A repeated Instance.
- *
- * InstanceForm is an utility class for repeated {@link Instance}. It is designed for shrinking
- * volume of network message I/O by storing {@link count repeated count}.
- *
- * @author Jeongho Nam
- */
- class InstanceForm extends protocol.Entity {
- /**
- * A duplicated Instance.
- */
- private instance;
- /**
- * Repeated count of the {@link instance}.
- */
- private count;
- /**
- * Default Constructor.
- */
- constructor(instance?: Instance, count?: number);
- /**
- * @inheritdoc
- */
- construct(xml: library.XML): void;
- private createInstance(xml);
- key(): any;
- getInstance(): Instance;
- getCount(): number;
- setCount(val: number): void;
- $name: string;
- $width: string;
- $height: string;
- $length: string;
- $count: string;
- /**
- * @inheritdoc
- */
- TAG(): string;
- /**
- * @inheritdoc
- */
- toXML(): library.XML;
- /**
- * Repeated {@link instance} to {@link InstanceArray}.
- *
- * @details
- *
Contains the {@link instance repeated instance} to an {@link InstanceArray} to make
- * {@link instance} to participate in the packing process. The returned {@link InstanceArray} will be
- * registered on {@link Packer.instanceArray}.
- *
- * @return An array of instance containing repeated {@link instance}.
- */
- toInstanceArray(): InstanceArray;
- }
-}
-declare namespace bws.packer {
- class WrapperArray extends protocol.EntityArrayCollection {
- /**
- * Default Constructor.
- */
- constructor();
- /**
- * @inheritdoc
- */
- createChild(xml: library.XML): Wrapper;
- /**
- * Get (calculate) price.
- */
- getPrice(): number;
- /**
- * Get (calculate) utilization rate.
- */
- getUtilization(): number;
- /**
- * @inheritdoc
- */
- TAG(): string;
- /**
- * @inheritdoc
- */
- CHILD_TAG(): string;
- }
-}
-declare namespace bws.packer {
- class GAWrapperArray extends WrapperArray {
- protected instanceArray: InstanceArray;
- protected result: std.HashMap;
- private price;
- /**
- * @brief Validity of this sequence list.
- */
- private valid;
- /**
- * Construct from instances.
- *
- * @param instanceArray Instances to be wrapped.
- */
- constructor(instanceArray: InstanceArray);
- /**
- * @brief Copy Constructor.
- */
- constructor(genes: GAWrapperArray);
- private constructResult();
- /**
- * @brief Get optimization result.
- *
- * @return result map.
- */
- getResult(): std.HashMap;
- less(obj: GAWrapperArray): boolean;
- }
-}
-declare namespace bws.packer {
- /**
- * An interface of physical 3D-instances.
- *
- * @author Jeongho Nam
- */
- interface Instance extends protocol.IEntity {
- /**
- * Get name.
- */
- getName(): string;
- /**
- * Get width, length on the X-axis in 3D.
- */
- getWidth(): number;
- /**
- * Get height, length on the Y-axis in 3D.
- */
- getHeight(): number;
- /**
- * Get length, length on the Z-axis in 3D.
- */
- getLength(): number;
- /**
- * Get (calculate) volume.
- *
- * @return width x height x length
- */
- getVolume(): number;
- /**
- * Set name.
- */
- setName(val: string): void;
- /**
- * Set width, length on the X-axis in 3D.
- */
- setWidth(val: number): void;
- /**
- * Set height, length on the Y-axis in 3D.
- */
- setHeight(val: number): void;
- /**
- * Set length, length on the Z-axis in 3D.
- */
- setLength(val: number): void;
- /**
- * A type, identifier of derived class.
- *
- * Derived types
- *
- * - {@link Product product}
- * - {@link Wrapper wrapper}
- *
- */
- TYPE(): string;
- }
-}
-declare namespace bws.packer {
- /**
- * An array of Instance objects.
- *
- * @author Jeongho Nam
- */
- class InstanceArray extends protocol.EntityArray {
- /**
- * Default Constructor.
- */
- constructor();
- /**
- * @inheritdoc
- */
- createChild(xml: library.XML): Instance;
- /**
- * @inheritdoc
- */
- TAG(): string;
- /**
- * @inheritdoc
- */
- CHILD_TAG(): string;
- }
-}
-declare namespace bws.packer {
- /**
- * @brief Packer, a solver of 3d bin packing with multiple wrappers.
- *
- * @details
- * Packer is a facade class supporting packing operations in user side. You can solve a packing problem
- * by constructing Packer class with {@link WrapperArray wrappers} and {@link InstanceArray instances} to
- * pack and executing {@link optimize Packer.optimize()} method.
- *
- * In background side, deducting packing solution, those algorithms are used.
- *
- *
- * @author Jeongho Nam
- */
- class Packer extends protocol.Entity {
- /**
- * Candidate wrappers who can contain instances.
- */
- protected wrapperArray: WrapperArray;
- /**
- * Instances trying to pack into the wrapper.
- */
- protected instanceArray: InstanceArray;
- /**
- * Default Constructor.
- */
- constructor();
- /**
- * Construct from members.
- *
- * @param wrapperArray Candidate wrappers who can contain instances.
- * @param instanceArray Instances to be packed into some wrappers.
- */
- constructor(wrapperArray: WrapperArray, instanceArray: InstanceArray);
- /**
- * @inheritdoc
- */
- construct(xml: library.XML): void;
- /**
- * Get wrapperArray.
- */
- getWrapperArray(): WrapperArray;
- /**
- * Get instanceArray.
- */
- getInstanceArray(): InstanceArray;
- /**
- * Deduct
- *
- */
- optimize(): WrapperArray;
- /**
- * @brief Initialize sequence list (gene_array).
- *
- * @details
- *
Deducts initial sequence list by such assumption:
- *
- *
- * - Cost of larger wrapper is less than smaller one, within framework of price per volume unit.
- *
- * - Wrapper Larger: (price: $1,000, volume: 100cm^3 -> price per volume unit: $10 / cm^3)
- * - Wrapper Smaller: (price: $700, volume: 50cm^3 -> price per volume unit: $14 / cm^3)
- * - Larger's cost is less than Smaller, within framework of price per volume unit
- *
- *
- *
- * Method {@link initGenes initGenes()} constructs {@link WrapperGroup WrapperGroups} corresponding
- * with the {@link wrapperArray} and allocates {@link instanceArray instances} to a {@link WrapperGroup},
- * has the smallest cost between containbles.
- *
- * After executing packing solution by {@link WrapperGroup.optimize WrapperGroup.optimize()}, trying to
- * {@link repack re-pack} each {@link WrapperGroup} to another type of {@link Wrapper}, deducts the best
- * solution between them. It's the initial sequence list of genetic algorithm.
- *
- * @return Initial sequence list.
- */
- protected initGenes(): GAWrapperArray;
- /**
- * Try to repack each wrappers to another type.
- *
- * @param $wrappers Wrappers to repack.
- * @return Re-packed wrappers.
- */
- protected repack($wrappers: WrapperArray): WrapperArray;
- /**
- * @inheritdoc
- */
- TAG(): string;
- /**
- * @inheritdoc
- */
- toXML(): library.XML;
- }
-}
-declare namespace bws.packer {
- /**
- * A product.
- *
- * @author Jeongho Nam
- */
- class Product extends protocol.Entity implements Instance {
- /**
- * Name, key of the Product.
- *
- * The name must be unique because a name identifies a {@link Product}.
- */
- protected name: string;
- /**
- * Width of the Product, length on the X-axis in 3D.
- */
- protected width: number;
- /**
- * Height of the Product, length on the Y-axis in 3D.
- */
- protected height: number;
- /**
- * Length of the Product, length on the Z-axis in 3D.
- */
- protected length: number;
- /**
- * Default Constructor.
- */
- constructor();
- /**
- * Construct from members.
- *
- * @param name Name, identifier of the Product.
- * @param width Width, length on the X-axis in 3D.
- * @param height Height, length on the Y-axis in 3D.
- * @param length Length, length on the Z-axis in 3D.
- */
- constructor(name: string, width: number, height: number, length: number);
- /**
- * Key of a Product is its name.
- */
- key(): any;
- /**
- * @inheritdoc
- */
- getName(): string;
- /**
- * @inheritdoc
- */
- getWidth(): number;
- /**
- * @inheritdoc
- */
- getHeight(): number;
- /**
- * @inheritdoc
- */
- getLength(): number;
- /**
- * @inheritdoc
- */
- getVolume(): number;
- /**
- * @inheritdoc
- */
- setName(val: string): void;
- /**
- * @inheritdoc
- */
- setWidth(val: number): void;
- /**
- * @inheritdoc
- */
- setHeight(val: number): void;
- /**
- * @inheritdoc
- */
- setLength(val: number): void;
- /**
- * @inheritdoc
- */
- TYPE(): string;
- /**
- * @inheritdoc
- */
- TAG(): string;
- /**
- * @inheritdoc
- */
- toXML(): library.XML;
- }
-}
-declare namespace bws.packer {
- /**
- * Wrap represents an act wrap(ping).
- *
- * {@link Wrap} is a class represents an act wrapping an {@link Instance} to an {@link Wrapper}.
- * To represent the relationship, Wrap uses Bridge and Capsular patterns to links and intermediates
- * relationship between Wrapper and Instance.
- *
- * Wrap also helps packing optimization and 3d-visualization with its own members
- * {@link orientation} and position variables {@link x}, {@link y} and {@link z}.
- *
- * @author Jeongho Nam
- */
- class Wrap extends protocol.Entity {
- /**
- * A wrapper wrapping the {@link instance}.
- */
- protected wrapper: Wrapper;
- /**
- * An instance wrapped into the {@link wrapper}.
- */
- protected instance: Instance;
- /**
- * Coordinate-X of the instance placement in the wrapper.
- */
- protected x: number;
- /**
- * Coordinate-Y of the instance placement in the wrapper.
- */
- protected y: number;
- /**
- * Coordinate-Z of the instance placement in the wrapper.
- */
- protected z: number;
- /**
- * Placement orientation of wrapped {@link instance}.
- */
- protected orientation: number;
- /**
- * Construct from a Wrapper.
- *
- * @param wrapper A wrapper who will contain an instance.
- */
- constructor(wrapper: Wrapper);
- /**
- * Construct from a Wrapper and Instance with its position and default orientation 1.
- *
- * @param wrapper A wrapper who contains the instance.
- * @param instance An instance contained into the wrapper.
- * @param x Coordinate-X of the {@link instance} placement in the {@link wrapper}.
- * @param y Coordinate-Y of the {@link instance} placement in the {@link wrapper}.
- * @param z Coordinate-Z of the {@link instance} placement in the {@link wrapper}.
- */
- constructor(wrapper: Wrapper, instance: Instance, x: number, y: number, z: number);
- /**
- * Construct from a Wrapper and Instance with its position and orientation.
- *
- * @param wrapper A wrapper who contains the instance.
- * @param instance An instance contained into the wrapper.
- * @param x Coordinate-X of the {@link instance} placement in the {@link wrapper}.
- * @param y Coordinate-Y of the {@link instance} placement in the {@link wrapper}.
- * @param z Coordinate-Z of the {@link instance} placement in the {@link wrapper}.
- * @param orientation Placement orientation of wrapped {@link instance}.
- */
- constructor(wrapper: Wrapper, instance: Instance, x: number, y: number, z: number, orientation: number);
- /**
- * @inheritdoc
- */
- construct(xml: library.XML): void;
- /**
- * Factory method of wrapped Instance.
- *
- * @param type Type of contained Instance's type.
- */
- protected createInstance(type: string): Instance;
- /**
- * Set orientation.
- *
- * @param orientation Orientation code (1 to 6).
- */
- setOrientation(orientation: number): void;
- /**
- * Set position.
- *
- * @param x Coordinate-X of the instance placement in the wrapper.
- * @param y Coordinate-Y of the instance placement in the wrapper.
- * @param z Coordinate-Z of the instance placement in the wrapper.
- */
- setPosition(x: number, y: number, z: number): void;
- /**
- * @brief Estimate orientation by given size.
- *
- * @param width Width by placement.
- * @param height Height by placement.
- * @param length Length by placement.
- */
- estimateOrientation(width: number, height: number, length: number): void;
- /**
- * @brief Orientation change is occured in level of the packer.
- *
- * @details orientation Packer's new orientation.
- */
- changeWrapperOrientation(orientation: number): void;
- /**
- * Get wrapper.
- */
- getWrapper(): Wrapper;
- /**
- * Get instance.
- */
- getInstance(): Instance;
- /**
- * Get x.
- */
- getX(): number;
- /**
- * Get y.
- */
- getY(): number;
- /**
- * Get z.
- */
- getZ(): number;
- /**
- * Get orientation.
- */
- getOrientation(): number;
- /**
- * Get width.
- */
- getLayoutWidth(): number;
- /**
- * Get height.
- */
- getLayoutHeight(): number;
- /**
- * Get length.
- */
- getLength(): number;
- /**
- * Get volume.
- */
- getVolume(): number;
- readonly $instanceName: string;
- readonly $layoutScale: string;
- readonly $position: string;
- /**
- * @inheritdoc
- */
- TAG(): string;
- /**
- * @inheritdoc
- */
- toXML(): library.XML;
- }
-}
-declare namespace bws.packer {
- /**
- * A wrapper wrapping instances.
- *
- * @author Jeongho Nam
- */
- class Wrapper extends protocol.EntityDeque implements Instance {
- /**
- * Name, key of the Wrapper.
- *
- * The name represents a type of Wrapper and identifies the Wrapper.
- */
- protected name: string;
- /**
- * Price, cost of using an Wrapper.
- */
- protected price: number;
- /**
- * Width of the Wrapper, length on the X-axis in 3D.
- */
- protected width: number;
- /**
- * Height of the Wrapper, length on the Y-axis in 3D.
- */
- protected height: number;
- /**
- * Length of the Wrapper, length on the Z-axis in 3D.
- */
- protected length: number;
- /**
- * Thickness, margin of a Wrapper causes shrinkness of containable volume.
- *
- * The thickness reduces each dimension's containable size (dimension - 2*thickness),
- * so finally, it reduces total containable volume (-8 * thickness^3).
- */
- protected thickness: number;
- /**
- * Default Constructor.
- */
- constructor();
- /**
- * Copy Constructor.
- */
- constructor(wrapper: Wrapper);
- /**
- * Construct from members.
- *
- * @param name Name, identifier of a Wrapper.
- * @param price Price, issued cost for a type of the Wrapper.
- * @param width Width, dimensional length on the X-axis in 3D.
- * @param height Height, dimensional length on the Y-axis in 3D.
- * @param length Length, dimensional length on the Z-axis in 3D.
- * @param thickness A thickness causes shrinkness on containable volume.
- */
- constructor(name: string, price: number, width: number, height: number, length: number, thickness: number);
- /**
- * @inheritdoc
- */
- createChild(xml: library.XML): Wrap;
- /**
- * Key of a Wrapper is its name.
- */
- key(): any;
- /**
- * Get name.
- */
- getName(): string;
- /**
- * Get price.
- */
- getPrice(): number;
- /**
- * Get width, length on X-axis in 3D.
- */
- getWidth(): number;
- /**
- * Get height, length on Y-axis in 3D.
- */
- getHeight(): number;
- /**
- * Get length, length on Z-axis in 3D.
- */
- getLength(): number;
- /**
- * Get thickness.
- */
- getThickness(): number;
- /**
- * Get (calculate) containable width, length on the X-axis in 3D.
- *
- * Calculates containable width considering the {@link thickness}.
- *
- * @return width - (2 x thickness)
- */
- getContainableWidth(): number;
- /**
- * Get (calculate) containable height, length on the Y-axis in 3D.
- *
- * Calculates containable height considering the {@link thickness}.
- *
- * @return height - (2 x thickness)
- */
- getContainableHeight(): number;
- /**
- * Get (calculate) containable length, length on the Z-axis in 3D.
- *
- * Calculates containable length considering the {@link thickness}.
- *
- * @return length - (2 x thickness)
- */
- getContainableLength(): number;
- /**
- * Get (calculate) volume.
- *
- * Notice
- * If {@link thickness} of the Wrapper is not 0, the volume does not mean containable volume.
- * In that case, use {@link containableVolume} instead.
- *
- * @return width x height x length
- */
- getVolume(): number;
- /**
- * Get (calculate) containable volume.
- *
- * Calculates containable volume considering the {@link thickness}.
- *
- * @return volume - {(2 x thickness) ^ 3}
- */
- getContainableVolume(): number;
- /**
- * Get utilization ratio of containable volume.
- *
- * @return utilization ratio.
- */
- getUtilization(): number;
- equals(obj: Wrapper): boolean;
- /**
- * Wrapper is enough greater?
- *
- * Test whether the Wrapper is enough greater than an Instance to contain.
- *
- * @param instance An Instance to test.
- * @return Enough greater or not.
- */
- containable(instance: Instance): boolean;
- /**
- * @inheritdoc
- */
- setName(val: string): void;
- /**
- * Set price.
- */
- setPrice(val: number): void;
- /**
- * @inheritdoc
- */
- setWidth(val: number): void;
- /**
- * @inheritdoc
- */
- setHeight(val: number): void;
- /**
- * @inheritdoc
- */
- setLength(val: number): void;
- /**
- * Set thickness.
- */
- setThickness(val: number): void;
- $name: string;
- $price: string;
- $width: string;
- $height: string;
- $length: string;
- $thickness: string;
- readonly $scale: string;
- readonly $spaceUtilization: string;
- /**
- * @inheritdoc
- */
- TYPE(): string;
- /**
- * @inheritdoc
- */
- TAG(): string;
- /**
- * @inheritdoc
- */
- CHILD_TAG(): string;
- /**
- * @inheritdoc
- */
- toXML(): library.XML;
- }
-}
-declare namespace bws.packer {
- /**
- * A group of {@link Wrapper Wrappers} with same type.
- *
- * @author Jeongho Nam
- */
- class WrapperGroup extends WrapperArray {
- /**
- * A sample, standard of the WrapperGroup.
- *
- * The sample represents what type of Wrappers are grouped into the WrapperGroup.
- */
- protected sample: Wrapper;
- /**
- * Allocated instances.
- */
- protected allocatedInstanceArray: InstanceArray;
- /**
- * Default Constructor.
- */
- constructor();
- /**
- * Copy Constructor.
- */
- constructor(wrapperGroup: WrapperGroup);
- /**
- * Construct from a sample.
- *
- * @param sample A sample, standard of the WrapperGroup.
- */
- constructor(sample: Wrapper);
- /**
- * Construct from members of the {@link sample}.
- *
- * @param name Name, identifier of the sample.
- * @param price Price, issued cost for a type of the sample.
- * @param width Width, dimensional length on the X-axis in 3D, of the sample.
- * @param height Height, dimensional length on the Y-axis in 3D, of the sample.
- * @param length Length, dimensional length on the Z-axis in 3D, of the sample.
- * @param thickness A thickness, causes shrinkness on containable volume, of the sample.
- */
- constructor(name: string, price: number, width: number, height: number, length: number, thickness: number);
- /**
- * Key of a WrapperGroup is dependent on its sample.
- */
- key(): any;
- /**
- * Get sample.
- */
- getSample(): Wrapper;
- /**
- * Get allocated instances.
- */
- getAllocatedInstanceArray(): InstanceArray;
- /**
- * Get (calculate) price.
- *
- * @return (Price of the sample) x (numbers of children Wrappers)
- */
- getPrice(): number;
- /**
- * @inheritdoc
- */
- getUtilization(): number;
- /**
- * Allocate instance(s) to the WrapperGroup.
- *
- * Inspect the instance is enough small to be wrapped into an empty wrapper. If the instance
- * is enough small, registers the instance (or repeated instances) to the {@link reserveds} and
- * returns true. If the instance is too large to be capsuled, returns false.
- *
- * Note
- * The word the instance is enough small to be wrapped into the empty wrapper means
- * the instance can be contained into an empty, a new wrapper contaning nothing literally.
- *
- * In the method allocate(), it doesn't consider how many instances are wrapped into ordinary
- * wrapper and how much volumes are consumed.
- *
- * @param instance An Instance to allocate.
- * @param n Repeating number of the instance.
- *
- * @return Whether the instance is enough small to be wrapped into a (new) wrapper
- * of same type with the sample.
- */
- allocate(instance: Instance, n?: number): boolean;
- /**
- * Run optimization in level of the group.
- *
- * The optimization routine begins by creating a {@link Wrapper} like the {@link sample}. Then
- * try to pack {@link allocatedInstanceArray allocated instances} to the {@link Wrapper} as a lot as
- * possible. If there're some {@link Wrappers} can't be packed by overloading, then create a new
- * {@link Wrapper} again and try to pack {@link allocatedInstanceArray instances} again, too.
- *
- * Repeats those steps until all {@link alloctedInstanceArray instances} are {@link Wrap packed}
- * so that there's not any {@link Instance instance} left.
- *
- * Warning
- * When call this {@link optimize optimize()} method, ordinary children {@link Wrapper} objects
- * in the {@link WrapperGroup} will be substituted with the newly optimized {@link Wrapper} objects.
- */
- optimize(): void;
- /**
- * Wrap allocated instances into a new {@link Wrapper}.
- *
- * {@link Wrap Wraps} instances to a new Wrapper which is copied from the sample.
- * After the wrapping is done, the new {@link Wrapper} is registered to the {@link WrapperGroup}
- * as a child and instances failed to wrap by overloading is returned.
- *
- * @param instanceArray instances to {@link Wrap wrap} into a new {@link Wrapper}.
- *
- * @return Instances failed to {@link Wrap wrap} by overloading.
- * @see boxologic
- */
- private pack(instanceArray);
- /**
- * @inheritdoc
- */
- TAG(): string;
- }
-}
diff --git a/types/3d-bin-packing/tsconfig.json b/types/3d-bin-packing/tsconfig.json
deleted file mode 100644
index 18e4645ac9..0000000000
--- a/types/3d-bin-packing/tsconfig.json
+++ /dev/null
@@ -1,23 +0,0 @@
-{
- "compilerOptions": {
- "module": "commonjs",
- "lib": [
- "es6",
- "dom"
- ],
- "noImplicitAny": true,
- "noImplicitThis": true,
- "strictNullChecks": false,
- "baseUrl": "../",
- "typeRoots": [
- "../"
- ],
- "types": [],
- "noEmit": true,
- "forceConsistentCasingInFileNames": true
- },
- "files": [
- "index.d.ts",
- "3d-bin-packing-tests.ts"
- ]
-}
\ No newline at end of file
diff --git a/types/abbrev/abbrev-tests.ts b/types/abbrev/abbrev-tests.ts
new file mode 100644
index 0000000000..b4f892e9e3
--- /dev/null
+++ b/types/abbrev/abbrev-tests.ts
@@ -0,0 +1,13 @@
+import abbrev = require('abbrev');
+
+let abbrs: { [abbreviation: string]: string; };
+abbrs = abbrev();
+abbrs = abbrev('foo', 'fool', 'folding', 'flop');
+abbrs = abbrev(['foo', 'fool', 'folding', 'flop']);
+
+abbrev.monkeyPatch();
+
+abbrs = [].abbrev();
+const roArr: ReadonlyArray = [];
+abbrs = roArr.abbrev();
+abbrs = ({}).abbrev();
diff --git a/types/abbrev/index.d.ts b/types/abbrev/index.d.ts
new file mode 100644
index 0000000000..0d55334d3f
--- /dev/null
+++ b/types/abbrev/index.d.ts
@@ -0,0 +1,27 @@
+// Type definitions for abbrev 1.1
+// Project: https://github.com/isaacs/abbrev-js#readme
+// Definitions by: BendingBender
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export = abbrev;
+
+declare function abbrev(words: string[]): {[abbreviation: string]: string};
+declare function abbrev(...words: string[]): {[abbreviation: string]: string};
+
+declare namespace abbrev {
+ function monkeyPatch(): void;
+}
+
+declare global {
+ interface Array {
+ abbrev(): {[abbreviation: string]: string};
+ }
+
+ interface ReadonlyArray {
+ abbrev(): {[abbreviation: string]: string};
+ }
+
+ interface Object {
+ abbrev(): {[abbreviation: string]: string};
+ }
+}
diff --git a/types/abbrev/tsconfig.json b/types/abbrev/tsconfig.json
new file mode 100644
index 0000000000..95c20ed32a
--- /dev/null
+++ b/types/abbrev/tsconfig.json
@@ -0,0 +1,22 @@
+{
+ "compilerOptions": {
+ "module": "commonjs",
+ "lib": [
+ "es6"
+ ],
+ "noImplicitAny": true,
+ "noImplicitThis": true,
+ "strictNullChecks": true,
+ "baseUrl": "../",
+ "typeRoots": [
+ "../"
+ ],
+ "types": [],
+ "noEmit": true,
+ "forceConsistentCasingInFileNames": true
+ },
+ "files": [
+ "index.d.ts",
+ "abbrev-tests.ts"
+ ]
+}
diff --git a/types/raw-body/tslint.json b/types/abbrev/tslint.json
similarity index 100%
rename from types/raw-body/tslint.json
rename to types/abbrev/tslint.json
diff --git a/types/ably/index.d.ts b/types/ably/index.d.ts
index 7bfc2338b6..3a150257ba 100644
--- a/types/ably/index.d.ts
+++ b/types/ably/index.d.ts
@@ -1,6 +1,6 @@
// Type definitions for Ably Realtime and Rest client library 0.9
// Project: https://www.ably.io/
-// Definitions by: Ably
+// Definitions by: Ably
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
export namespace ablyLib {
@@ -287,7 +287,7 @@ export namespace ablyLib {
}
// Common Listeners
- type paginatedResultCallback = (error: ErrorInfo, results: PaginatedResult ) => void;
+ type paginatedResultCallback = (error: ErrorInfo, results: PaginatedResult) => void;
type standardCallback = (error: ErrorInfo, results: any) => void;
type messageCallback = (message: T) => void;
type errorCallback = (error: ErrorInfo) => void;
@@ -410,7 +410,7 @@ export namespace ablyLib {
state: ConnectionState;
close: () => void;
connect: () => void;
- ping: (callback?: (error: ErrorInfo, responseTime: number ) => void ) => void;
+ ping: (callback?: (error: ErrorInfo, responseTime: number) => void) => void;
}
class Stats {
diff --git a/types/accounting/index.d.ts b/types/accounting/index.d.ts
index 9a990a6519..8a9feca611 100644
--- a/types/accounting/index.d.ts
+++ b/types/accounting/index.d.ts
@@ -1,7 +1,7 @@
// Type definitions for accounting.js 0.4
// Project: http://openexchangerates.github.io/accounting.js/
-// Definitions by: Sergey Gerasimov
-// Christopher Eck
+// Definitions by: Sergey Gerasimov
+// Christopher Eck
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
declare namespace accounting {
diff --git a/types/activex-adodb/activex-adodb-tests.ts b/types/activex-adodb/activex-adodb-tests.ts
index cadb01c15e..22680d963c 100644
--- a/types/activex-adodb/activex-adodb-tests.ts
+++ b/types/activex-adodb/activex-adodb-tests.ts
@@ -14,9 +14,7 @@ let obj5 = new ActiveXObject('ADODB.Stream');
let pathToExcelFile = 'C:\\path\\to\\excel\\file.xlsx';
let conn = new ActiveXObject('ADODB.Connection');
conn.Provider = 'Microsoft.ACE.OLEDB.12.0';
-conn.ConnectionString =
- 'Data Source="' + pathToExcelFile + '";' +
- 'Extended Properties="Excel 12.0;HDR=Yes"';
+conn.ConnectionString = `Data Source="${pathToExcelFile}";Extended Properties="Excel 12.0;HDR=Yes"`;
conn.Open();
// create a Command to access the data
diff --git a/types/activex-scripting/activex-scripting-tests.ts b/types/activex-scripting/activex-scripting-tests.ts
index cc14a421ff..2297548b81 100644
--- a/types/activex-scripting/activex-scripting-tests.ts
+++ b/types/activex-scripting/activex-scripting-tests.ts
@@ -1,7 +1,7 @@
// source -- https://msdn.microsoft.com/en-us/library/ebkhfaaz.aspx
// Generates a string describing the drive type of a given Drive object.
-let showDriveType = (drive: Scripting.Drive) => {
+function showDriveType(drive: Scripting.Drive) {
switch (drive.DriveType) {
case Scripting.DriveTypeConst.Removable:
return 'Removeable';
@@ -16,15 +16,15 @@ let showDriveType = (drive: Scripting.Drive) => {
default:
return 'Unknown';
}
-};
+}
// Generates a string describing the attributes of a file or folder.
-let showFileAttributes = (file: Scripting.File) => {
- let attr = file.Attributes;
+function showFileAttributes(file: Scripting.File) {
+ const attr = file.Attributes;
if (attr === 0) {
return 'Normal';
}
- let attributeStrings: string[] = [];
+ const attributeStrings: string[] = [];
if (attr & Scripting.FileAttribute.Directory) { attributeStrings.push('Directory'); }
if (attr & Scripting.FileAttribute.ReadOnly) { attributeStrings.push('Read-only'); }
if (attr & Scripting.FileAttribute.Hidden) { attributeStrings.push('Hidden'); }
@@ -34,22 +34,22 @@ let showFileAttributes = (file: Scripting.File) => {
if (attr & Scripting.FileAttribute.Alias) { attributeStrings.push('Alias'); }
if (attr & Scripting.FileAttribute.Compressed) { attributeStrings.push('Compressed'); }
return attributeStrings.join(',');
-};
+}
// source --https://msdn.microsoft.com/en-us/library/ts2t8ybh(v=vs.84).aspx
-let showFreeSpace = (drvPath: string) => {
- let fso = new ActiveXObject('Scripting.FileSystemObject');
- let d = fso.GetDrive(fso.GetDriveName(drvPath));
- let s = 'Drive ' + drvPath + ' - ';
+function showFreeSpace(drvPath: string) {
+ const fso = new ActiveXObject('Scripting.FileSystemObject');
+ const d = fso.GetDrive(fso.GetDriveName(drvPath));
+ let s = `Drive ${drvPath} - `;
s += d.VolumeName + '
';
- s += 'Free Space: ' + d.FreeSpace / 1024 + ' Kbytes';
+ s += `Free Space: ${d.FreeSpace / 1024} Kbytes`;
return (s);
-};
+}
// source -- https://msdn.microsoft.com/en-us/library/kaf6yaft(v=vs.84).aspx
-let getALine = (filespec: string) => {
- let fso = new ActiveXObject('Scripting.FileSystemObject');
- let file = fso.OpenTextFile(filespec, Scripting.IOMode.ForReading, false);
+function getALine(filespec: string) {
+ const fso = new ActiveXObject('Scripting.FileSystemObject');
+ const file = fso.OpenTextFile(filespec, Scripting.IOMode.ForReading, false);
let s = '';
while (!file.AtEndOfLine) {
@@ -57,4 +57,4 @@ let getALine = (filespec: string) => {
}
file.Close();
return (s);
-};
+}
diff --git a/types/activex-wia/activex-wia-tests.ts b/types/activex-wia/activex-wia-tests.ts
index 8384291f5d..d8046ef319 100644
--- a/types/activex-wia/activex-wia-tests.ts
+++ b/types/activex-wia/activex-wia-tests.ts
@@ -7,7 +7,7 @@ let img = commonDialog.ShowAcquireImage();
// when DefinitelyTyped supports Typescript 2.4 -- end of July 2017, replace these:
let jpegFormatID = '{B96B3CAE-0728-11D3-9D7B-0000F81EF32E}';
if (img.FormatID !== jpegFormatID) {
- let ip = new ActiveXObject('WIA.ImageProcess');
+ const ip = new ActiveXObject('WIA.ImageProcess');
ip.Filters.Add(ip.FilterInfos.Item('Convert').FilterID);
ip.Filters.Item(1).Properties.Item('FormatID').Value = jpegFormatID;
img = ip.Apply(img);
@@ -24,8 +24,8 @@ if (img.FormatID !== jpegFormatID) {
let dev = commonDialog.ShowSelectDevice();
if (dev.Type === WIA.WiaDeviceType.CameraDeviceType) {
// when DefinitelyTyped supports Typescript 2.4 -- end of July 2017, replace these:
- let commandID = '{AF933CAC-ACAD-11D2-A093-00C04F72DC3C}';
- let itm = dev.ExecuteCommand(commandID);
+ const commandID = '{AF933CAC-ACAD-11D2-A093-00C04F72DC3C}';
+ const itm = dev.ExecuteCommand(commandID);
// with this:
// let itm = dev.ExecuteCommand(WIA.CommandID.wiaCommandTakePicture);
@@ -36,15 +36,15 @@ dev = commonDialog.ShowSelectDevice();
let e = new Enumerator(dev.Properties); // no foreach over ActiveX collections
e.moveFirst();
while (!e.atEnd()) {
- let p = e.item();
- let s = p.Name + ' (' + p.PropertyID + ') = ';
+ const p = e.item();
+ let s = `${p.Name} (${p.PropertyID}) = `;
if (p.IsVector) {
s += '[vector of data]';
} else {
s += p.Value;
if (p.SubType !== WIA.WiaSubType.UnspecifiedSubType) {
if (p.Value !== p.SubTypeDefault) {
- s += ' (Default = ' + p.SubTypeDefault + ')';
+ s += ` (Default = ${p.SubTypeDefault})`;
}
}
}
@@ -60,7 +60,7 @@ while (!e.atEnd()) {
} else {
s += ' [valid values include: ';
}
- let count = p.SubTypeValues.Count;
+ const count = p.SubTypeValues.Count;
for (let i = 1; i <= count; i++) {
s += p.SubTypeValues.Item(i);
if (i < count) {
@@ -70,7 +70,7 @@ while (!e.atEnd()) {
s += ']';
break;
case WIA.WiaSubType.RangeSubType:
- s += ' [valid values in the range from ' + p.SubTypeMin + ' to ' + p.SubTypeMax + ' in increments of ' + p.SubTypeStep + ']';
+ s += ` [valid values in the range from ${p.SubTypeMin} to ${p.SubTypeMax} in increments of ${p.SubTypeStep}]`;
break;
}
}
diff --git a/types/adal/index.d.ts b/types/adal/index.d.ts
index 2150716b17..43655efbbb 100644
--- a/types/adal/index.d.ts
+++ b/types/adal/index.d.ts
@@ -31,6 +31,8 @@ declare namespace adal {
resource?: string;
extraQueryParameter?: string;
navigateToLoginRequestUrl?: boolean;
+ logOutUri?: string;
+ isAngular?: boolean;
}
interface User {
diff --git a/types/adone/adone-tests.ts b/types/adone/adone-tests.ts
new file mode 100644
index 0000000000..861660ee89
--- /dev/null
+++ b/types/adone/adone-tests.ts
@@ -0,0 +1,3 @@
+// Actual tests inside ./test/
+
+const a: string = adone.ok;
diff --git a/types/adone/adone.d.ts b/types/adone/adone.d.ts
new file mode 100644
index 0000000000..a4f102752c
--- /dev/null
+++ b/types/adone/adone.d.ts
@@ -0,0 +1,85 @@
+///
+
+declare const _null: symbol;
+export { _null as null };
+export function noop(): void;
+export function identity(x: T): T;
+export function truly(): true;
+export function falsely(): false;
+export const ok: "OK";
+export const bad: "BAD";
+export const exts: [".js", ".tjs", ".ajs"];
+export function log(...args: any[]): void;
+export function fatal(...args: any[]): void;
+export function error(...args: any[]): void;
+export function warn(...args: any[]): void;
+export function info(...args: any[]): void;
+export function debug(...args: any[]): void;
+export function trace(...args: any[]): void;
+export function o(...props: any[]): object;
+export const Date: typeof global.Date;
+export const hrtime: typeof global.process.hrtime;
+export const setTimeout: typeof global.setTimeout;
+export const setInterval: typeof global.setInterval;
+export const setImmediate: typeof global.setImmediate;
+export const clearTimeout: typeof global.clearTimeout;
+export const clearInterval: typeof global.clearInterval;
+export const clearImmediate: typeof global.clearImmediate;
+interface LazifyOptions {
+ configurable: boolean;
+}
+export function lazify(modules: object, obj?: object, require?: (path: string) => any, options?: LazifyOptions): object;
+interface Tag {
+ set(Class: object, tag: string): void;
+ has(obj: object, tag: string): boolean;
+ define(tag: string, predicate?: string): void;
+ SUBSYSTEM: symbol;
+ APPLICATION: symbol;
+ TRANSFORM: symbol;
+ CORE_STREAM: symbol;
+ LOGGER: symbol;
+ LONG: symbol;
+ BIGNUMBER: symbol;
+ EXBUFFER: symbol;
+ EXDATE: symbol;
+ CONFIGURATION: symbol;
+ GENESIS_NETRON: symbol;
+ GENESIS_PEER: symbol;
+ NETRON: symbol;
+ NETRON_PEER: symbol;
+ NETRON_ADAPTER: symbol;
+ NETRON_DEFINITION: symbol;
+ NETRON_DEFINITIONS: symbol;
+ NETRON_REFERENCE: symbol;
+ NETRON_INTERFACE: symbol;
+ NETRON_STUB: symbol;
+ NETRON_REMOTESTUB: symbol;
+ NETRON_STREAM: symbol;
+ FAST_STREAM: symbol;
+ FAST_FS_STREAM: symbol;
+ FAST_FS_MAP_STREAM: symbol;
+}
+export const tag: Tag;
+export function run(App: object, ignoreArgs?: boolean): Promise;
+export function bind(libName: string): object;
+export function getAssetAbsolutePath(relPath: string): string;
+export function loadAsset(relPath: string): string | Buffer;
+export function require(path: string): object;
+export const package: object;
+
+import * as std from "./glosses/std";
+export { std };
+
+export * from "./glosses/common";
+export * from "./glosses/math";
+export * from "./glosses/utils";
+export * from "./glosses/assertion";
+export * from "./glosses/promise";
+export * from "./glosses/shani";
+
+import "./glosses/shani-global";
+
+export const assert: adone.assertion.I.AssertFunction;
+export const expect: adone.assertion.I.ExpectFunction;
+
+export as namespace adone;
diff --git a/types/adone/glosses/assertion.d.ts b/types/adone/glosses/assertion.d.ts
new file mode 100644
index 0000000000..4e8bfc593a
--- /dev/null
+++ b/types/adone/glosses/assertion.d.ts
@@ -0,0 +1,1074 @@
+import adone from "adone";
+
+/**
+ * assertion functions
+ */
+export namespace assertion {
+ namespace I {
+ interface assertion {
+ AssertionError: AssertionError;
+ config: Config;
+ use: UseFunction;
+ loadMockInterface: LoadInterfaceFunction;
+ loadExpectInterface: LoadInterfaceFunction;
+ loadAssertInterface: LoadInterfaceFunction;
+ assert: AssertFunction;
+ expect: ExpectFunction;
+ }
+
+ interface Config {
+ /**
+ * Include stack in Assertion error message
+ */
+ includeStack: boolean;
+ /**
+ * Include `showDiff` flag in the thrown errors
+ */
+ showDiff: boolean;
+ /**
+ * Length threshold for actual and expected values in assertion errors
+ */
+ truncateThreshold: number;
+ /**
+ * use Proxy to throw an error when a non-existent property is read
+ */
+ useProxy: boolean;
+ /**
+ * properties that should be ignored instead of throwing an error if they do not exist on the assertion
+ */
+ proxyExcludedKeys: string[];
+ }
+
+ type PossibleTypes = adone.util.I.PossibleTypes | "array";
+
+ type UseFunction = (fn: () => void) => assertion;
+
+ type LoadInterfaceFunction = () => assertion;
+
+ interface AssertFunction {
+ /**
+ * Asserts that value is truthy
+ */
+ (value: any, message?: string): void;
+ /**
+ * Throws an AssertionError, like node.js
+ */
+ fail(actual?: any, expected?: any, message?: string, operator?: any): void;
+ /**
+ * Asserts that value is truthy
+ */
+ isOk(value: any, message?: string): void;
+ /**
+ * Asserts that value is truthy
+ */
+ ok(value: any, message?: string): void;
+ /**
+ * Asserts that value is falsy
+ */
+ isNotOk(value: any, message?: string): void;
+ /**
+ * Asserts that value is falsy
+ */
+ notOk(value: any, message?: string): void;
+ /**
+ * Asserts non-strict equality
+ */
+ equal(actual: any, expected: any, message?: string): void;
+ /**
+ * Asserts non-strict inequality
+ */
+ notEqual(actual: any, expected: any, message?: string): void;
+ /**
+ * Asserts strict equality
+ */
+ strictEqual(actual: any, expected: any, message?: string): void;
+ /**
+ * Asserts strict inequality
+ */
+ notStrictEqual(actual: any, expected: any, message?: string): void;
+ /**
+ * Asserts that actual is deeply equal to expected
+ */
+ deepEqual(actual: any, expected: any, message?: string): void;
+ /**
+ * Asserts that actual is deeply equal to expected
+ */
+ deepStrictEqual(actual: any, expected: any, message?: string): void;
+ /**
+ * Asserts that actual and expected have the same length and the same members (===)
+ */
+ equalArrays(actual: any[], expected: any[], message?: string): void;
+ /**
+ * Asserts that actual is not deeply equal to expected
+ */
+ notDeepEqual(actual: any, expected: any, message?: string): void;
+ /**
+ * Asserts that value > above
+ */
+ isAbove(value: any, above: any, message?: string): void;
+ /**
+ * Asserts that value >= atLeast
+ */
+ isAtLeast(value: any, atLeast: any, message?: string): void;
+ /**
+ * Asserts that value < below
+ */
+ isBelow(value: any, below: any, message?: string): void;
+ /**
+ * Asserts that value <= atMost
+ */
+ isAtMost(value: any, atMost: any, message?: string): void;
+ /**
+ * Asserts that value is true
+ */
+ isTrue(value: any, message?: string): void;
+ /**
+ * Asserts that value is not true
+ */
+ isNotTrue(value: any, message?: string): void;
+ /**
+ * Asserts that value is false
+ */
+ isFalse(value: any, message?: string): void;
+ /**
+ * Asserts that value is not false
+ */
+ isNotFalse(value: any, message?: string): void;
+ /**
+ * Asserts that value is null
+ */
+ isNull(value: any, message?: string): void;
+ /**
+ * Asserts that valus is not null
+ */
+ isNotNull(value: any, message?: string): void;
+ /**
+ * Asserts that value is NaN
+ */
+ isNaN(value: any, message?: string): void;
+ /**
+ * Asserts that value is not NaN
+ */
+ isNotNaN(value: any, message?: string): void;
+ /**
+ * Asserts that value is neither null nor undefined
+ */
+ exists(value: any, message?: string): void;
+ /**
+ * Asserts that value is either null or undefined
+ */
+ notExists(value: any, message?: string): void;
+ /**
+ * Asserts that value is undefined
+ */
+ isUndefined(value: any, message?: string): void;
+ /**
+ * Asserts that value is not undefined
+ */
+ isDefined(value: any, message?: string): void;
+ /**
+ * Asserts that value is a function
+ */
+ isFunction(value: any, message?: string): void;
+ /**
+ * Asserts that value is not a function
+ */
+ isNotFunction(value: any, message?: string): void;
+ /**
+ * Asserts that value is an object of type Object
+ */
+ isObject(value: any, message?: string): void;
+ /**
+ * Asserts that value is not an object of type Object
+ */
+ isNotObject(value: any, message?: string): void;
+ /**
+ * Asserts that value is an array
+ */
+ isArray(value: any, message?: string): void;
+ /**
+ * Asserts that value is not an array
+ */
+ isNotArray(value: any, message?: string): void;
+ /**
+ * Asserts that value is a string
+ */
+ isString(value: any, message?: string): void;
+ /**
+ * Asserts that value is not a string
+ */
+ isNotString(value: any, message?: string): void;
+ /**
+ * Asserts that value is a number
+ */
+ isNumber(value: any, message?: string): void;
+ /**
+ * Asserts that value is not a number
+ */
+ isNotNumber(value: any, message?: string): void;
+ /**
+ * Asserts that value is a finite number
+ */
+ isFinite(value: any, message?: string): void;
+ /**
+ * Asserts that value is a boolean
+ */
+ isBoolean(value: any, message?: string): void;
+ /**
+ * Asserts that value is not a boolean
+ */
+ isNotBoolean(value: any, message?: string): void;
+ /**
+ * Asserts that value's type is `type`
+ */
+ typeOf(value: any, type: I.PossibleTypes, message?: string): void;
+ typeOf(value: any, type: string, message?: string): void;
+ /**
+ * Assert that value's type is not `type`
+ */
+ notTypeOf(value: any, type: I.PossibleTypes, message?: string): void;
+ notTypeOf(value: any, type: string, message?: string): void;
+ /**
+ * Asserts that value is an instance of constructor
+ */
+ instanceOf(value: any, constructor: object, message?: string): void;
+ /**
+ * Asserts that value is not an instance of constructor
+ */
+ notInstanceOf(value: any, constructor: object, message?: string): void;
+ /**
+ * Asserts that expected includes inc
+ */
+ include(expected: T[], inc: T, message?: string): void;
+ include(expected: string, inc: string, message?: string): void;
+ /**
+ * Asserts that expected does not include inc
+ */
+ notInclude(expected: T[], inc: T, message?: string): void;
+ notInclude(expected: string, inc: string, message?: string): void;
+ /**
+ * Asserts that expected includes inc
+ */
+ deepInclude(expected: T[], inc: T, message?: string): void;
+ deepInclude(expected: string, inc: string, message?: string): void;
+ /**
+ * Asserts that expected does not include inc
+ */
+ notDeepInclude(expected: T[], inc: T, message?: string): void;
+ notDeepInclude(expected: string, inc: string, message?: string): void;
+ /**
+ * Asserts that expected includes inc
+ */
+ nestedInclude(expected: object, inc: object, message?: string): void;
+ /**
+ * Asserts that expected does not include inc
+ */
+ notNestedInclude(expected: object, inc: object, message?: string): void;
+ /**
+ * Assert that expected includes inc
+ */
+ deepNestedInclude(expected: object, inc: object, message?: string): void;
+ /**
+ * Assert that expected includes inc
+ */
+ notDeepNestedInclude(expected: object, inc: object, message?: string): void;
+ /**
+ * Assert that expected includes inc
+ */
+ ownInclude(expected: object, inc: object, message?: string): void;
+ /**
+ * Assert that expected does not include inc
+ */
+ notOwnInclude(expected: object, inc: object, message?: string): void;
+ /**
+ * Assert that expected includes inc
+ */
+ deepOwnInclude(expected: object, inc: object, message?: string): void;
+ /**
+ * Assert that expected does not include inc
+ */
+ notDeepOwnInclude(expected: object, inc: object, message?: string): void;
+ /**
+ * Asserts that expected matches the regular expression regExp
+ */
+ match(expected: any, regExp: RegExp, message?: string): void;
+ /**
+ * Asserts that expected does not match the regular expression regExp
+ */
+ notMatch(expected: any, regExp: RegExp, message?: string): void;
+ /**
+ * Asserts that object has a property named `property`
+ */
+ property(object: object, property: string, message?: string): void;
+ /**
+ * Asserts that object does not have a property named `property`
+ */
+ notProperty(object: object, property: string, message?: string): void;
+ /**
+ * Asserts that object has a property named `property` with value `value` (===)
+ */
+ propertyVal(object: object, property: string, value: any, message?: string): void;
+ /**
+ * Asserts that object does not have a property named `property` with value `value` (===)
+ */
+ notPropertyVal(object: object, property: string, value: any, message?: string): void;
+ /**
+ * Asserts that object has a property named `property` with a value `value`
+ */
+ deepPropertyVal(object: object, property: string, value: any, message?: string): void;
+ /**
+ * Asserts that object does not have a property named `property` with value `value`
+ */
+ notDeepPropertyVal(object: object, property: string, value: any, message?: string): void;
+ /**
+ * Asserts that object has an owned property named `property`
+ */
+ ownProperty(object: object, property: string, message?: string): void;
+ /**
+ * Asserts that object does not have an owned property named `property`
+ */
+ notOwnProperty(object: object, property: string, message?: string): void;
+ /**
+ * Asserts that object has an owned property named `property` with value `value`(===)
+ */
+ ownPropertyVal(object: object, property: string, value: any, message?: string): void;
+ /**
+ * Asserts that object does not have an owned property named `property` with value `value`(===)
+ */
+ notOwnPropertyVal(object: object, property: string, value: any, message?: string): void;
+ /**
+ * Asserts that object has an owned property named `property` with value `value`
+ */
+ deepOwnPropertyVal(object: object, property: string, value: any, message?: string): void;
+ /**
+ * Asserts that object does not have an owned property named `property` with value `value`(===)
+ */
+ notDeepOwnPropertyVal(object: object, property: string, value: any, message?: string): void;
+ /**
+ * Asserts that object has a property named `property`
+ */
+ nestedProperty(object: object, property: string, message?: string): void;
+ /**
+ * Asserts that object does not have a property named `property`
+ */
+ notNestedProperty(object: object, property: string, message?: string): void;
+ /**
+ * Asserts that object has a property named `property` with value `value`(===)
+ */
+ nestedPropertyVal(object: object, property: string, value: any, message?: string): void;
+ /**
+ * Asserts that object does not have a property named `property` with value `value`(===)
+ */
+ notNestedPropertyVal(object: object, property: string, value: any, message?: string): void;
+ /**
+ * Asserts that object has a property named `property` with value `value`
+ */
+ deepNestedPropertyVal(object: object, property: string, value: any, message?: string): void;
+ /**
+ * Asserts that object does not have a property named `property` with value `value`
+ */
+ notDeepNestedPropertyVal(object: object, property: string, value: any, message?: string): void;
+ /**
+ * Asserts that expected has a length property with value `length`
+ */
+ lengthOf(expected: any, length: number, message?: string): void;
+ /**
+ * Asserts that object has at least one key from `keys`
+ */
+ hasAnyKeys(object: object, keys: string | string[] | object, message?: string): void;
+ /**
+ * Asserts that object has all and only all of the keys provided
+ */
+ hasAllKeys(object: object, keys: string | string[] | object, message?: string): void;
+ /**
+ * Asserts that object has all the keys provided but maybe more
+ */
+ containsAllKeys(object: object, keys: string | string[] | object, message?: string): void;
+ /**
+ * Asserts that object does not have any provided key
+ */
+ doesNotHaveAnyKeys(object: object, keys: string | string[] | object, message?: string): void;
+ /**
+ * Asserts that object does not have all the keys provided
+ */
+ doesNotHaveAllKeys(object: object, keys: string | string[] | object, message?: string): void;
+ /**
+ * Asserts that object has at least one of the keys provided
+ */
+ hasAnyDeepKeys(object: object, keys: string | string[] | object, message?: string): void;
+ /**
+ * Asserts that object has all and only all of the keys provided
+ */
+ hasAllDeepKeys(object: object, keys: string | string[] | object, message?: string): void;
+ /**
+ * Asserts that object has all the keys provided but maybe more
+ */
+ containsAllDeepKeys(object: object, keys: string | string[] | object, message?: string): void;
+ /**
+ * Asserts that object does not have any provided key
+ */
+ doesNotHaveAnyDeepKeys(object: object, keys: string | string[] | object, message?: string): void;
+ /**
+ * Asserts that object does not have all the keys provided
+ */
+ doesNotHaveAllDeepKeys(object: object, keys: string | string[] | object, message?: string): void;
+ /**
+ * Asserts that a function or an async functions throws an error
+ */
+ throws(fn: () => void, errorLike?: object, errMsgMatcher?: string | RegExp, message?: string): any;
+ throws(fn: () => Promise, errorLike?: object, errMsgMatcher?: string | RegExp, message?: string): Promise;
+ /**
+ * Asserts that a function or an async functions throws an error
+ */
+ throw(fn: () => void, errorLike?: object, errMsgMatcher?: string | RegExp, message?: string): any;
+ throw(fn: () => Promise, errorLike?: object, errMsgMatcher?: string | RegExp, message?: string): Promise;
+ /**
+ * Asserts that a function or an async function does not throw an error
+ */
+ doesNotThrow(fn: () => Promise, errorLike?: object, errMsgMatcher?: string | RegExp, message?: string): Promise;
+ doesNotThrow(fn: () => void, errorLike?: object, errMsgMatcher?: string | RegExp, message?: string): any;
+ /**
+ * Compares two values using operator
+ */
+ operator(value: any, operator: string, val2: any, message?: string): void;
+ /**
+ * Asserts that actual is expected +/- delta
+ */
+ closeTo(actual: number, expected: number, delta: number, message?: string): void;
+ /**
+ * Asserts that actual is expect +/- delta
+ */
+ approximately(actual: number, expected: number, delta: number, message?: string): void;
+ /**
+ * Asserts that arrays have the same members in any order (===)
+ */
+ sameMembers(set1: any[], set2: any[], message?: string): void;
+ /**
+ * Asserts that arrays do not have the same members in any order (===)
+ */
+ notSameMembers(set1: any[], set2: any[], message?: string): void;
+ /**
+ * Asserts that arrays have the same members in any order
+ */
+ sameDeepMembers(set1: any[], set2: any[], message?: string): void;
+ /**
+ * Asserts that arrays do not have the same members in any order
+ */
+ notSameDeepMembers(set1: any[], set2: any[], message?: string): void;
+ /**
+ * Asserts that arrays have the same members in the same order (===)
+ */
+ sameOrderedMembers(set1: any[], set2: any[], message?: string): void;
+ /**
+ * Asserts that arrays do not have the same members in the same order (===)
+ */
+ notSameOrderedMembers(set1: any[], set2: any[], message?: string): void;
+ /**
+ * Asserts that arrays have the same members in the same order
+ */
+ sameDeepOrderedMembers(set1: any[], set2: any[], message?: string): void;
+ /**
+ * Asserts that arrays do not have the same members in the same order
+ */
+ notSameDeepOrderedMembers(set1: any[], set2: any[], message?: string): void;
+ /**
+ * Asserts that subset is included in superset in any order (===)
+ */
+ includeMembers(superset: any[], subset: any[], message?: string): void;
+ /**
+ * Asserts that subset is not included in superset in any order (===)
+ */
+ notIncludeMembers(superset: any[], subset: any[], message?: string): void;
+ /**
+ * Asserts that subset is included in superset in any order
+ */
+ includeDeepMembers(superset: any[], subset: any[], message?: string): void;
+ /**
+ * Asserts that subset is not included in superset in any order
+ */
+ notIncludeDeepMembers(superset: any[], subset: any[], message?: string): void;
+ /**
+ * Asserts that subset is included in superset in the same order (===)
+ */
+ includeOrderedMembers(superset: any[], subset: any[], message?: string): void;
+ /**
+ * Asserts that subset is not included in superset in the same order (===)
+ */
+ notIncludeOrderedMembers(superset: any[], subset: any[], message?: string): void;
+ /**
+ * Asserts that subset is included in superset in the same order
+ */
+ includeDeepOrderedMembers(superset: any[], subset: any[], message?: string): void;
+ /**
+ * Asserts that subset is not included in superset in the same order
+ */
+ notIncludeDeepOrderedMembers(superset: any[], subset: any[], message?: string): void;
+ /**
+ * Asserts that list includes inList
+ */
+ oneOf(inList: any, list: any[], message?: string): void;
+ /**
+ * Asserts that a function changes the value of a property
+ */
+ changes(fn: () => void, object: object, property: string, message?: string): void;
+ /**
+ * Asserts that a function changes the value of a property by delta
+ */
+ changesBy(fn: () => void, object: object, property: string, delta: number, message?: string): void;
+ /**
+ * Asserts that a function does not changes the value of a property
+ */
+ doesNotChange(fn: () => void, object: object, property: string, message?: string): void;
+ /**
+ * Asserts that a function does not change the value of a property or of a function’s return value by delta
+ */
+ changesButNotBy(fn: () => void, object: object, property: string, delta: number, message?: string): void;
+ /**
+ * Asserts that a function increases a numeric object property
+ */
+ increases(fn: () => void, object: object, property: string, message?: string): void;
+ /**
+ * Asserts that a function increases a numeric object property or a function’s return value by delta
+ */
+ increasesBy(fn: () => void, object: object, property: string, delta: number, message?: string): void;
+ /**
+ * Asserts that a function does not increase a numeric object property
+ */
+ doesNotIncrease(fn: () => void, object: object, property: string, message?: string): void;
+ /**
+ * Asserts that a function does not increase a numeric object property or function’s return value by delta
+ */
+ increasesButNotBy(fn: () => void, object: object, property: string, delta: number, message?: string): void;
+ /**
+ * Asserts that a function decreases the value of a property
+ */
+ decreases(fn: () => void, object: object, property: string, message?: string): void;
+ /**
+ * Asserts that a function decreases the value of a property by delta
+ */
+ decreasesBy(fn: () => void, object: object, property: string, delta: number, message?: string): void;
+ /**
+ * Asserts that a function does not decrease the value of a property
+ */
+ doesNotDecrease(fn: () => void, object: object, property: string, message?: string): void;
+ /**
+ * Asserts that a function does not decrease the value of a property or a function's return value by delta
+ */
+ doesNotDecreaseBy(fn: () => void, object: object, property: string, delta: number, message?: string): void;
+ /**
+ * Asserts that a function does not decreases a numeric object property or a function’s return value by delta
+ */
+ decreasesButNotBy(fn: () => void, object: object, property: string, delta: number, message?: string): void;
+ /**
+ * Throws an error if value is truthy
+ */
+ ifError(value: any): void;
+ /**
+ * Asserts that object is extensible
+ */
+ isExtensible(object: object, message?: string): void;
+ /**
+ * Asserts that object is extensible
+ */
+ extensible(object: object, message?: string): void;
+ /**
+ * Asserts that object is not extensible
+ */
+ isNotExtensible(object: object, message?: string): void;
+ /**
+ * Asserts that object is not extensible
+ */
+ notExtensible(object: object, message?: string): void;
+ /**
+ * Asserts that object is sealed
+ */
+ isSealed(object: object, message?: string): void;
+ /**
+ * Asserts that object is sealed
+ */
+ sealed(object: object, message?: string): void;
+ /**
+ * Asserts that object is not sealed
+ */
+ isNotSealed(object: object, message?: string): void;
+ /**
+ * Asserts that object is not sealed
+ */
+ notSealed(object: object, message?: string): void;
+ /**
+ * Asserts that object is frozen
+ */
+ isFrozen(object: object, message?: string): void;
+ /**
+ * Asserts that object is frozen
+ */
+ frozen(object: object, message?: string): void;
+ /**
+ * Asserts that object is not frozen
+ */
+ isNotFrozen(object: object, message?: string): void;
+ /**
+ * Asserts that object is not frozen
+ */
+ notFrozen(object: object, message?: string): void;
+ /**
+ * Asserts that value is empty
+ */
+ isEmpty(value: any, message?: string): void;
+ /**
+ * Asserts that value is empty
+ */
+ empty(value: any, message?: string): void;
+ /**
+ * Asserts that value is not empty
+ */
+ isNotEmpty(value: any, message?: string): void;
+ /**
+ * Asserts that value is not empty
+ */
+ notEmpty(value: any, message?: string): void;
+ }
+
+ interface ExpectFunction {
+ (value: adone.shani.util.I.Spy, message?: string): MockAssertions;
+ (value: any, message?: string): Assertion;
+ fail(actual: any, expected: any, message?: string, operator?: any): void;
+ }
+
+ interface LanguageChains {
+ to: this;
+ be: this;
+ been: this;
+ is: this;
+ that: this;
+ which: this;
+ and: this;
+ has: this;
+ have: this;
+ with: this;
+ at: this;
+ of: this;
+ same: this;
+ but: this;
+ does: this;
+ }
+
+ interface Assertion extends LanguageChains {
+ /**
+ * Negates all following assertion in the chain
+ */
+ not: this;
+ /**
+ * Causes following assertions to use deep equality
+ */
+ deep: this;
+ /**
+ * Enables dot- and bracket-notation in following property and include assertions
+ */
+ nested: this;
+ /**
+ * Causes following property and incude assertions to ignore inherited properties
+ */
+ own: this;
+ /**
+ * Causes following members assertions to require that members be in the same order
+ */
+ ordered: this;
+ /**
+ * Causes following keys assertions to only require that the target have at least one of the given keys
+ */
+ any: this;
+ /**
+ * Causes following keys assertions to require that the target have all of the given keys
+ */
+ all: this;
+ /**
+ * Asserts that the target's type is `type`
+ */
+ a(type: I.PossibleTypes, message?: string): this;
+ a(type: string, message?: string): this;
+ /**
+ * Asserts that the target's type is `type`
+ */
+ an(type: I.PossibleTypes, message?: string): this;
+ an(type: string, message?: string): this;
+ /**
+ * Asserts that the target includes the given value
+ */
+ include(value: any, message?: string): this;
+ /**
+ * Asserts that the target includes the given value
+ */
+ includes(value: any, message?: string): this;
+ /**
+ * Asserts that the target contains the given value
+ */
+ contain(value: any, message?: string): this;
+ /**
+ * Asserts that the target contains the given value
+ */
+ contains(value: any, message?: string): this;
+ /**
+ * Asserts that the target is non-strictly equal to true
+ */
+ ok: this;
+ /**
+ * Asserts that the target is true
+ */
+ true: this;
+ /**
+ * Asserts that the target is false
+ */
+ false: this;
+ /**
+ * Asserts that the target is null
+ */
+ null: this;
+ /**
+ * Asserts that the target is undefined
+ */
+ undefined: this;
+ /**
+ * Asserts that the target is NaN
+ */
+ NaN: this;
+ /**
+ * Asserts that the target is neither null nor undefined
+ */
+ exist: this;
+ /**
+ * Asserts that the target is empty
+ */
+ empty: this;
+ /**
+ * Asserts that the target is an arguments object
+ */
+ arguments: this;
+ /**
+ * Asserts that the target is an arguments object
+ */
+ Arguments: this;
+ /**
+ * Asserts that the target is strictly equal to value(===)
+ */
+ equal(value: any, message?: string): this;
+ /**
+ * Asserts that the target is strictly equal to value(===)
+ */
+ equals(value: any, message?: string): this;
+ /**
+ * Asserts that the target is strictly equal to value(===)
+ */
+ eq(value: any, message?: string): this;
+ /**
+ * Asserts that the target is deeply equal to object
+ */
+ eql(object: any, message?: string): this;
+ /**
+ * Asserts that the target is deeply equal to object
+ */
+ eqls(object: any, message?: string): this;
+ /**
+ * Asserts that the target has the same length length and elements as array in the same order
+ */
+ eqlArray(array: any[], message?: string): this;
+ /**
+ * Asserts that target > n
+ */
+ above(n: number, message?: string): this;
+ /**
+ * Asserts that target > n
+ */
+ gt(n: number, message?: string): this;
+ /**
+ * Asserts that target > n
+ */
+ greaterThan(n: number, message?: string): this;
+ /**
+ * Asserts that target >= n
+ */
+ least(n: number, message?: string): this;
+ /**
+ * Asserts that target >= n
+ */
+ gte(n: number, message?: string): this;
+ /**
+ * Asserts that target < n
+ */
+ below(n: number, message?: string): this;
+ /**
+ * Asserts that target < n
+ */
+ lt(n: number, message?: string): this;
+ /**
+ * Asserts that target < n
+ */
+ lessThan(n: number, message?: string): this;
+ /**
+ * Asserts that target <= n
+ */
+ most(n: number, message?: string): this;
+ /**
+ * Asserts that target <= n
+ */
+ lte(n: number, message?: string): this;
+ /**
+ * Asserts that start <= target <= end
+ */
+ within(start: number, end: number, message?: string): this;
+ /**
+ * Asserts that the target is an instance of constructor
+ */
+ instanceof(constructor: object, message?: string): this;
+ /**
+ * Asserts that the target is an instance of constructor
+ */
+ instanceOf(constructor: object, message?: string): this;
+ /**
+ * Asserts that the target has a property name `name` with value `value`
+ */
+ property(name: string, value?: any, message?: string): this;
+ /**
+ * Asserts that the target has its own property name `name` with value `value`
+ */
+ ownProperty(name: string, value?: any, message?: string): this;
+ /**
+ * Asserts that the target has its own property name `name` with value `value`
+ */
+ haveOwnProperty(name: string, value?: any, message?: string): this;
+ /**
+ * Asserts that the target has its own property descriptor with name `name` and value `value`
+ */
+ ownPropertyDescriptor(name: string, descriptor?: object, message?: string): this;
+ /**
+ * Asserts that the target has its own property descriptor with name `name` and value `value`
+ */
+ haveOwnPropertyDescriptor(name: string, descriptor?: object, message?: string): this;
+ /**
+ * Asserts that the target's property length equal to n
+ */
+ length(n: number, message?: string): this;
+ /**
+ * Asserts that the target's property length equal to n
+ */
+ lengthOf(n: number, message?: string): this;
+ /**
+ * Asserts that the target matches the regular expression regExp
+ */
+ match(regExp: RegExp, message?: string): this;
+ /**
+ * Asserts that the target matches the regular expression regExp
+ */
+ matches(regExp: RegExp, message?: string): this;
+ /**
+ * Asserts that the target contains str as a substring
+ */
+ string(str: string, message?: string): this;
+ /**
+ * Assert that the target has the given keys
+ */
+ key(key: string | string[] | object): this;
+ key(...keys: string[]): this;
+ /**
+ * Assert that the target has the given keys
+ */
+ keys(key: string | string[] | object): this;
+ keys(...keys: string[]): this;
+ /**
+ * Assert that the target throws an error
+ */
+ throw(errorLike?: object, errMsgMatcher?: string | RegExp, message?: string): this;
+ /**
+ * Assert that the target throws an error
+ */
+ throws(errorLike?: object, errMsgMatcher?: string | RegExp, message?: string): this;
+ /**
+ * Assert that the target throws an error
+ */
+ Throw(errorLike?: Error, errMsgMatcher?: string | RegExp): this;
+ /**
+ * Assert that the target has a method with name `method`. For functions checks the prototype
+ */
+ respondTo(method: string, message?: string): this;
+ /**
+ * Assert that the target has a method with name `method`. For functions checks the prototype
+ */
+ respondsTo(method: string, message?: string): this;
+ /**
+ * Makes respondsTo behave like the target is not a function
+ */
+ itself: this;
+ /**
+ * Asserts that matches returns a truthy value with the target as the first argument
+ */
+ satisfy(matcher: () => boolean, message?: string): this;
+ /**
+ * Asserts that matches returns a truthy value with the target as the first argument
+ */
+ satisfies(matcher: () => boolean, message?: string): this;
+ /**
+ * Asserts that the target is expected +/- delta
+ */
+ closeTo(expected: number, delta: number, message?: string): this;
+ /**
+ * Asserts that the target is expected +/- delta
+ */
+ approximately(expected: number, delta: number, message?: string): this;
+ /**
+ * Asserts that the target array has the same members as the given
+ */
+ members(set: any[], message?: string): this;
+ /**
+ * Asserts that the target is the member of list
+ */
+ oneOf(list: any[], message?: string): this;
+ /**
+ * Asserts that fn returns a different value after the target's invokation than before
+ */
+ change(fn: () => any, message?: string): this;
+ /**
+ * Asserts that the target's invokation changes subject's property
+ */
+ change(subject: object, property: string, message?: string): this;
+ /**
+ * Asserts that fn returns a different value after the target's invokation than before
+ */
+ changes(fn: () => any, message?: string): this;
+ /**
+ * Asserts that the target's invokation changes subject's property
+ */
+ changes(subject: object, property: string, message?: string): this;
+ /**
+ * Asserts that fn returns a greater number after the target's invokation than before
+ */
+ increase(fn: () => number, message?: string): this;
+ /**
+ * Asserts that the target's invokation increases subject's property
+ */
+ increase(subject: object, property?: string, message?: string): this;
+ /**
+ * Asserts that fn returns a greater number after the target's invokation than before
+ */
+ increases(fn: () => number, message?: string): this;
+ /**
+ * Asserts that the target's invokation increases subject's property
+ */
+ increases(subject: object, property?: string, message?: string): this;
+ /**
+ * Asserts that fn returns a lesser number after the target's invokation than before
+ */
+ decrease(fn: () => number, message?: string): this;
+ /**
+ * Asserts that the target's invokation decreases subject's property
+ */
+ decrease(subject: object, property?: string, message?: string): this;
+ /**
+ * Asserts that fn returns a lesser number after the target's invokation than before
+ */
+ decreases(fn: () => number, message?: string): this;
+ /**
+ * Asserts that the target's invokation decreases subject's property
+ */
+ decreases(subject: object, property?: string, message?: string): this;
+ /**
+ * Asserts that the value was decreased/increased by delta
+ */
+ by(delta: number, message?: string): this;
+ /**
+ * Asserts that the target is extensible
+ */
+ extensible: this;
+ /**
+ * Asserts that the target is sealed
+ */
+ sealed: this;
+ /**
+ * Asserts that the target is frozen
+ */
+ frozen: this;
+ /**
+ * Asserts that the target is a finite number
+ */
+ finite: this;
+ }
+
+ interface MockAssertions extends Assertion {
+ /**
+ * Asserts that the spy has been called
+ */
+ called: this;
+ /**
+ * Asserts that the spy has been called n times
+ */
+ callCount(n: number): this;
+ /**
+ * Asserts that the spy has been called once
+ */
+ calledOnce: this;
+ /**
+ * Asserts that the spy has been called twice
+ */
+ calledTwice: this;
+ /**
+ * Asserts that the spy has been been called with `new`
+ */
+ calledThrice: this;
+ /**
+ * Asserts that the spy has been called before anotherSpy
+ */
+ calledBefore(anotherSpy: adone.shani.util.I.Spy): this;
+ /**
+ * Asserts that the spy has been called after anotherSpy
+ */
+ calledAfter(anotherSpy: adone.shani.util.I.Spy): this;
+ /**
+ * Asserts that the spy has been called immediately before anotherSpy
+ */
+ calledImmediatelyBefore(anotherSpy: adone.shani.util.I.Spy): this;
+ /**
+ * Asserts that the spy has been called immediately after anotherSpy
+ */
+ calledImmediatelyAfter(anotherSpy: adone.shani.util.I.Spy): this;
+ /**
+ * Asserts that the spy has been called with context as this value
+ */
+ calledOn(context: object): this;
+ /**
+ * Asserts that the spy has been called with the given arguments
+ */
+ calledWith(...args: any[]): this;
+ /**
+ * Asserts that the spy has been called exactly with the given arguments
+ */
+ calledWithExactly(...args: any[]): this;
+ /**
+ * Asserts that the spy has been called with matching arguments
+ */
+ calledWithMatch(...args: any[]): this;
+ /**
+ * Asserts that the spy returned value
+ */
+ returned(value: any): this;
+ /**
+ * Asserts that the spy threw error
+ */
+ thrown(error: any): this;
+ /**
+ * Asserts that the spy threw error
+ */
+ threw(error: any): this;
+ }
+ }
+
+ class AssertionError extends adone.x.Exception {
+ constructor(message?: string, props?: object, ssf?: object)
+ }
+
+ const config: I.Config;
+ const use: I.UseFunction;
+ const loadMockInterface: I.LoadInterfaceFunction;
+ const loadExpectInterface: I.LoadInterfaceFunction;
+ const loadAssertInterface: I.LoadInterfaceFunction;
+ const assert: I.AssertFunction;
+ const expect: I.ExpectFunction;
+}
diff --git a/types/adone/glosses/common.d.ts b/types/adone/glosses/common.d.ts
new file mode 100644
index 0000000000..57025ea054
--- /dev/null
+++ b/types/adone/glosses/common.d.ts
@@ -0,0 +1,465 @@
+/**
+ * predicates
+ */
+export namespace is {
+ function _null(obj: any): boolean;
+ export { _null as null };
+ export function undefined(obj: any): boolean;
+ export function exist(obj: any): boolean;
+ export function nil(obj: any): boolean;
+ export function number(obj: any): boolean;
+ export function numeral(obj: any): boolean;
+ export function infinite(obj: any): boolean;
+ export function odd(obj: any): boolean;
+ export function even(obj: any): boolean;
+ export function float(obj: any): boolean;
+ export function negativeZero(obj: any): boolean;
+ export function string(obj: any): boolean;
+ export function emptyString(obj: any): boolean;
+ export function substring(substring: string, string: string, offset?: number): boolean;
+ export function prefix(prefix: string, string: string): boolean;
+ export function suffix(suffix: string, string: string): boolean;
+ export function boolean(obj: any): boolean;
+ export function json(obj: any): boolean;
+ export function object(obj: any): boolean;
+ export function plainObject(obj: any): boolean;
+ function _class(obj: any): boolean;
+ export { _class as class };
+ export function emptyObject(obj: any): boolean;
+ export function propertyOwned(obj: any, field: string): boolean;
+ export function propertyDefined(obj: any, field: string): boolean;
+ export function conforms(obj: object, schema: object, strict?: boolean): boolean;
+ export function arrayLikeObject(obj: any): boolean;
+ export function inArray(value: T, array: any[], offset?: number, comparator?: (a: T, b: T) => boolean): boolean;
+ export function sameType(value: any, other: any): boolean;
+ export function primitive(obj: any): boolean;
+ export function equalArrays(left: any[], right: any[]): boolean;
+ export function deepEqual(left: any, right: any): boolean;
+ export function shallowEqual(left: any, right: any): boolean;
+ export function stream(obj: any): boolean;
+ export function writableStream(obj: any): boolean;
+ export function readableStream(obj: any): boolean;
+ export function duplexStream(obj: any): boolean;
+ export function transformStream(obj: any): boolean;
+ export function utf8(obj: Buffer): boolean;
+ export function win32PathAbsolute(path: string): boolean;
+ export function posixPathAbsolute(path: string): boolean;
+ export function pathAbsolute(path: string): boolean;
+ export function glob(str: string): boolean;
+ export function dotfile(str: string): boolean;
+ function _function(obj: any): boolean;
+ export { _function as function };
+ export function asyncFunction(obj: any): boolean;
+ export function promise(obj: any): boolean;
+ export function validDate(str: string): boolean;
+ export function buffer(obj: any): boolean;
+ export function callback(obj: any): boolean;
+ export function generator(obj: any): boolean;
+ export function nan(obj: any): boolean;
+ export function finite(obj: any): boolean;
+ export function integer(obj: any): boolean;
+ export function safeInteger(obj: any): boolean;
+ export function array(obj: any): boolean;
+ export function uint8Array(obj: any): boolean;
+ export function configuration(obj: any): boolean;
+ export function long(obj: any): boolean;
+ export function bigNumber(obj: any): boolean;
+ export function exbuffer(obj: any): boolean;
+ export function exdate(obj: any): boolean;
+ export function transform(obj: any): boolean;
+ export function subsystem(obj: any): boolean;
+ export function application(obj: any): boolean;
+ export function logger(obj: any): boolean;
+ export function coreStream(obj: any): boolean;
+ export function fastStream(obj: any): boolean;
+ export function fastFSStream(obj: any): boolean;
+ export function fastFSMapStream(obj: any): boolean;
+ export function genesisNetron(obj: any): boolean;
+ export function genesisPeer(obj: any): boolean;
+ export function netronAdapter(obj: any): boolean;
+ export function netron(obj: any): boolean;
+ export function netronPeer(obj: any): boolean;
+ export function netronDefinition(obj: any): boolean;
+ export function netronDefinitions(obj: any): boolean;
+ export function netronReference(obj: any): boolean;
+ export function netronInterface(obj: any): boolean;
+ export function netronContext(obj: any): boolean;
+ export function netronIMethod(netronInterface: object, name: string): boolean;
+ export function netronIProperty(netronInterface: any, name: string): boolean;
+ export function netronStub(obj: any): boolean;
+ export function netronRemoteStub(obj: any): boolean;
+ export function netronStream(obj: any): boolean;
+ export function iterable(obj: any): boolean;
+ export const windows: boolean;
+ export const linux: boolean;
+ export const freebsd: boolean;
+ export const darwin: boolean;
+ export const sunos: boolean;
+ export function uppercase(str: string): boolean;
+ export function lowercase(str: string): boolean;
+ export function digits(str: string): boolean;
+ export function identifier(str: string): boolean;
+ export function binaryExtension(str: string): boolean;
+ export function binaryPath(str: string): boolean;
+ export function ip4(str: string): boolean;
+ export function ip6(str: string): boolean;
+ export function arrayBuffer(obj: any): boolean;
+ export function arrayBufferView(obj: any): boolean;
+ export function date(obj: any): boolean;
+ export function error(obj: any): boolean;
+ export function map(obj: any): boolean;
+ export function regexp(obj: any): boolean;
+ export function set(obj: any): boolean;
+ export function symbol(obj: any): boolean;
+ export function validUTF8(obj: any): boolean;
+}
+
+export namespace x {
+ class Exception extends Error {
+ constructor(message?: string | Error, captureStackTrace?: boolean);
+ }
+ class Runtime extends Exception { }
+ class IncompleteBufferError extends Exception { }
+ class NotImplemented extends Exception { }
+ class IllegalState extends Exception { }
+ class NotValid extends Exception { }
+ class Unknown extends Exception { }
+ class NotExists extends Exception { }
+ class Exists extends Exception { }
+ class Empty extends Exception { }
+ class InvalidAccess extends Exception { }
+ class NotSupported extends Exception { }
+ class InvalidArgument extends Exception { }
+ class InvalidNumberOfArguments extends Exception { }
+ class NotFound extends Exception { }
+ class Timeout extends Exception { }
+ class Incorrect extends Exception { }
+ class NotAllowed extends Exception { }
+ class LimitExceeded extends Exception { }
+ class Encoding extends Exception { }
+ class Network extends Exception { }
+ class Bind extends Exception { }
+ class Connect extends Exception { }
+ class Database extends Exception { }
+ class DatabaseInitialization extends Exception { }
+ class DatabaseOpen extends Exception { }
+ class DatabaseRead extends Exception { }
+ class DatabaseWrite extends Exception { }
+ class NetronIllegalState extends Exception { }
+ class NetronPeerDisconnected extends Exception { }
+ class NetronTimeout extends Exception { }
+}
+
+export class EventEmitter {
+ static listenerCount(emitter: EventEmitter, event: string | symbol): number;
+ static defaultMaxListeners: number;
+
+ addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+ on(event: string | symbol, listener: (...args: any[]) => void): this;
+ once(event: string | symbol, listener: (...args: any[]) => void): this;
+ prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+ prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+ removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+ removeAllListeners(event?: string | symbol): this;
+ setMaxListeners(n: number): this;
+ getMaxListeners(): number;
+ listeners(event: string | symbol): Array<(...args: any[]) => any>;
+ emit(event: string | symbol, ...args: any[]): boolean;
+ eventNames(): Array;
+ listenerCount(type: string | symbol): number;
+}
+
+export class AsyncEmitter extends EventEmitter {
+ constructor(concurrency?: number);
+
+ setConcurrency(max?: number): this;
+
+ emitParallel(event: string, ...args: any[]): Promise;
+
+ emitSerial(event: string, ...args: any[]): Promise;
+
+ emitReduce(event: string, ...args: any[]): Promise;
+
+ emitReduceRight(event: string, ...args: any[]): Promise;
+
+ subscribe(event: string, listener: (...args: any[]) => void, once?: boolean): () => void;
+}
+
+declare namespace I {
+ type Long = adone.math.Long;
+
+ type Longable = adone.math.I.Longable;
+
+ namespace ExBuffer {
+ interface Varint32 {
+ value: number;
+ length: number;
+ }
+
+ interface Varint64 {
+ value: Long;
+ length: number;
+ }
+
+ interface String {
+ string: string;
+ length: number;
+ }
+
+ type Wrappable = string | ExBuffer | Buffer | Uint8Array | ArrayBuffer;
+
+ type METRICS = "b" | "c";
+ }
+}
+
+export class ExBuffer {
+ constructor(capacity?: number, noAssert?: boolean);
+
+ readBitSet(offset?: number): number[];
+
+ read(length: number, offset?: number): ExBuffer;
+
+ readInt8(offset?: number): number;
+
+ readUInt8(offset?: number): number;
+
+ readInt16LE(offset?: number): number;
+
+ readUInt16LE(offset?: number): number;
+
+ readInt16BE(offset?: number): number;
+
+ readUInt16BE(offset?: number): number;
+
+ readInt32LE(offset?: number): number;
+
+ readUInt32LE(offset?: number): number;
+
+ readInt32BE(offset?: number): number;
+
+ readUInt32BE(offset?: number): number;
+
+ readInt64LE(offset?: number): adone.math.Long;
+
+ readUInt64LE(offset?: number): adone.math.Long;
+
+ readInt64BE(offset?: number): adone.math.Long;
+
+ readUInt64BE(offset?: number): adone.math.Long;
+
+ readFloatLE(offset?: number): number;
+
+ readFloatBE(offset?: number): number;
+
+ readDoubleLE(offset?: number): number;
+
+ readDoubleBE(offset?: number): number;
+
+ write(source: I.ExBuffer.Wrappable, offset?: number, length?: number, encoding?: string): this;
+
+ writeBitSet(value: number[]): this;
+
+ writeBitSet(value: number[], offset: number): number;
+
+ writeInt8(value: number, offset?: number): this;
+
+ writeUInt8(value: number, offset?: number): this;
+
+ writeInt16LE(value: number, offset?: number): this;
+
+ writeInt16BE(value: number, offset?: number): this;
+
+ writeUInt16LE(value: number, offset?: number): this;
+
+ writeUInt16BE(value: number, offset?: number): this;
+
+ writeInt32LE(value: number, offset?: number): this;
+
+ writeInt32BE(value: number, offset?: number): this;
+
+ writeUInt32LE(value: number, offset?: number): this;
+
+ writeUInt32BE(value: number, offset?: number): this;
+
+ writeInt64LE(value: I.Longable, offset?: number): this;
+
+ writeInt64BE(value: I.Longable, offset?: number): this;
+
+ writeUInt64LE(value: I.Longable, offset?: number): this;
+
+ writeUInt64BE(value: I.Longable, offset?: number): this;
+
+ writeFloatLE(value: number, offset?: number): this;
+
+ writeFloatBE(value: number, offset?: number): this;
+
+ writeDoubleLE(value: number, offset?: number): this;
+
+ writeDoubleBE(value: number, offset?: number): this;
+
+ writeVarint32(value: number): this;
+
+ writeVarint32(value: number, offset: number): number;
+
+ writeVarint32ZigZag(value: number): this;
+
+ writeVarint32ZigZag(value: number, offset: number): number;
+
+ readVarint32(): number;
+
+ readVarint32(offset: number): I.ExBuffer.Varint32;
+
+ readVarint32ZigZag(): number;
+
+ readVarint32ZigZag(offset: number): I.ExBuffer.Varint32;
+
+ writeVarint64(value: I.Longable): this;
+
+ writeVarint64(value: I.Longable, offset: number): number;
+
+ writeVarint64ZigZag(value: I.Longable): this;
+
+ writeVarint64ZigZag(value: I.Longable, offset: number): number;
+
+ readVarint64(): I.Long;
+
+ readVarint64(offset: number): I.ExBuffer.Varint64;
+
+ readVarint64ZigZag(): adone.math.Long;
+
+ readVarint64ZigZag(offset: number): I.ExBuffer.Varint64;
+
+ writeCString(str: string): this;
+
+ writeCString(str: string, offset: number): number;
+
+ readCString(): string;
+
+ readCString(offset: number): I.ExBuffer.String;
+
+ writeString(str: string): this;
+
+ writeString(str: string, offset: number): number;
+
+ readString(length: number, metrics?: I.ExBuffer.METRICS): string;
+
+ readString(length: number, metrics: I.ExBuffer.METRICS, offset: number): I.ExBuffer.String;
+
+ readString(length: number, offset: number): I.ExBuffer.String;
+
+ writeVString(str: string): this;
+
+ writeVString(str: string, offset: number): number;
+
+ readVString(): string;
+
+ readVString(offset: number): I.ExBuffer.String;
+
+ appendTo(target: ExBuffer, offset?: number): this;
+
+ assert(assert?: boolean): this;
+
+ capacity(): number;
+
+ clear(): this;
+
+ compact(begin?: number, end?: number): this;
+
+ copy(begin?: number, end?: number): ExBuffer;
+
+ copyTo(target: ExBuffer, targetOffset?: number, souceOffset?: number, sourceLimit?: number): this | ExBuffer;
+
+ ensureCapacity(capacity: number): this;
+
+ fill(value: string | number, begin?: number, end?: number): this;
+
+ flip(): this;
+
+ mark(offset?: number): this;
+
+ prepend(source: I.ExBuffer.Wrappable, encoding?: string, offset?: number): this;
+
+ prepend(source: I.ExBuffer.Wrappable, offset: number): this;
+
+ prependTo(target: ExBuffer, offset?: number): this;
+
+ remaining(): number;
+
+ reset(): this;
+
+ resize(capacity: number): this;
+
+ reverse(begin?: number, end?: number): this;
+
+ skip(length: number): this;
+
+ slice(begin?: number, end?: number): ExBuffer;
+
+ toBuffer(forceCopy?: boolean, begin?: number, end?: number): Buffer;
+
+ toArrayBuffer(): ArrayBuffer;
+
+ toString(encoding?: string, begin?: number, end?: number): string;
+
+ toBase64(begin?: number, end?: number): string;
+
+ toBinary(begin?: number, end?: number): string;
+
+ toDebug(columns?: boolean): string;
+
+ toHex(begin?: number, end?: number): string;
+
+ toUTF8(begin?: number, end?: number): string;
+
+ static accessor(): typeof Buffer;
+
+ static allocate(capacity?: number, noAssert?: boolean): ExBuffer;
+
+ static concat(buffers: I.ExBuffer.Wrappable[], encoding?: string, noAssert?: boolean): ExBuffer;
+
+ static type(): typeof Buffer;
+
+ static wrap(buffer: I.ExBuffer.Wrappable, encoding?: string, noAssert?: boolean): ExBuffer;
+
+ static calculateVarint32(value: number): number;
+
+ static zigZagEncode32(n: number): number;
+
+ static zigZagDecode32(n: number): number;
+
+ static calculateVarint64(value: number | string): number;
+
+ static zigZagEncode64(value: number | string | I.Long): I.Long;
+
+ static zigZagDecode64(value: number | string | I.Long): I.Long;
+
+ static calculateUTF8Chars(str: string): number;
+
+ static calculateString(str: string): number;
+
+ static fromBase64(str: string): ExBuffer;
+
+ static btoa(str: string): string;
+
+ static atob(b64: string): string;
+
+ static fromBinary(str: string): ExBuffer;
+
+ static fromDebug(str: string, noAssert?: boolean): ExBuffer;
+
+ static fromHex(str: string, noAssert?: boolean): ExBuffer;
+
+ static fromUTF8(str: string, noAssert?: boolean): ExBuffer;
+
+ static DEFAULT_CAPACITY: number;
+
+ static DEFAULT_NOASSERT: boolean;
+
+ static MAX_VARINT32_BYTES: number;
+
+ static MAX_VARINT64_BYTES: number;
+
+ static METRICS_CHARS: string;
+
+ static METRICS_BYTES: string;
+}
diff --git a/types/adone/glosses/math.d.ts b/types/adone/glosses/math.d.ts
new file mode 100644
index 0000000000..076bdd105f
--- /dev/null
+++ b/types/adone/glosses/math.d.ts
@@ -0,0 +1,118 @@
+/**
+ * math related things
+ */
+export namespace math {
+ namespace I {
+ interface LowHighBits {
+ low: number;
+ high: number;
+ }
+ type Longable = math.Long | number | string | LowHighBits;
+ }
+
+ export class Long {
+ constructor(low?: number, high?: number, unsigned?: boolean);
+
+ toInt(): number;
+
+ toNumber(): number;
+
+ toString(radix?: number): string;
+
+ getHighBits(): number;
+
+ getHighBitsUnsigned(): number;
+
+ getLowBits(): number;
+
+ getLowBitsUnsigned(): number;
+
+ getNumBitsAbs(): number;
+
+ isZero(): boolean;
+
+ isNegative(): boolean;
+
+ isPositive(): boolean;
+
+ isOdd(): boolean;
+
+ isEven(): boolean;
+
+ equals(other: I.Longable): boolean;
+
+ lessThan(other: I.Longable): boolean;
+
+ lessThanOrEqual(other: I.Longable): boolean;
+
+ greaterThan(other: I.Longable): boolean;
+
+ greaterThanOrEqual(other: I.Longable): boolean;
+
+ compare(other: I.Longable): number;
+
+ negate(): Long;
+
+ add(addend: I.Longable): Long;
+
+ sub(subtrahend: I.Longable): Long;
+
+ mul(multiplier: I.Longable): Long;
+
+ div(divisor: I.Longable): Long;
+
+ mod(divisor: I.Longable): Long;
+
+ not(): Long;
+
+ and(other: I.Longable): Long;
+
+ or(other: I.Longable): Long;
+
+ xor(other: I.Longable): Long;
+
+ shl(numBits: number | Long): Long;
+
+ shr(numBits: number | Long): Long;
+
+ shru(numBits: number | Long): Long;
+
+ toSigned(): Long;
+
+ toUnsigned(): Long;
+
+ toBytes(le?: boolean): number[];
+
+ toBytesLE(): number[];
+
+ toBytesBE(): number[];
+
+ static fromInt(value: number, unsigned?: boolean): Long;
+
+ static fromNumber(value?: number, unsigned?: boolean): Long;
+
+ static fromBits(lowBits: number, highBits: number, unsigned?: boolean): Long;
+
+ static fromString(str: string, unsigned?: boolean, radix?: number): Long;
+
+ static fromString(str: string, radix?: number): Long;
+
+ static fromValue(val: I.Longable): Long;
+
+ static MIN_VALUE: Long;
+
+ static MAX_VALUE: Long;
+
+ static MAX_UNSIGNED_VALUE: Long;
+
+ static ZERO: Long;
+
+ static UZERO: Long;
+
+ static ONE: Long;
+
+ static UONE: Long;
+
+ static NEG_ONE: Long;
+ }
+}
diff --git a/types/adone/glosses/promise.d.ts b/types/adone/glosses/promise.d.ts
new file mode 100644
index 0000000000..a5267c69a3
--- /dev/null
+++ b/types/adone/glosses/promise.d.ts
@@ -0,0 +1,114 @@
+/**
+ * promise helpers
+ */
+export namespace promise {
+ namespace I {
+ interface Deferred {
+ /**
+ * Resolves the promise
+ */
+ resolve(value?: T): void;
+
+ /**
+ * Rejects the promise
+ */
+ reject(value?: any): void;
+
+ promise: Promise;
+ }
+ }
+
+ /**
+ * Creates a promise and returns an interface to control the state
+ */
+ export function defer(): I.Deferred;
+
+ /**
+ * Creates a promise that will be resolved after given milliseconds
+ *
+ * @param ms delay in milliseconds
+ * @param value resolving value
+ */
+ export function delay(ms: number, value?: T): Promise;
+
+ /**
+ * Creates a promise that will be rejected after given milliseconds if the given promise is not fulfilled
+ *
+ * @param ms timeout in milliseconds
+ */
+ export function timeout(promise: Promise, ms: number): Promise;
+
+ /**
+ * Converts a promise to node.js style callback
+ */
+ export function nodeify(promise: Promise, callback: (err?: any, value?: T) => void): Promise;
+
+ namespace I {
+ interface PromisifyOptions {
+ /**
+ * Context to bind to new function
+ */
+ context?: object;
+ }
+ }
+
+ /**
+ * Converts a callback function to a promise-based function
+ */
+ export function promisify(fn: (callback: (err?: any, result?: R) => void) => void, options?: I.PromisifyOptions): () => Promise;
+ export function promisify(fn: (a: T, callback: (err?: any, result?: R) => void) => void, options?: I.PromisifyOptions): (a: T) => Promise;
+ export function promisify(fn: (a: T, callback: (err?: any) => void) => void, options?: I.PromisifyOptions): (a: T) => Promise;
+ export function promisify(fn: (a: T1, b: T2, callback: (err?: any, result?: R) => void) => void, options?: I.PromisifyOptions): (a: T1, b: T2) => Promise;
+ export function promisify(fn: (a: T1, b: T2, callback: (err?: any) => void) => void, options?: I.PromisifyOptions): (a: T1, b: T2) => Promise;
+ export function promisify(fn: (a: T1, b: T2, c: T3, callback: (err?: any, result?: R) => void) => void, options?: I.PromisifyOptions): (a: T1, b: T2, c: T3) => Promise;
+ export function promisify(fn: (a: T1, b: T2, c: T3, callback: (err?: any) => void) => void, options?: I.PromisifyOptions): (a: T1, b: T2, c: T3) => Promise;
+ export function promisify(
+ fn: (a: T1, b: T2, c: T3, d: T4, callback: (err?: any, result?: R) => void) => void,
+ options?: I.PromisifyOptions
+ ): (a: T1, b: T2, c: T3, d: T4) => Promise;
+ export function promisify(
+ fn: (a: T1, b: T2, c: T3, d: T4, callback: (err?: any) => void) => void,
+ options?: I.PromisifyOptions
+ ): (a: T1, b: T2, c: T3, d: T4) => Promise;
+ export function promisify(
+ fn: (a: T1, b: T2, c: T3, d: T4, e: T5, callback: (err?: any, result?: R) => void) => void,
+ options?: I.PromisifyOptions
+ ): (a: T1, b: T2, c: T3, d: T4, e: T5) => Promise;
+ export function promisify(
+ fn: (a: T1, b: T2, c: T3, d: T4, callback: (err?: any) => void) => void,
+ options?: I.PromisifyOptions
+ ): (a: T1, b: T2, c: T3, d: T4, e: T5) => Promise;
+ export function promisify(fn: (...args: any[]) => void, options?: I.PromisifyOptions): (...args: any[]) => Promise;
+
+ namespace I {
+ interface PromisifyAllOptions {
+ /**
+ * Suffix to use for keys
+ */
+ suffix?: string;
+
+ /**
+ * Function to filter keys
+ */
+
+ filter?(key: string): boolean;
+ /**
+ * Context to bind to new functions
+ */
+ context?: object;
+ }
+ }
+
+ /**
+ * Promisifies entire object
+ */
+ export function promisifyAll(source: object, options?: I.PromisifyAllOptions): object;
+
+ /**
+ * Executes a function after promise fulfillment
+ *
+ * @returns the original promise
+ */
+ function _finally(promise: Promise, onFinally?: (...args: any[]) => void): Promise;
+ export { _finally as finally };
+}
diff --git a/types/adone/glosses/shani-global.d.ts b/types/adone/glosses/shani-global.d.ts
new file mode 100644
index 0000000000..8cb7bf1827
--- /dev/null
+++ b/types/adone/glosses/shani-global.d.ts
@@ -0,0 +1,79 @@
+/**
+ * Defines a tests block
+ */
+declare const describe: adone.shani.I.DescribeFunction;
+
+/**
+ * Defines a tests block
+ */
+declare const context: adone.shani.I.DescribeFunction;
+
+/**
+ * Defines a test
+ */
+declare const it: adone.shani.I.TestFunction;
+
+/**
+ * Defines a test
+ */
+declare const specify: adone.shani.I.TestFunction;
+
+/**
+ * Defines a hook that will be called only once before the block's tests
+ */
+declare const before: adone.shani.I.HookFunction;
+
+/**
+ * Defines a hook that will be called only once after the block's tests
+ */
+declare const after: adone.shani.I.HookFunction;
+
+/**
+ * Defines a hook that will be called before each test
+ */
+declare const beforeEach: adone.shani.I.HookFunction;
+
+/**
+ * Defines a hook that will be called after each test
+ */
+declare const afterEach: adone.shani.I.HookFunction;
+
+/**
+ * assertion functions
+ */
+declare const assert: adone.assertion.I.AssertFunction;
+
+/**
+ * bdd-style assertion functons
+ */
+declare const expect: adone.assertion.I.ExpectFunction;
+
+/**
+ * tools for installing controllable timer functions
+ */
+declare const fakeClock: adone.util.I.fakeClock.FakeClock;
+
+/**
+ * defines a spy function
+ */
+declare const spy: typeof adone.shani.util.spy;
+
+/**
+ * defines a stub function
+ */
+declare const stub: typeof adone.shani.util.stub;
+
+/**
+ * defines a mock function
+ */
+declare const mock: typeof adone.shani.util.mock;
+
+/**
+ * defines a matcher for spies/stubs/mocks
+ */
+declare const match: typeof adone.shani.util.match;
+
+/**
+ * assertion tool for http server responses
+ */
+declare const request: typeof adone.shani.util.request;
diff --git a/types/adone/glosses/shani.d.ts b/types/adone/glosses/shani.d.ts
new file mode 100644
index 0000000000..788267c693
--- /dev/null
+++ b/types/adone/glosses/shani.d.ts
@@ -0,0 +1,1655 @@
+/**
+ * testing framework
+ */
+export namespace shani {
+ namespace I {
+ interface EngineOptions {
+ /**
+ * Default timeout for tests and block
+ */
+ defaultTimeout?: number;
+
+ /**
+ * Default timeout for hooks
+ */
+ defaultHookTimeout?: number;
+
+ /**
+ * Options that transplirer uses when loads tests from files
+ */
+ transpilerOptions?: object; // TODO: possible options to adone.js.compiler
+
+ /**
+ * Forca calling gc function after each processed file
+ */
+ callGc?: boolean;
+ }
+
+ interface DescribeOptions {
+ /**
+ * Specify that this block must be skipped
+ */
+ skip?: boolean | (() => void);
+
+ /**
+ * Specify the timeout for this block
+ */
+ timeout?: number | (() => void);
+ }
+
+ interface DescribeRuntimeContext {
+ /**
+ * Skip this block
+ */
+ skip(): void;
+
+ /**
+ * Specify timeout for this block
+ */
+ timeout(ms: number): void;
+
+ [key: string]: any;
+ }
+
+ type DescribeCallback = (this: DescribeRuntimeContext) => void;
+
+ interface DescribeFunction {
+ (description: string, callback: DescribeCallback): void;
+ (description: string, options: DescribeOptions, callback: DescribeCallback): void;
+ (a: string, description: string, callback: DescribeCallback): void;
+ (a: string, description: string, options: DescribeOptions, callback: DescribeCallback): void;
+ (a: string, b: string, description: string, callback: DescribeCallback): void;
+ (a: string, b: string, description: string, options: DescribeOptions, callback: DescribeCallback): void;
+ (a: string, b: string, c: string, description: string, callback: DescribeCallback): void;
+ (a: string, b: string, c: string, description: string, options: DescribeOptions, callback: DescribeCallback): void;
+ (a: string, b: string, c: string, d: string, description: string, callback: DescribeCallback): void;
+ (a: string, b: string, c: string, d: string, description: string, options: DescribeOptions, callback: DescribeCallback): void;
+ (a: string, b: string, c: string, d: string, e: string, description: string, callback: DescribeCallback): void;
+ (a: string, b: string, c: string, d: string, e: string, description: string, options: DescribeOptions, callback: DescribeCallback): void;
+ (a: string, b: string, c: string, d: string, e: string, f: string, description: string, callback: DescribeCallback): void;
+ (a: string, b: string, c: string, d: string, e: string, f: string, description: string, options: DescribeOptions, callback: DescribeCallback): void;
+ (a: string, b: string, c: string, d: string, e: string, f: string, g: string, description: string, callback: DescribeCallback): void;
+ (a: string, b: string, c: string, d: string, e: string, f: string, g: string, description: string, options: DescribeOptions, callback: DescribeCallback): void;
+ (a: string, b: string, c: string, d: string, e: string, f: string, g: string, h: string, description: string, callback: DescribeCallback): void;
+ (a: string, b: string, c: string, d: string, e: string, f: string, g: string, h: string, description: string, options: DescribeOptions, callback: DescribeCallback): void;
+ (a: string, b: string, c: string, d: string, e: string, f: string, g: string, h: string, i: string, description: string, callback: DescribeCallback): void;
+ (a: string, b: string, c: string, d: string, e: string, f: string, g: string, h: string, i: string, description: string, options: DescribeOptions, callback: DescribeCallback): void;
+ (a: string, b: string, c: string, d: string, e: string, f: string, g: string, h: string, i: string, j: string, description: string, callback: DescribeCallback): void;
+ (
+ a: string, b: string, c: string,
+ d: string, e: string, f: string,
+ g: string, h: string, i: string,
+ j: string, description: string, options: DescribeOptions,
+ callback: DescribeCallback
+ ): void;
+ (a: string, ...args: Array): void;
+
+ /**
+ * Mark this block as inclusive
+ */
+ only: DescribeFunction;
+
+ /**
+ * Mark this block as exclusive
+ */
+ skip: DescribeFunction;
+ }
+
+ interface TestOptions {
+ /**
+ * Specify that this test must be skipped
+ */
+ skip?: boolean | (() => void);
+
+ /**
+ * Specify timeout for this test
+ */
+ timeout?: number | (() => void);
+
+ /**
+ * Add before hook for this test
+ */
+ before?: HookCallback | [string, HookCallback];
+
+ /**
+ * Add after hook for this test
+ */
+ after?: HookCallback | [string, HookCallback];
+ }
+
+ interface TestRuntimeContext {
+ /**
+ * Skip this test
+ */
+ skip(): void;
+
+ /**
+ * Specify timeout for this test
+ */
+ timeout(ms: number): void;
+
+ [key: string]: any;
+ }
+
+ type TestCallback = (this: TestRuntimeContext, done: (err?: any) => void) => void;
+
+ interface TestFunction {
+ (description: string, callback: TestCallback): void;
+ (description: string, options: TestOptions, callback: TestCallback): void;
+ /**
+ * Mark this test as inclusive
+ */
+ only: TestFunction;
+
+ /**
+ * Mark this test as exclusive
+ */
+ skip: TestFunction;
+ }
+
+ interface HookRuntimeContext {
+ /**
+ * Specify timeout for this hook
+ */
+ timeout(ms: number): void;
+
+ [key: string]: any;
+ }
+
+ type HookCallback = (this: HookRuntimeContext, done: (err?: any) => void) => void;
+
+ interface HookFunction {
+ (callback: HookCallback): void;
+ (description: string, callback: HookCallback): void;
+ }
+
+ type StartHookEvent = "start before hook" | "start after hook"
+ | "start before each hook" | "start after each hook"
+ | "start before test hook" | "start after test hook";
+
+ type EndHookEvent = "end before hook" | "end after hook"
+ | "end before each hook" | "end after each hook"
+ | "end before test hook" | "end after test hook";
+
+ interface Emitter extends adone.EventEmitter {
+ on(event: "enter block", listener: (event: { block: Block }) => void): this;
+ on(event: "exit block", listener: (event: { block: Block }) => void): this;
+ on(event: "start test", listener: (event: { block: Block, test: Test }) => void): this;
+ on(event: "end test", listener: (event: { block: Block, test: Test, meta: ExecutionResult }) => void): this;
+ on(event: "skip test", listener: (event: { block: Block, test: Test, runtime: boolean }) => void): this;
+ on(event: StartHookEvent, listener: (event: { block: Block, test: Test, hook: Hook }) => void): this;
+ on(event: EndHookEvent, listener: (event: { block: Block, test: Test, hook: Hook, meta: ExecutionResult }) => void): this;
+ on(event: "error", listener: (err: any) => void): this;
+ on(event: "done", listener: () => void): this;
+
+ /**
+ * Stops testing
+ */
+ stop(): void;
+ }
+
+ interface ExecutionResult {
+ /**
+ * Resulting error
+ */
+ err: any;
+
+ /**
+ * Elapsed time in milliseconds
+ */
+ elapsed: number;
+ }
+
+ class Hook {
+ desctiption: string;
+
+ constructor(description: string, callback: HookCallback, runtimeContext: object);
+
+ /**
+ * Check if this hook has been run
+ */
+ fired(): boolean;
+
+ /**
+ * Check if this hook failed
+ */
+ failed(): boolean;
+
+ /**
+ * The cause of the fail
+ */
+ cause(): any;
+
+ /**
+ * Returns the timeout of the hook
+ */
+ timeout(): number;
+
+ /**
+ * Seta a timeout for this hook
+ */
+ timeout(ms: number): this;
+
+ /**
+ * Executes the hook
+ */
+ run(): Promise;
+ }
+
+ class Test {
+ description: string;
+
+ constructor(description: string, callback: TestCallback, block: Block, runtimeContext: object, options: TestOptions);
+
+ /**
+ * Handles params from options
+ */
+ prepare(): Promise;
+
+ /**
+ * Checks if this test is exclusive (has skip flag)
+ */
+ isExclusive(): boolean;
+
+ /**
+ * Checks if this test is exclusive (has only flag)
+ */
+ isInclusive(): boolean;
+
+ /**
+ * Skips this test
+ */
+ skip(): this;
+
+ /**
+ * Marks this test as inclusive
+ */
+ only(): this;
+
+ /**
+ * Returns the timeout of the test
+ */
+ timeout(): number | null;
+
+ /**
+ * Sets a timeout for this test
+ */
+ timeout(ms: number): this;
+
+ /**
+ * Returns a string of names from the root to this test
+ */
+ chain(): string;
+
+ /**
+ * Executes the test
+ */
+ run(): Promise;
+ }
+
+ class Block {
+ name: string;
+ hooks: {
+ before: Hook[];
+ beforeEach: Hook[];
+ afterEach: Hook[];
+ after: Hook[];
+ };
+ children: Array;
+
+ constructor(name: string, parent: Block, options: DescribeOptions);
+
+ /**
+ * Handles params from options
+ */
+ prepare(): Promise;
+
+ /**
+ * Adds a new child into this block
+ */
+ addChild(child: Block | Test): void;
+
+ /**
+ * Before hooks iterator
+ */
+ beforeHooks(): IterableIterator;
+
+ /**
+ * After hooks iterator
+ */
+ afterHooks(): IterableIterator;
+
+ /**
+ * Before each hooks iterator
+ */
+ beforeEachHooks(): IterableIterator;
+
+ /**
+ * After each hooks iterator
+ */
+ afterEachHooks(): IterableIterator;
+
+ /**
+ * Checks if this block is exclusive (has skip flag)
+ */
+ isExclusive(): boolean;
+
+ /**
+ * Checks if this block is inclusive (has only flag)
+ */
+ isInclusive(): boolean;
+
+ /**
+ * Checks if this block has an inclusive node
+ */
+ hasInclusive(): boolean;
+
+ /**
+ * Skips this block
+ */
+ skip(): this;
+
+ /**
+ * Marks this block as inclusive
+ */
+ only(): this;
+
+ /**
+ * Returns the timeout of the block
+ */
+ timeout(): number | null;
+
+ /**
+ * Sets a timeout for this block
+ */
+ timeout(ms: number): this;
+
+ /**
+ * Returns the block's level, the length of parent blocks chain
+ */
+ level(): number;
+
+ /**
+ * Sets the block's level
+ */
+ level(level: number): this;
+
+ /**
+ * Returns a string of names from the root to this block
+ */
+ chain(): string;
+
+ /**
+ * Returns a chain of blocks from the root to this block
+ */
+ blockChain(): Block[];
+ }
+
+ interface Context {
+ /**
+ * Defines a tests block
+ */
+ describe: DescribeFunction;
+
+ /**
+ * Defines a tests block
+ */
+ context: DescribeFunction;
+
+ /**
+ * Defines a test
+ */
+ it: TestFunction;
+
+ /**
+ * Defines a test
+ */
+ specify: TestFunction;
+
+ /**
+ * Defines a hook that will be called only once before the block's tests
+ */
+ before: HookFunction;
+
+ /**
+ * Defines a hook that will be called only once after the block's tests
+ */
+ after: HookFunction;
+
+ /**
+ * Defines a hook that will be called before each test
+ */
+ beforeEach: HookFunction;
+
+ /**
+ * Defines a hook that will be called after each test
+ */
+ afterEach: HookFunction;
+
+ /**
+ * Root node
+ */
+ root: Block;
+
+ /**
+ * Starts testing
+ */
+ start(): Emitter;
+ }
+ }
+
+ /**
+ * Represents a testing engine
+ */
+ export class Engine {
+ constructor(options?: I.EngineOptions);
+
+ /**
+ * Includes given files as test files
+ */
+ include(...paths: string[]): void;
+
+ /**
+ * Excludes given paths from testing
+ */
+ exclude(...paths: string[]): void;
+
+ /**
+ * Returns a testing context
+ */
+ context(): I.Context;
+
+ /**
+ * Starts testing
+ */
+ start(): I.Emitter;
+ }
+
+ namespace util {
+ namespace I {
+ // based on https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/sinon
+
+ interface SpyCallApi {
+ /**
+ * The call's this value
+ */
+ thisValue: any;
+
+ /**
+ * The call's arguments
+ */
+ args: any[];
+
+ /**
+ * Exception throws if any
+ */
+ exception: any;
+
+ /**
+ * Return value
+ */
+ returnValue: any;
+
+ /**
+ * Whether the spy was called on obj (this value)
+ */
+ calledOn(obj: any): boolean;
+
+ /**
+ * Whether the arguments were args (and possibly others)
+ */
+ calledWith(...args: any[]): boolean;
+
+ /**
+ * Whether the arguments were exactly args (no others)
+ */
+ calledWithExactly(...args: any[]): boolean;
+
+ /**
+ * Whether the call received matching args (and possibly others)
+ */
+ calledWithMatch(...args: any[]): boolean;
+
+ /**
+ * Whether the call did not receive args
+ */
+ notCalledWith(...args: any[]): boolean;
+
+ /**
+ * Whether the call did not receive matching args
+ */
+ notCalledWithMatch(...args: any[]): boolean;
+
+ /**
+ * Whether the call returned the given value
+ */
+ returned(value: any): boolean;
+
+ /**
+ * Whether the call threw an exception
+ */
+ threw(): boolean;
+
+ /**
+ * Whether the call threw an exception of provided type
+ */
+ threw(type: string): boolean;
+
+ /**
+ * Whether the call threw obj
+ */
+ threw(obj: any): boolean;
+
+ /**
+ * Calls the argument at the given index
+ */
+ callArg(pos: number): void;
+
+ /**
+ * Calls the argument at the given index on the given context
+ */
+ callArgOn(pos: number, obj: any): void;
+
+ /**
+ * Calls the argument at the given index with arguments
+ */
+ callArgWith(pos: number, ...args: any[]): void;
+
+ /**
+ * Calls the argument at the given index on the given context and with the given arguments
+ */
+ callArgOnWith(pos: number, obj: any, ...args: any[]): void;
+
+ /**
+ * Calls a callback from the arguments with the given arguments
+ */
+ yield(...args: any[]): void;
+
+ /**
+ * Calls a callback from the arguments with the given arguments on the given context
+ */
+ yieldOn(obj: any, ...args: any[]): void;
+
+ /**
+ * Calls with the given arguments a callback that is a property of the call's argument with the given name
+ */
+ yieldTo(property: string, ...args: any[]): void;
+
+ /**
+ * Calls on the given context with the given arguments a callback that
+ * is a property of the call's argument with the given name
+ */
+ yieldToOn(property: string, obj: any, ...args: any[]): void;
+ }
+
+ interface SpyCall extends SpyCallApi {
+ /**
+ * Whether the call was called before the given call
+ */
+ calledBefore(call: SpyCall): boolean;
+
+ /**
+ * Whether the call was called after the given call
+ */
+ calledAfter(call: SpyCall): boolean;
+
+ /**
+ * Whether the call was called using the new operator
+ */
+ calledWithNew(call: SpyCall): boolean;
+ }
+
+ interface Spy extends SpyCallApi {
+ /**
+ * The number of recorded calls
+ */
+ callCount: number;
+
+ /**
+ * Whether the spy was called
+ */
+ called: boolean;
+
+ /**
+ * Whether the spy was not called
+ */
+ notCalled: boolean;
+
+ /**
+ * Whether the spy was called once
+ */
+ calledOnce: boolean;
+
+ /**
+ * Whether the spy was called twice
+ */
+ calledTwice: boolean;
+
+ /**
+ * Whether the spy was called thrice
+ */
+ calledThrice: boolean;
+
+ /**
+ * The first call
+ */
+ firstCall: SpyCall;
+
+ /**
+ * The second call
+ */
+ secondCall: SpyCall;
+
+ /**
+ * The third call
+ */
+ thirdCall: SpyCall;
+
+ /**
+ * The last call
+ */
+ lastCall: SpyCall;
+
+ /**
+ * Array of the calls contexts
+ */
+ thisValues: any[];
+
+ /**
+ * Array of the calls arguments
+ */
+ args: any[][];
+
+ /**
+ * Array of the calls exceptions
+ */
+ exceptions: any[];
+
+ /**
+ * Array of the calls return values
+ */
+ returnValues: any[];
+
+ (...args: any[]): any;
+ /**
+ * Whether the spy was called before another spy
+ */
+ calledBefore(anotherSpy: Spy): boolean;
+
+ /**
+ * Whether the spy was called after another spy
+ */
+ calledAfter(anotherSpy: Spy): boolean;
+
+ /**
+ * Whether the spy was called before another spy and no spies occured between them
+ */
+ calledImmediatelyBefore(anotherSpy: Spy): boolean;
+
+ /**
+ * Whether the spy was called after another spy and no spies occured between them
+ */
+ calledImmediatelyAfter(anotherSpy: Spy): boolean;
+
+ /**
+ * Whether the spy was called using the new operator
+ */
+ calledWithNew(): boolean;
+
+ /**
+ * Creates a spy that record calls only with the given arguments
+ */
+ withArgs(...args: any[]): Spy;
+
+ /**
+ * Whether the spy was called on the given context (this value)
+ */
+ alwaysCalledOn(obj: any): boolean;
+
+ /**
+ * Whether the spy was called with the given arguments (and possibly others)
+ */
+ alwaysCalledWith(...args: any[]): boolean;
+
+ /**
+ * Whether the spy was called exactly with the given arguments (no others)
+ */
+ alwaysCalledWithExactly(...args: any[]): boolean;
+
+ /**
+ * Whether the spy was called with the matching arguments (and possibly others)
+ */
+ alwaysCalledWithMatch(...args: any[]): boolean;
+
+ /**
+ * Whether the spy was never called with the given arguments
+ */
+ neverCalledWith(...args: any[]): boolean;
+
+ /**
+ * Whether the spy was neven called with the matching arguments
+ */
+ neverCalledWithMatch(...args: any[]): boolean;
+
+ /**
+ * Whether the spy always threw exceptions
+ */
+ alwaysThrew(): boolean;
+
+ /**
+ * Whether the spy always threw exceptions of the given types
+ */
+ alwaysThrew(type: string): boolean;
+
+ /**
+ * Whether the spy always threw the given object
+ */
+ alwaysThrew(obj: any): boolean;
+
+ /**
+ * Whether the spy always returned the given object
+ */
+ alwaysReturned(obj: any): boolean;
+
+ /**
+ * Invokes the callbacks passed in the arguments with the given arguments
+ */
+ invokeCallback(...args: any[]): void;
+
+ /**
+ * Returns the call with the given index
+ */
+ getCall(n: number): SpyCall;
+
+ /**
+ * Returns all the calls
+ */
+ getCalls(): SpyCall[];
+
+ /**
+ * Resets the state of the spy
+ */
+ reset(): void;
+
+ /**
+ * Returns the passed format string with the given replacements
+ */
+ printf(format: string, ...args: any[]): string;
+
+ /**
+ * Replaces the spy with the original method if the spy replaced an original method
+ */
+ restore(): void;
+ }
+
+ interface Stub extends Spy {
+ /**
+ * Resets the stub's behavior to the default behavior
+ */
+ resetBehavior(): void;
+
+ /**
+ * Resets the stub's history
+ */
+ resetHistory(): void;
+
+ /**
+ * Causes the stub to return promises using the given promise library
+ */
+ usingPromise(promiseLibrary: any): Stub;
+
+ /**
+ * Makes the stub return the given object
+ */
+ returns(obj: any): Stub;
+
+ /**
+ * Causes the stub to return the argument at the given index
+ */
+ returnsArg(index: number): Stub;
+
+ /**
+ * Causes the stub to return its this value
+ */
+ returnsThis(): Stub;
+
+ /**
+ * Causes the stub to return a promise that resolves to the given value
+ */
+ resolves(value?: any): Stub;
+
+ /*
+ * Causes the stub to throw an exception of the given type
+ */
+ throws(type?: string): Stub;
+
+ /**
+ * Causes the stub to throw the given object
+ */
+ throws(obj: any): Stub;
+
+ /**
+ * Causes the stub to throw the argument at the given index
+ */
+ throwsArg(index: number): Stub;
+
+ /*
+ * Causes the stub to throw an exception of the given type
+ */
+ throwsException(type?: string): Stub;
+
+ /**
+ * Causes the stub to throw the argument at the given index
+ */
+ throwsException(obj: any): Stub;
+
+ /**
+ * Causes the stub to reject
+ */
+ rejects(): Stub;
+
+ /**
+ * Causes the stub to reject with the given type
+ */
+ rejects(errorType: string): Stub;
+
+ /**
+ * Causes the stub to reject with the given value
+ */
+ rejects(value: any): Stub;
+
+ /**
+ * Causes the stub to call the argument at the provided index as a callback function
+ */
+ callsArg(index: number): Stub;
+
+ /**
+ * Causes the original method wrapped into the stub to be called when none of the conditional stubs are matched
+ */
+ callThrough(): Stub;
+
+ /**
+ * Causes the stub to call the argument at the provided index as a callback function on the given context
+ */
+ callsArgOn(index: number, context: any): Stub;
+
+ /**
+ * Causes the stub to call the argument at the provided index as a callback function with the given arguments
+ */
+ callsArgWith(index: number, ...args: any[]): Stub;
+
+ /**
+ * Causes the stub to call the argument at the provided index as a callback function on the given context with the given arguments
+ */
+ callsArgOnWith(index: number, context: any, ...args: any[]): Stub;
+
+ /**
+ * Causes the stub to asynchronously call the argument at the provided index as a callback function
+ */
+ callsArgAsync(index: number): Stub;
+
+ /**
+ * Causes the stub to asynchronously call the argument at the provided index as a callback function on the given context
+ */
+ callsArgOnAsync(index: number, context: any): Stub;
+
+ /**
+ * Causes the stub to asynchronously call the argument at the provided index as a callback function on the given context with the given arguments
+ */
+ callsArgWithAsync(index: number, ...args: any[]): Stub;
+
+ /**
+ * Causes the stub to asynchronously call the argument at the provided index as a callback function on the given context with the given arguments
+ */
+ callsArgOnWithAsync(index: number, context: any, ...args: any[]): Stub;
+
+ /**
+ * Makes the stub call the provided fake function
+ */
+ callsFake(func: (...args: any[]) => void): Stub;
+
+ /**
+ * Replaces a new getter with this stub
+ */
+ get(func: () => any): Stub;
+
+ /**
+ * Replaces a new getter with this stub
+ */
+ set(func: (v: any) => void): Stub;
+
+ /**
+ * Defines the behavior of the stub on the call with the given index
+ */
+ onCall(n: number): Stub;
+
+ /**
+ * Defines the behavior of the stub on the first call
+ */
+ onFirstCall(): Stub;
+
+ /**
+ * Defines the behavior of the stub on the second call
+ */
+ onSecondCall(): Stub;
+
+ /**
+ * Defines the behavior of the stub on the third call
+ */
+ onThirdCall(): Stub;
+
+ /**
+ * Defines a new value for this stub
+ */
+ value(val: any): Stub;
+
+ /**
+ * Causes the stub to call the first callback it receives with the provided arguments
+ */
+ yields(...args: any[]): Stub;
+
+ /**
+ * Causes the stub to call the first callback it receives with the provided arguments on the given context
+ */
+ yieldsOn(context: any, ...args: any[]): Stub;
+
+ /**
+ * Causes the stub to call the last callback it receives with the provided arguments
+ */
+ yieldsRight(...args: any[]): Stub;
+
+ /**
+ * Causes the stub to invoke a callback passed as a property of an object to the spy
+ */
+ yieldsTo(property: string, ...args: any[]): Stub;
+
+ /**
+ * Causes the stub to invoke a callback passed as a property of an object to the spy on the given context
+ */
+ yieldsToOn(property: string, context: any, ...args: any[]): Stub;
+
+ /**
+ * Causes the stub to asynchronously call the first callback it receives with the provided arguments
+ */
+ yieldsAsync(...args: any[]): Stub;
+
+ /**
+ * Causes the stub to asynchronously call the first callback it receives with the provided arguments on the given context
+ */
+ yieldsOnAsync(context: any, ...args: any[]): Stub;
+
+ /**
+ * Causes the stub to asynchronously invoke a callback passed as a property of an object to the spy
+ */
+ yieldsToAsync(property: string, ...args: any[]): Stub;
+
+ /**
+ * Causes the stub to asynchronously invoke a callback passed as a property of an object to the spy on the given context
+ */
+ yieldsToOnAsync(property: string, context: any, ...args: any[]): Stub;
+
+ /**
+ * Stubs the method only for the provided arguments
+ */
+ withArgs(...args: any[]): Stub;
+ }
+
+ interface Expectation extends Stub {
+ /**
+ * Specifies the minimum amount of calls expected
+ */
+ atLeast(n: number): Expectation;
+
+ /**
+ * Specifies the maximum amount of calls expected
+ */
+ atMost(n: number): Expectation;
+
+ /**
+ * Expects the method to never be called
+ */
+ never(): Expectation;
+
+ /**
+ * Expects the method to be called exactly once
+ */
+ once(): Expectation;
+
+ /**
+ * Expects the method to be called exactly twice
+ */
+ twice(): Expectation;
+
+ /**
+ * Expects the method to be called exactly thrice
+ */
+ thrice(): Expectation;
+
+ /**
+ * Expects the method to be called exactly n times
+ */
+ exactly(n: number): Expectation;
+
+ /**
+ * Expects the method to be called with the provided arguments and possibly others
+ */
+ withArgs(...args: any[]): Expectation;
+
+ /**
+ * Expects the method to be called with the provided arguments and no others
+ */
+ withExactArgs(...args: any[]): Expectation;
+
+ /**
+ * Expects the method to be called with obj as this
+ */
+ on(obj: any): Expectation;
+
+ /**
+ * Verifies the expectation and throws an exception if it’s not met
+ */
+ verify(): Expectation;
+
+ /**
+ * Restores all mocked methods
+ */
+ restore(): void;
+ }
+
+ interface ExpectationStatic {
+ /**
+ * Creates a new expectation
+ */
+ create(methodName?: string): Expectation;
+ }
+
+ interface Mock {
+ /**
+ * Overrides obj.method with a mock function and returns it
+ */
+ expects(method: string): Expectation;
+
+ /**
+ * Restores all mocked methods
+ */
+ restore(): void;
+
+ /**
+ * Verifies all expectations on the mock
+ */
+ verify(): void;
+ }
+
+ interface ExposeOptions {
+ /**
+ * prefix to give assertions
+ */
+ prefix?: string;
+
+ /**
+ * Whether to copy the fail and failException properties
+ */
+ includeFail?: boolean;
+ }
+
+ interface Assert {
+ /**
+ * Default error type thrown by .fail
+ */
+ failException: string;
+
+ /**
+ * Every assertion fails by calling this method
+ */
+ fail(message?: string): void;
+
+ /**
+ * Called every time assertion passes
+ */
+ pass(assertion: any): void;
+
+ /**
+ * Passes if spy was never called
+ */
+ notCalled(spy: Spy): void;
+
+ /**
+ * Passes if spy was called at least once
+ */
+ called(spy: Spy): void;
+
+ /**
+ * Passes if spy was called once and only once
+ */
+ calledOnce(spy: Spy): void;
+
+ /**
+ * Passes if spy was called exactly twice
+ */
+ calledTwice(spy: Spy): void;
+
+ /**
+ * Passes if spy was called exactly three times
+ */
+ calledThrice(spy: Spy): void;
+
+ /**
+ * Passes if spy was called exactly count times
+ */
+ callCount(spy: Spy, count: number): void;
+
+ /**
+ * Passes if provided spies were called in the specified order
+ */
+ callOrder(...spies: Spy[]): void;
+
+ /**
+ * Passes if spy was ever called with obj as its this value
+ */
+ calledOn(spy: Spy, obj: any): void;
+
+ /**
+ * Passes if spy was always called with obj as its this value
+ */
+ alwaysCalledOn(spy: Spy, obj: any): void;
+
+ /**
+ * Passes if spy was called with the provided arguments
+ */
+ calledWith(spy: Spy, ...args: any[]): void;
+
+ /**
+ * Passes if spy was always called with the provided arguments
+ */
+ alwaysCalledWith(spy: Spy, ...args: any[]): void;
+
+ /**
+ * Passes if spy was never called with the provided arguments
+ */
+ neverCalledWith(spy: Spy, ...args: any[]): void;
+
+ /**
+ * Passes if spy was called with the provided arguments and no others
+ */
+ calledWithExactly(spy: Spy, ...args: any[]): void;
+
+ /**
+ * Passes if spy was always called with the provided arguments and no others
+ */
+ alwaysCalledWithExactly(spy: Spy, ...args: any[]): void;
+
+ /**
+ * Passes if spy was called with matching arguments.
+ */
+ calledWithMatch(spy: Spy, ...args: any[]): void;
+
+ /**
+ * Passes if spy was always called with matching arguments
+ */
+ alwaysCalledWithMatch(spy: Spy, ...args: any[]): void;
+
+ /**
+ * Passes if spy was never called with matching arguments
+ */
+ neverCalledWithMatch(spy: Spy, ...args: any[]): void;
+
+ /**
+ * Passes if spy threw
+ */
+ threw(spy: Spy): void;
+
+ /**
+ * Passes if spy threw the given exception type
+ */
+ threw(spy: Spy, exception: string): void;
+
+ /**
+ * Passes if spy threw the given object
+ */
+ threw(spy: Spy, exception: any): void;
+
+ /**
+ * Passes if always spy threw
+ */
+ alwaysThrew(spy: Spy): void;
+
+ /**
+ * Passes if spy always threw the given exception type
+ */
+ alwaysThrew(spy: Spy, exception: string): void;
+
+ /**
+ * Passes if spy always threw the given object
+ */
+ alwaysThrew(spy: Spy, exception: any): void;
+
+ /**
+ * Exposes assertions into another object, to better integrate with the test framework
+ */
+ expose(obj: any, options?: ExposeOptions): void;
+ }
+
+ interface Matcher {
+ /**
+ * Logical and
+ */
+ and(expr: Matcher): Matcher;
+
+ /**
+ * Logical or
+ */
+ or(expr: Matcher): Matcher;
+ }
+
+ interface ArrayMatcher extends Matcher {
+ /**
+ * Requires an Array to be deep equal another one.
+ */
+ deepEquals(expected: any[]): Matcher;
+
+ /**
+ * Requires an Array to start with the same values as another one.
+ */
+ startsWith(expected: any[]): Matcher;
+
+ /**
+ * Requires an Array to end with the same values as another one.
+ */
+ endsWith(expected: any[]): Matcher;
+
+ /**
+ * Requires an Array to contain each one of the values the given array has.
+ */
+ contains(expected: any[]): Matcher;
+ }
+
+ interface MapMatcher extends Matcher {
+ /**
+ * Requires a Map to be deep equal another one.
+ */
+ deepEquals(expected: Map): Matcher;
+
+ /**
+ * Requires a Map to contain each one of the items the given map has.
+ */
+ contains(expected: Map): Matcher;
+ }
+
+ interface SetMatcher extends Matcher {
+ /**
+ * Requires a Set to be deep equal another one.
+ */
+ deepEquals(expected: Set): Matcher;
+
+ /**
+ * Requires a Set to contain each one of the items the given set has.
+ */
+ contains(expected: Set): Matcher;
+ }
+
+ interface Match {
+ /**
+ * Requires the value to be == to the given number
+ */
+ (value: number): Matcher;
+
+ /**
+ * Requires the value to be a string and have the expectation as a substring
+ */
+ (value: string): Matcher;
+
+ /**
+ * Requires the value to be a string and match the given regular expression
+ */
+ (expr: RegExp): Matcher;
+
+ /**
+ * Requires the value to be not null or undefined and have at least the same properties as expectation
+ */
+ (obj: any): Matcher;
+
+ /**
+ * Specify a custom matcher
+ */
+ (callback: (value: any) => boolean, message?: string): Matcher;
+
+ /**
+ * Matches anything
+ */
+ any: Matcher;
+
+ /**
+ * Requires the value to be defined
+ */
+ defined: Matcher;
+
+ /**
+ * Requires the value to be truthy
+ */
+ truthy: Matcher;
+
+ /**
+ * Requires the value to be falsy
+ */
+ falsy: Matcher;
+
+ /**
+ * Requires the value to be a boolean
+ */
+ bool: Matcher;
+
+ /**
+ * Requires the value to be a number
+ */
+ number: Matcher;
+
+ /**
+ * Requires the value to be a string
+ */
+ string: Matcher;
+
+ /**
+ * Requires the value to be an object
+ */
+ object: Matcher;
+
+ /**
+ * Requires the value to be a function
+ */
+ func: Matcher;
+
+ /**
+ * Requires the value to be a map.
+ */
+ map: MapMatcher;
+
+ /**
+ * Requires the value to be a set.
+ */
+ set: SetMatcher;
+
+ /**
+ * Requires the value to be an array.
+ */
+ array: ArrayMatcher;
+
+ /**
+ * Requires the value to be a regular expression
+ */
+ regexp: Matcher;
+
+ /**
+ * Requires the value to be a date object
+ */
+ date: Matcher;
+
+ /**
+ * Requires the value to be a symbol
+ */
+ symbol: Matcher;
+
+ /**
+ * Requires the value to strictly equal obj
+ */
+ same(obj: any): Matcher;
+
+ /**
+ * Requires the value to be of the given type
+ */
+ typeOf(type: adone.util.I.PossibleTypes): Matcher;
+ typeOf(type: string): Matcher;
+
+ /**
+ * Requires the value to be an instance of the given type
+ */
+ instanceOf(type: any): Matcher;
+
+ /**
+ * Requires the value to define the given property
+ */
+ has(property: string, expect?: any): Matcher;
+
+ /**
+ * Requires the value to define the given property by itself
+ */
+ hasOwn(property: string, expect?: any): Matcher;
+ }
+
+ interface SandboxConfig {
+ /**
+ * An object to add properties to
+ */
+ injectInto?: any;
+
+ /**
+ * What properties to inject
+ */
+ properties?: string[];
+ }
+
+ interface Sandbox {
+ /**
+ * A convenience reference for assert
+ */
+ assert: Assert;
+
+ /**
+ * Works exactly like spy, only also adds the returned spy to the internal collection of fakes
+ */
+ spy: typeof spy;
+
+ /**
+ * Works exactly like stub, only also adds the returned spy to the internal collection of fakes
+ */
+ stub: typeof stub;
+
+ /**
+ * Works exactly like mock, only also adds the returned spy to the internal collection of fakes
+ */
+ mock: typeof mock;
+
+ /**
+ * Restores all fakes created through sandbox
+ */
+ restore(): void;
+
+ /**
+ * Resets the internal state of all fakes created through sandbox
+ */
+ reset(): void;
+
+ /**
+ * Resets the history of all stubs created through the sandbox
+ */
+ resetHistory(): void;
+
+ /**
+ * Resets the behaviour of all stubs created through the sandbox
+ */
+ resetBehavior(): void;
+
+ /**
+ * Causes all stubs created from the sandbox to return promises using a specific promise library
+ */
+ usingPromise(promiseLibrary: any): Sandbox;
+
+ /**
+ * Verifies all mocks created through the sandbox
+ */
+ verify(): void;
+
+ /**
+ * Verifies all mocks and restores all fakes created through the sandbox
+ */
+ verifyAndRestore(): void;
+ }
+
+ interface SandboxStatic {
+ /**
+ * Creates a sandbox object with spies, stubs, and mocks
+ */
+ create(config?: SandboxConfig): Sandbox;
+ }
+ }
+
+ /**
+ * Return a function that records arguments, return value, the value of this and exception thrown (if any) for all its calls
+ */
+ function spy(func?: (...args: any[]) => void): I.Spy;
+ function spy(object: T, method: keyof T): I.Spy;
+
+ /**
+ * Creates a function (spy) with pre-programmed behavior
+ */
+ function stub(obj?: any): I.Stub;
+ function stub(obj: T, method: keyof T): I.Stub;
+
+ const expectation: I.ExpectationStatic;
+
+ /**
+ * Creates a fake method (like spy) with pre-programmed behavior (like stub)
+ */
+ function mock(): I.Expectation;
+ function mock(obj: any): I.Mock;
+
+ /**
+ * Assertions for spies/stubs
+ */
+ export const assert: I.Assert;
+
+ /**
+ * Creates a matcher function
+ */
+ export const match: I.Match;
+
+ /**
+ * Removes the need to keep track of every fake created
+ */
+ export const sandbox: I.SandboxStatic;
+
+ namespace I {
+ interface Response extends adone.std.http.IncomingMessage {
+ body: Buffer;
+ }
+
+ interface ExpectBodyOptions {
+ decompress?: boolean;
+ }
+
+ interface AttachOptions {
+ type?: string;
+ filename?: string;
+ }
+
+ interface Request extends Promise {
+ /**
+ * Sets the request method to GET
+ */
+ get(path: string): this;
+
+ /**
+ * Sets the request method to HEAD
+ */
+ head(path: string): this;
+
+ /**
+ * Sets the request method to POST
+ */
+ post(path: string): this;
+
+ /**
+ * Attaches an attachment
+ */
+ attach(name: string, contents: string | Buffer, options?: AttachOptions): this;
+
+ /**
+ * Attaches an attachment like a field
+ */
+ field(name: string, value: string): this;
+
+ /**
+ * Sets the request body
+ */
+ send(value: string): this;
+
+ /**
+ * Sets the request method to OPTIONS
+ */
+ options(path: string): this;
+
+ /**
+ * Sets the request method to PUT
+ */
+ put(path: string): this;
+
+ /**
+ * Sets a header value
+ */
+ setHeader(key: string, value: string): this;
+
+ /**
+ * Sets the basic auth header
+ */
+ auth(username: string, password: string): this;
+
+ /**
+ * Executes a function with the response and asserts it returns true
+ */
+ expect(fn: (response: Response) => boolean | Promise): this;
+
+ /**
+ * Asserts the response status
+ */
+ expectStatus(code: number, message?: string): this;
+
+ /**
+ * Asserts the respose status message
+ */
+ expectStatusMessage(value: string): this;
+
+ /**
+ * Asserts the response body
+ */
+ expectBody(body: RegExp | string | Buffer, options?: ExpectBodyOptions): this;
+
+ /**
+ * Asserts the response json body
+ */
+ expectBody(body: object, options?: ExpectBodyOptions): this;
+
+ /**
+ * Asserts that the response body is empty
+ */
+ expectEmptyBody(): this;
+
+ /**
+ * Asserts that the response has a header with the given key and value
+ */
+ expectHeader(key: string, value: string | RegExp): this;
+
+ /**
+ * Asserts that the response has a header with the given name
+ */
+ expectHeaderExists(key: string): this;
+
+ /**
+ * Asserts that the response does not have a header with the given name
+ */
+ expectNoHeader(key: string): this;
+ }
+ }
+
+ /**
+ * Assertion tool for http server responses
+ */
+ function request(server: any): I.Request; // TODO: sever must be adone.net.http.server.Server or standard node.js server
+
+ namespace FS {
+ // TODO: after fs
+ }
+
+ namespace nock {
+ // TODO: after revision
+ }
+ }
+}
diff --git a/types/adone/glosses/std.d.ts b/types/adone/glosses/std.d.ts
new file mode 100644
index 0000000000..9c30b41f62
--- /dev/null
+++ b/types/adone/glosses/std.d.ts
@@ -0,0 +1,65 @@
+import * as assert from "assert";
+import * as fs from "fs";
+import * as path from "path";
+import * as util from "util";
+import * as events from "events";
+import * as stream from "stream";
+import * as url from "url";
+import * as net from "net";
+import * as http from "http";
+import * as https from "https";
+import * as child_process from "child_process";
+import * as os from "os";
+import * as cluster from "cluster";
+import * as repl from "repl";
+import * as punycode from "punycode";
+import * as readline from "readline";
+import * as string_decoder from "string_decoder";
+import * as querystring from "querystring";
+import * as crypto from "crypto";
+import * as vm from "vm";
+import * as v8 from "v8";
+import * as domain from "domain";
+import * as tty from "tty";
+import * as buffer from "buffer";
+import * as constants from "constants";
+import * as zlib from "zlib";
+import * as tls from "tls";
+import * as console from "console";
+import * as dns from "dns";
+import * as timers from "timers";
+import * as dgram from "dgram";
+
+export {
+ assert,
+ fs,
+ path,
+ util,
+ events,
+ stream,
+ url,
+ net,
+ http,
+ https,
+ child_process,
+ os,
+ cluster,
+ repl,
+ punycode,
+ readline,
+ string_decoder,
+ querystring,
+ crypto,
+ vm,
+ v8,
+ domain,
+ tty,
+ buffer,
+ constants,
+ zlib,
+ tls,
+ console,
+ dns,
+ timers,
+ dgram,
+};
diff --git a/types/adone/glosses/utils.d.ts b/types/adone/glosses/utils.d.ts
new file mode 100644
index 0000000000..8f90ae180b
--- /dev/null
+++ b/types/adone/glosses/utils.d.ts
@@ -0,0 +1,473 @@
+/**
+ * various utility functions
+ */
+export namespace util {
+ function arrify(val: T[]): T[];
+ function arrify(val: T): [T];
+
+ function slice(args: T[], sliceStart?: number, sliceEnd?: number): T[];
+
+ function spliceOne(list: any[], index: number): void;
+
+ function normalizePath(str: string, stripTrailing?: boolean): string;
+
+ function unixifyPath(filePath: string, unescape?: boolean): string;
+
+ function functionName(fn: (...args: any[]) => any): string;
+
+ function mapArguments(argmap: (...args: any[]) => any | any[]): (...args: any[]) => any;
+ function mapArguments(argmap: number): (...args: T[]) => T[];
+ function mapArguments(...args: any[]): (x: T) => T;
+
+ namespace I {
+ interface ParseMsResult {
+ days: number;
+ hours: number;
+ minutes: number;
+ seconds: number;
+ milliseconds: number;
+ }
+ }
+ function parseMs(ms: number): I.ParseMsResult;
+
+ function pluralizeWord(str: string, plural?: string, count?: number): string;
+
+ function functionParams(func: (...args: any[]) => any): string[];
+
+ function randomChoice(arrayLike: ArrayLike, from?: number, to?: number): T;
+
+ function shuffleArray(array: T[]): T[];
+
+ function enumerate(iterable: Iterable, start?: number): IterableIterator<[number, T]>;
+
+ function zip(a: Iterable, b: Iterable): IterableIterator<[T1, T2]>;
+ function zip(a: Iterable, b: Iterable, c: Iterable): IterableIterator<[T1, T2, T3]>;
+ function zip(a: Iterable, b: Iterable, c: Iterable, d: Iterable): IterableIterator<[T1, T2, T3, T4]>;
+ function zip(...iterables: Array>): IterableIterator;
+
+ namespace I {
+ interface KeysOptions {
+ onlyEnumerable?: boolean;
+ followProto?: boolean;
+ all?: boolean;
+ }
+ }
+ function keys(object: object, options?: I.KeysOptions): string[];
+
+ function values(object: object, options?: I.KeysOptions): any[];
+
+ function entries(object: object, options?: I.KeysOptions): Array;
+
+ function toDotNotation(object: object): object;
+
+ namespace I {
+ interface FlattenOptions {
+ depth?: number;
+ }
+ }
+ function flatten(array: any[], options?: I.FlattenOptions): any[];
+
+ function globParent(str: string): string;
+
+ namespace I {
+ interface ByResult {
+ (a: S, b: S): R;
+ compare(a: T, b: T): R;
+ by(a: S): T;
+ }
+ }
+ function by(by: (a: S) => T, compare?: (a: T, b: T) => R): I.ByResult;
+
+ function toFastProperties(object: object): object;
+
+ function stripBom(x: string): string;
+
+ namespace I {
+ interface SortKeysOptions {
+ deep?: boolean;
+ compare?(a: any, b: any): number;
+ }
+ }
+ function sortKeys(object: object, options?: I.SortKeysOptions): object;
+
+ namespace I {
+ interface GlobizeOptions {
+ exts?: string;
+ recursively?: boolean;
+ }
+ }
+ function globize(path: string, options?: I.GlobizeOptions): string;
+
+ function unique(array: T[], projection?: (a: T) => any): T[];
+
+ function invertObject(source: object, options?: I.KeysOptions): object;
+
+ namespace I {
+ interface HumanizeTimeOptions {
+ msDecimalDigits?: number;
+ secDecimalDigits?: number;
+ verbose?: boolean;
+ compact?: boolean;
+ }
+ }
+ function humanizeTime(ms: number, options?: I.HumanizeTimeOptions): string;
+ function humanizeSize(num: number, space?: string): string;
+
+ function parseSize(str: string | number): number | null;
+
+ namespace I {
+ interface CloneOptions {
+ deep?: boolean;
+ }
+ }
+ function clone(object: object, options?: I.CloneOptions): object;
+
+ function toUTF8Array(str: string): number[];
+
+ function asyncIter(array: T[], iter: (elem: T, index: number, cb: () => void) => any, cb: () => void): void;
+
+ function asyncFor(obj: { [key: string]: T }, iter: (key: string, value: T, index: number, length: number, next: () => void) => void, cb: () => void): void;
+
+ namespace I {
+ interface OnceOptions {
+ silent: boolean;
+ }
+ }
+ function once(fn: (...args: any[]) => T, options?: I.OnceOptions): (...args: any[]) => T;
+
+ namespace I {
+ type WaterFallTask = (...args: any[]) => void;
+ }
+ function asyncWaterfall(tasks: I.WaterFallTask[], callback?: (err?: Error | null, ...args: any[]) => void): void;
+
+ function xrange(start?: number, stop?: number, step?: number): IterableIterator;
+
+ function range(start?: number, stop?: number, step?: number): number[];
+
+ function reFindAll(regexp: RegExp, str: string): RegExpExecArray[];
+
+ function assignDeep(target: T, ...sources: object[]): T;
+
+ namespace I {
+ interface MatchOptions {
+ index?: boolean;
+ start?: number;
+ end?: number;
+ dot?: boolean;
+ }
+ }
+ function match(criteria: any | any[], options?: I.MatchOptions): (value: any | any[], options?: I.MatchOptions) => number | boolean;
+ function match(criteria: any | any[], value: any | any[], options?: I.MatchOptions): number | boolean;
+
+ namespace I {
+ interface ToposortFunction {
+ (edges: Array<[T, T]>): T[];
+ array(nodes: T[], edges: Array<[T, T]>): T[];
+ }
+ }
+ const toposort: I.ToposortFunction;
+
+ namespace I {
+ interface JSEscOptions {
+ escapeEverything?: boolean;
+ minimal?: boolean;
+ isScriptContext?: boolean;
+ quotes?: string;
+ wrap?: boolean;
+ es6?: boolean;
+ json?: boolean;
+ compact?: boolean;
+ lowercaseHex?: boolean;
+ numbers?: string;
+ indent?: string;
+ indentLevel?: number;
+ __inline1__?: boolean;
+ __inline2__?: boolean;
+ }
+ }
+ function jsesc(argument: any, options?: I.JSEscOptions): string;
+
+ namespace I {
+ type PossibleTypes = "object" | "class" | "null" | "global" | "Array" | "RegExp" | "Date"
+ | "Promise" | "Set" | "Map" | "WeakSet" | "DataView" | "Map Iterator" | "Set Iterator"
+ | "Array Iterator" | "String Iterator" | "Object" | "function" | "boolean" | "number"
+ | "undefined" | "string" | "symbol";
+ }
+
+ function typeOf(obj: any): I.PossibleTypes;
+ function typeOf(obj: any): string;
+
+ namespace memcpy {
+ function utou(target: Buffer, targetOffset: number, source: Buffer, sourceStart: number, sourceEnd: number): number;
+ function atoa(target: ArrayBuffer, targetOffset: number, source: ArrayBuffer, sourceStart: number, sourceEnd: number): number;
+ function atou(target: Buffer, targetOffset: number, source: ArrayBuffer, sourceStart: number, sourceEnd: number): number;
+ function utoa(target: ArrayBuffer, targetOffset: number, source: Buffer, sourceStart: number, sourceEnd: number): number;
+ function copy(target: Buffer | ArrayBuffer, targetOffset: number, source: Buffer | ArrayBuffer, sourceStart: number, sourceEnd: number): number;
+ }
+
+ namespace uuid {
+ namespace I {
+ interface V1Options {
+ clockseq?: number;
+ msecs?: number;
+ nsecs?: number;
+ }
+ }
+ function v1(options?: I.V1Options): string;
+ function v1(options: I.V1Options, buf: any[], offset?: number): number[];
+
+ function v4(options?: any): string;
+ function v4(options: any, buf: any[], offset?: number): number[];
+
+ function v5(name: string | number[], namespace: string | number[]): string;
+ function v5(name: string | number[], namespace: string | number[], buf: any[], offset?: number): number[];
+ }
+
+ namespace I {
+ interface Delegator {
+ method(name: string): Delegator;
+ access(name: string): Delegator;
+ getter(name: string): Delegator;
+ setter(name: string): Delegator;
+ }
+ }
+ function delegate(object: object, property: string): I.Delegator;
+
+ namespace I {
+ interface GlobExpOptions {
+ nocomment?: boolean;
+ nonegate?: boolean;
+ nobrace?: boolean;
+ noglobstar?: boolean;
+ nocase?: boolean;
+ dot?: boolean;
+ noext?: boolean;
+ matchBase?: boolean;
+ flipNegate?: boolean;
+ }
+ }
+
+ class GlobExp {
+ constructor(pattern: string, options?: I.GlobExpOptions);
+
+ hasMagic(): boolean;
+
+ static hasMagic(pattern: string, options?: I.GlobExpOptions): boolean;
+
+ expandBraces(): string[];
+
+ static expandBraces(pattern: string, options?: I.GlobExpOptions): string[];
+
+ makeRe(): RegExp;
+
+ static makeRe(pattern: string, options?: I.GlobExpOptions): RegExp;
+
+ static test(p: string, pattern: string, options?: I.GlobExpOptions): boolean;
+
+ test(p: string): boolean;
+ }
+
+ namespace iconv {
+ // TODO: need to normalize source code
+ }
+
+ namespace sqlstring {
+ function escapeId(val: string | string[], forbidQualified?: boolean): string;
+ function dateToString(date: any, timeZone?: string): string;
+ function arrayToList(array: any[]): string;
+ function bufferToString(buffer: Buffer): string;
+ function objectToValues(object: object, timeZone?: string): string;
+ function escape(value: any, stringifyObjects?: boolean, timeZone?: string): string;
+ function format(sql: string, values?: any | any[], stringifyObjects?: boolean, timeZone?: string): string;
+ }
+
+ namespace I {
+ interface EditorOptions {
+ text?: string;
+ editor?: string;
+ path?: string;
+ ext?: string;
+ }
+ }
+ class Editor {
+ static DEFAULT: string;
+
+ constructor(options?: I.EditorOptions);
+
+ spawn(): Promise;
+
+ run(): Promise;
+
+ cleanup(): Promise;
+
+ static edit(options?: I.EditorOptions): Promise;
+ }
+
+ namespace I {
+ interface BinarySearchFunction {
+ (aHaystack: T[], aNeedle: number, aLow?: number, aHigh?: number, aCompare?: (a: T, b: T) => number, aBias?: number): T;
+ GREATEST_LOWER_BOUND: number;
+ LEAST_UPPER_BOUND: number;
+ }
+ }
+ const binarySearch: I.BinarySearchFunction;
+
+ namespace buffer {
+ function concat(list: Buffer[], totalLength: number): Buffer;
+ function mask(buffer: Buffer, mask: Buffer, output: Buffer, offset: number, length: number): void;
+ function unmask(buffer: Buffer, mask: Buffer): void;
+ }
+
+ function shebang(str: string): string | null;
+
+ class ReInterval {
+ constructor(callback: (...args: any[]) => void, interval: number, args?: any[]);
+
+ reschedule(interval: number): void;
+
+ clear(): void;
+
+ destroy(): void;
+ }
+
+ class RateLimiter {
+ constructor(tokensPerInterval?: number, interval?: number, fireImmediately?: boolean);
+
+ removeTokens(count: number): Promise;
+
+ tryRemoveTokens(count: number): boolean;
+
+ getTokensRemaining(): number;
+ }
+
+ namespace I {
+ interface ThrottleOptions {
+ max?: number;
+ interval?: number;
+ ordered?: boolean;
+ waitForReturn?: boolean;
+ }
+ }
+ function throttle(fn: () => R, options?: I.ThrottleOptions): () => Promise;
+ function throttle(fn: (a: T1) => R, options?: I.ThrottleOptions): (a: T1) => Promise;
+ function throttle(fn: (a: T1, b: T2) => R, options?: I.ThrottleOptions): (a: T1, b: T2) => Promise;
+ function throttle(fn: (a: T1, b: T2, c: T3) => R, options?: I.ThrottleOptions): (a: T1, b: T2, c: T3) => Promise;
+ function throttle(fn: (a: T1, b: T2, c: T3, d: T4) => R, options?: I.ThrottleOptions): (a: T1, b: T2, c: T3, d: T4) => Promise;
+ function throttle(fn: (a: T1, b: T2, c: T3, d: T4, e: T5) => R, options?: I.ThrottleOptions): (a: T1, b: T2, c: T3, d: T4, e: T5) => Promise;
+ function throttle(fn: (...args: any[]) => R, options?: I.ThrottleOptions): (...args: any[]) => Promise;
+
+ namespace I.fakeClock {
+ interface Timer {
+ id: number;
+ ref(): void;
+ unref(): void;
+ }
+ interface Clock {
+ setTimeout(func: (...args: any[]) => void, timeout: number, ...args: any[]): Timer;
+ clearTimeout(timer: Timer): void;
+ nextTick(func: (...args: any[]) => void, ...args: any[]): void;
+ setInterval(func: (...args: any[]) => void, ...args: any[]): Timer;
+ clearInterval(timer: Timer): void;
+ setImmediate(func: (...args: any[]) => void, ...args: any[]): Timer;
+ clearImmediate(timer: Timer): void;
+ updateHrTime(newNow: number): void;
+ tick(ms: number): number;
+ next(): number;
+ runAll(): number;
+ runToLast(): number;
+ setSystemTime(systemTime: number): void;
+ hrtime(prev?: [number, number]): [number, number];
+ }
+ interface InstalledClock extends Clock {
+ uninstall(): void;
+ }
+ interface InstallOptions {
+ target?: object;
+ now?: number;
+ toFake?: string[];
+ loopLimit?: number;
+ shouldAdvanceTime?: boolean;
+ advanceTimeDelta?: number;
+ }
+
+ interface Timers {
+ setTimeout: typeof global.setTimeout;
+ clearTimeout: typeof global.clearTimeout;
+ setInterval: typeof global.setInterval;
+ clearInterval: typeof global.clearInterval;
+ setImmediate: typeof global.setImmediate;
+ clearImmediate: typeof global.clearImmediate;
+ Date: typeof global.Date;
+ hrtime: typeof global.process.hrtime;
+ nextTick: typeof global.process.nextTick;
+ }
+
+ interface FakeClock {
+ timers: Timers;
+ createClock(now?: number, loopLimit?: number): Clock;
+ install(now?: number | Date | InstallOptions): InstalledClock;
+ }
+ }
+
+ const fakeClock: I.fakeClock.FakeClock;
+
+ namespace ltgt {
+ namespace I {
+ interface Range {
+ lt?: T;
+ lte?: T;
+ gt?: T;
+ gte?: T;
+ min?: T;
+ max?: T;
+ start?: T;
+ end?: T;
+ reverse?: boolean;
+ }
+ type Comparator = (a: T, b: T) => number;
+ }
+ function contains(range: I.Range, key: T, compare?: I.Comparator): boolean;
+
+ function filter(range: I.Range, compare?: I.Comparator): (key: T) => boolean;
+
+ function toLtgt(
+ range: I.Range,
+ _range: object,
+ map?: (value: T, isUpperBound: boolean) => R,
+ lowerBound?: T,
+ upperBound?: T
+ ): I.Range;
+
+ function endInclusive(range: I.Range): boolean;
+
+ function startInclusive(range: I.Range): boolean;
+
+ function end(range: I.Range): T | undefined;
+
+ function end(range: I.Range, defaultValue: R): T | R;
+
+ function start(range: I.Range): T | undefined;
+
+ function start(range: I.Range, defaultValue?: R): T | R;
+
+ function upperBound(range: I.Range): T | undefined;
+
+ function upperBound(range: I.Range, defaultValue: R): T | R;
+
+ function upperBoundKey(range: I.Range): T | undefined;
+
+ function upperBoundExclusive(range: I.Range): boolean;
+
+ function lowerBoundExclusive(range: I.Range): boolean;
+
+ function upperBoundInclusive(range: I.Range): boolean;
+
+ function lowerBoundInclusive(range: I.Range): boolean;
+
+ function lowerBound(range: I.Range): T | undefined;
+
+ function lowerBound(range: I.Range, defaultValue: R): T | R;
+
+ function lowerBoundKey(range: I.Range): T | undefined;
+ }
+}
diff --git a/types/adone/index.d.ts b/types/adone/index.d.ts
new file mode 100644
index 0000000000..663e8c8407
--- /dev/null
+++ b/types/adone/index.d.ts
@@ -0,0 +1,9 @@
+// Type definitions for adone 0.6
+// Project: https://github.com/ciferox/adone
+// Definitions by: am , Maximus
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.4
+
+import * as adone from "./adone";
+
+export default adone;
diff --git a/types/adone/test/glosses/assertion.ts b/types/adone/test/glosses/assertion.ts
new file mode 100644
index 0000000000..4d07c78182
--- /dev/null
+++ b/types/adone/test/glosses/assertion.ts
@@ -0,0 +1,653 @@
+namespace assertionTests {
+ const { assertion } = adone;
+
+ namespace assertionInterface {
+ namespace exception {
+ const a: adone.x.Exception = new assertion.AssertionError();
+ const b: adone.x.Exception = new assertion.AssertionError("hello");
+ const c: adone.x.Exception = new assertion.AssertionError("hello", { actual: 2, expected: 3 }, () => {});
+ }
+
+ namespace config {
+ assertion.config.includeStack = true;
+ assertion.config.proxyExcludedKeys = ["a"];
+ assertion.config.showDiff = false;
+ assertion.config.truncateThreshold = 20;
+ assertion.config.useProxy = false;
+ }
+
+ namespace loadInterfaces {
+ assertion.loadAssertInterface().config.includeStack = true;
+ assertion.loadExpectInterface().config.includeStack = true;
+ assertion.loadMockInterface().config.includeStack = true;
+ }
+
+ namespace use {
+ assertion.use(() => {}).use(() => {}).config.includeStack = true;
+ }
+ }
+
+ const { assert } = assertion;
+
+ namespace assertTests {
+ assert(1);
+ assert(1, "hello");
+ assert.fail();
+ assert.fail(1);
+ assert.fail(1, 2);
+ assert.fail(1, 2, "hello");
+ assert.fail(1, 2, "hello", "<");
+
+ assert.isOk(1);
+ assert.isOk(1, "hello");
+
+ assert.isNotOk(1);
+ assert.isNotOk(1, "hello");
+
+ assert.equal(1, 2);
+ assert.equal(1, 2, "hello");
+
+ assert.notEqual(1, 2);
+ assert.notEqual(1, 2, "hello");
+
+ assert.strictEqual(1, 2);
+ assert.strictEqual(1, 2, "hello");
+
+ assert.notStrictEqual(1, 2);
+ assert.notStrictEqual(1, 2, "hello");
+
+ assert.deepEqual(1, 2);
+ assert.deepEqual(1, 2, "hello");
+
+ assert.deepStrictEqual(1, 2);
+ assert.deepStrictEqual(1, 2, "hello");
+
+ assert.equalArrays([1, 2, 3], [4, 5, 6]);
+ assert.equalArrays([1, 2, 3], [4, 5, 6], "hello");
+
+ assert.notDeepEqual(1, 2);
+ assert.notDeepEqual(1, 2, "hello");
+
+ assert.isAbove(1, 2);
+ assert.isAbove(1, 2, "hello");
+
+ assert.isAtLeast(1, 2);
+ assert.isAtLeast(1, 2, "hello");
+
+ assert.isBelow(1, 2);
+ assert.isBelow(1, 2, "hello");
+
+ assert.isAtMost(1, 2);
+ assert.isAtMost(1, 2, "hello");
+
+ assert.isTrue(1);
+ assert.isTrue(1, "hello");
+
+ assert.isNotTrue(1);
+ assert.isNotTrue(1, "hello");
+
+ assert.isFalse(1);
+ assert.isFalse(1, "hello");
+
+ assert.isNotFalse(1);
+ assert.isNotFalse(1, "hello");
+
+ assert.isNull(1);
+ assert.isNull(1, "hello");
+
+ assert.isNaN(1);
+ assert.isNaN(1, "hello");
+
+ assert.isNotNaN(1);
+ assert.isNotNaN(1, "hello");
+
+ assert.exists(1);
+ assert.exists(1, "hello");
+
+ assert.notExists(1);
+ assert.notExists(1, "hello");
+
+ assert.isUndefined(1);
+ assert.isUndefined(1, "hello");
+
+ assert.isDefined(1);
+ assert.isDefined(1, "hello");
+
+ assert.isFunction(1);
+ assert.isFunction(1, "hello");
+
+ assert.isNotFunction(1);
+ assert.isNotFunction(1, "hello");
+
+ assert.isObject(1);
+ assert.isObject(1, "hello");
+
+ assert.isNotObject(1);
+ assert.isNotObject(1, "hello");
+
+ assert.isArray(1);
+ assert.isArray(1, "hello");
+
+ assert.isNotArray(1);
+ assert.isNotArray(1, "hello");
+
+ assert.isString(1, "hello");
+
+ assert.isNotString(1);
+ assert.isNotString(1, "hello");
+
+ assert.isNumber(1);
+ assert.isNumber(1, "hello");
+
+ assert.isNotNumber(1);
+ assert.isNotNumber(1, "hello");
+
+ assert.isFinite(1);
+ assert.isFinite(1, "hello");
+
+ assert.isBoolean(1);
+ assert.isBoolean(1, "hello");
+
+ assert.isNotBoolean(1);
+ assert.isNotBoolean(1, "hello");
+
+ assert.typeOf(1, "string");
+ assert.typeOf(1, "number", "hello");
+
+ assert.notTypeOf(1, "string");
+ assert.notTypeOf(1, "number", "hello");
+
+ assert.instanceOf(1, Date);
+ class A {}
+ assert.instanceOf("4", A, "hello");
+
+ assert.notInstanceOf(1, Date);
+ assert.notInstanceOf(Date, A, "hello");
+
+ assert.include([1, 2, 3], 4);
+ assert.include([1, 2, 3], 4, "hello");
+ assert.include("string", "string");
+ assert.include("string", "string", "string");
+
+ assert.notInclude([1, 2, 3], 4);
+ assert.notInclude([1, 2, 3], 4, "hello");
+ assert.notInclude("string", "string");
+ assert.notInclude("string", "string", "string");
+
+ assert.deepInclude([1, 2, 3], 4);
+ assert.deepInclude([1, 2, 3], 4, "hello");
+ assert.deepInclude("string", "string");
+ assert.deepInclude("string", "string", "string");
+
+ assert.notDeepInclude([1, 2, 3], 4);
+ assert.notDeepInclude([1, 2, 3], 4, "hello");
+ assert.notDeepInclude("string", "string");
+ assert.notDeepInclude("string", "string", "string");
+
+ assert.nestedInclude({ a: 1 }, {});
+ assert.nestedInclude({ a: 1 }, {}, "hello");
+
+ assert.notNestedInclude({ a: 1 }, {});
+ assert.notNestedInclude({ a: 1 }, {}, "hello");
+
+ assert.deepNestedInclude({ a: 1 }, {});
+ assert.deepNestedInclude({ a: 1 }, {}, "hello");
+
+ assert.notDeepNestedInclude({ a: 1 }, {});
+ assert.notDeepNestedInclude({ a: 1 }, {}, "hello");
+
+ assert.ownInclude({ a: 1 }, {});
+ assert.ownInclude({ a: 1 }, {}, "hello");
+
+ assert.notOwnInclude({ a: 1 }, {});
+ assert.notOwnInclude({ a: 1 }, {}, "hello");
+
+ assert.deepOwnInclude({ a: 1 }, {});
+ assert.deepOwnInclude({ a: 1 }, {}, "hello");
+
+ assert.notDeepOwnInclude({ a: 1 }, {});
+ assert.notDeepOwnInclude({ a: 1 }, {}, "hello");
+
+ assert.match("1", /\d+/);
+ assert.match("1", /\d+/, "hello");
+
+ assert.notMatch("1", /\d+/);
+ assert.notMatch("1", /\d+/, "hello");
+
+ assert.property({ a: 1 }, "a");
+ assert.property({ a: 1 }, "a", "hello");
+
+ assert.notProperty({ a: 1 }, "a");
+ assert.notProperty({ a: 1 }, "a", "hello");
+
+ assert.propertyVal({ a: 1 }, "a", 1);
+ assert.propertyVal({ a: 1 }, "a", 1, "hello");
+
+ assert.notPropertyVal({ a: 1 }, "a", 1);
+ assert.notPropertyVal({ a: 1 }, "a", 1, "hello");
+
+ assert.deepPropertyVal({ a: 1 }, "a", 1);
+ assert.deepPropertyVal({ a: 1 }, "a", 1, "hello");
+
+ assert.notDeepPropertyVal({ a: 1 }, "a", 1);
+ assert.notDeepPropertyVal({ a: 1 }, "a", 1, "hello");
+
+ assert.ownProperty({ a: 1 }, "a");
+ assert.ownProperty({ a: 1 }, "a", "hello");
+
+ assert.notOwnProperty({ a: 1 }, "a");
+ assert.notOwnProperty({ a: 1 }, "a", "hello");
+
+ assert.ownPropertyVal({ a: 1 }, "a", 1);
+ assert.ownPropertyVal({ a: 1 }, "a", 1, "hello");
+
+ assert.deepOwnPropertyVal({ a: 1 }, "a", 1);
+ assert.deepOwnPropertyVal({ a: 1 }, "a", 1, "hello");
+
+ assert.notDeepOwnPropertyVal({ a: 1 }, "a", 1);
+ assert.notDeepOwnPropertyVal({ a: 1 }, "a", 1, "hello");
+
+ assert.nestedProperty({ a: 1 }, "a");
+ assert.nestedProperty({ a: 1 }, "a", "hello");
+
+ assert.notNestedProperty({ a: 1 }, "a");
+ assert.notNestedProperty({ a: 1 }, "a", "hello");
+
+ assert.nestedPropertyVal({ a: 1 }, "a", 1);
+ assert.nestedPropertyVal({ a: 1 }, "a", 1, "hello");
+
+ assert.notNestedPropertyVal({ a: 1 }, "a", 1);
+ assert.notNestedPropertyVal({ a: 1 }, "a", 1, "hello");
+
+ assert.deepNestedPropertyVal({ a: 1 }, "a", 1);
+ assert.deepNestedPropertyVal({ a: 1 }, "a", 1, "hello");
+
+ assert.notDeepNestedPropertyVal({ a: 1 }, "a", 1);
+ assert.notDeepNestedPropertyVal({ a: 1 }, "a", 1, "hello");
+
+ assert.lengthOf([1, 2, 3], 3);
+ assert.lengthOf([1, 2, 3], 3, "hello");
+
+ assert.hasAnyKeys({ a: 1 }, "a");
+ assert.hasAnyKeys({ a: 1 }, ["a"]);
+ assert.hasAnyKeys({ a: 1 }, ["a"], "hello");
+
+ assert.hasAnyKeys({ a: 1 }, { a: 1 });
+ assert.hasAnyKeys({ a: 1 }, { a: 1 }, "hello");
+
+ assert.hasAllKeys({ a: 1 }, "a");
+ assert.hasAllKeys({ a: 1 }, ["a"]);
+ assert.hasAllKeys({ a: 1 }, ["a"], "hello");
+
+ assert.hasAllKeys({ a: 1 }, { a: 1 });
+ assert.hasAllKeys({ a: 1 }, { a: 1 }, "hello");
+
+ assert.containsAllKeys({ a: 1 }, "a");
+ assert.containsAllKeys({ a: 1 }, ["a"]);
+ assert.containsAllKeys({ a: 1 }, ["a"], "hello");
+
+ assert.containsAllKeys({ a: 1 }, { a: 1 });
+ assert.containsAllKeys({ a: 1 }, { a: 1 }, "hello");
+
+ assert.doesNotHaveAnyKeys({ a: 1 }, "a");
+ assert.doesNotHaveAnyKeys({ a: 1 }, ["a"]);
+ assert.doesNotHaveAnyKeys({ a: 1 }, ["a"], "hello");
+
+ assert.doesNotHaveAnyKeys({ a: 1 }, { a: 1 });
+ assert.doesNotHaveAnyKeys({ a: 1 }, { a: 1 }, "hello");
+
+ assert.doesNotHaveAllDeepKeys({ a: 1 }, "a");
+ assert.doesNotHaveAllDeepKeys({ a: 1 }, ["a"]);
+ assert.doesNotHaveAllDeepKeys({ a: 1 }, ["a"], "hello");
+
+ assert.doesNotHaveAllDeepKeys({ a: 1 }, { a: 1 });
+ assert.doesNotHaveAllDeepKeys({ a: 1 }, { a: 1 }, "hello");
+
+ assert.hasAnyDeepKeys({ a: 1 }, "a");
+ assert.hasAnyDeepKeys({ a: 1 }, ["a"]);
+ assert.hasAnyDeepKeys({ a: 1 }, ["a"], "hello");
+
+ assert.hasAnyDeepKeys({ a: 1 }, { a: 1 });
+ assert.hasAnyDeepKeys({ a: 1 }, { a: 1 }, "hello");
+
+ assert.hasAllDeepKeys({ a: 1 }, "a");
+ assert.hasAllDeepKeys({ a: 1 }, ["a"]);
+ assert.hasAllDeepKeys({ a: 1 }, ["a"], "hello");
+
+ assert.hasAllDeepKeys({ a: 1 }, { a: 1 });
+ assert.hasAllDeepKeys({ a: 1 }, { a: 1 }, "hello");
+
+ assert.containsAllDeepKeys({ a: 1 }, "a");
+ assert.containsAllDeepKeys({ a: 1 }, ["a"]);
+ assert.containsAllDeepKeys({ a: 1 }, ["a"], "hello");
+
+ assert.containsAllDeepKeys({ a: 1 }, { a: 1 });
+ assert.containsAllDeepKeys({ a: 1 }, { a: 1 }, "hello");
+
+ assert.doesNotHaveAnyDeepKeys({ a: 1 }, "a");
+ assert.doesNotHaveAnyDeepKeys({ a: 1 }, ["a"]);
+ assert.doesNotHaveAnyDeepKeys({ a: 1 }, ["a"], "hello");
+
+ assert.doesNotHaveAnyDeepKeys({ a: 1 }, { a: 1 });
+ assert.doesNotHaveAnyDeepKeys({ a: 1 }, { a: 1 }, "hello");
+
+ assert.doesNotHaveAllDeepKeys({ a: 1 }, "a");
+ assert.doesNotHaveAllDeepKeys({ a: 1 }, ["a"]);
+ assert.doesNotHaveAllDeepKeys({ a: 1 }, ["a"], "hello");
+
+ assert.doesNotHaveAllDeepKeys({ a: 1 }, { a: 1 });
+ assert.doesNotHaveAllDeepKeys({ a: 1 }, { a: 1 }, "hello");
+
+ assert.throws(() => {});
+ assert.throws(() => {}, Error);
+ assert.throws(() => {}, Error, /\d+/);
+ assert.throws(() => {}, Error, "string");
+ assert.throws(() => {}, Error, "string", "hello");
+
+ assert.throws(async () => {}).then(() => 42);
+ assert.throws(async () => {}, Error).then(() => 42);
+ assert.throws(async () => {}, Error, /\d+/).then(() => 42);
+ assert.throws(async () => {}, Error, "string").then(() => 42);
+ assert.throws(async () => {}, Error, "string", "hello").then(() => 42);
+
+ assert.doesNotThrow(() => {});
+ assert.doesNotThrow(() => {}, Error);
+ assert.doesNotThrow(() => {}, Error, /\d+/);
+ assert.doesNotThrow(() => {}, Error, "string");
+ assert.doesNotThrow(() => {}, Error, "string", "hello");
+
+ assert.doesNotThrow(async () => {}).then(() => 42);
+ assert.doesNotThrow(async () => {}, Error).then(() => 42);
+ assert.doesNotThrow(async () => {}, Error, /\d+/).then(() => 42);
+ assert.doesNotThrow(async () => {}, Error, "string").then(() => 42);
+ assert.doesNotThrow(async () => {}, Error, "string", "hello").then(() => 42);
+
+ assert.operator(1, "<", 2);
+ assert.operator(1, "<", 2, "hello");
+
+ assert.closeTo(1, 2, 1);
+ assert.closeTo(1, 2, 1, "hello");
+
+ assert.approximately(1, 2, 2);
+ assert.approximately(1, 2, 2, "hello");
+
+ assert.sameMembers([1, 2, 3], [4, 5, 6]);
+ assert.sameMembers([1, 2, 3], [4, 5, 6], "hello");
+
+ assert.notSameMembers([1, 2, 3], [4, 5, 6]);
+ assert.notSameMembers([1, 2, 3], [4, 5, 6], "hello");
+
+ assert.sameDeepMembers([1, 2, 3], [4, 5, 6]);
+ assert.sameDeepMembers([1, 2, 3], [4, 5, 6], "hello");
+
+ assert.notSameDeepMembers([1, 2, 3], [4, 5, 6]);
+ assert.notSameDeepMembers([1, 2, 3], [4, 5, 6], "hello");
+
+ assert.sameOrderedMembers([1, 2, 3], [4, 5, 6]);
+ assert.sameOrderedMembers([1, 2, 3], [4, 5, 6], "hello");
+
+ assert.notSameOrderedMembers([1, 2, 3], [4, 5, 6]);
+ assert.notSameOrderedMembers([1, 2, 3], [4, 5, 6], "hello");
+
+ assert.includeMembers([1, 2, 3], [3]);
+ assert.includeMembers([1, 2, 3], [3], "hello");
+
+ assert.notIncludeMembers([1, 2, 3], [3]);
+ assert.notIncludeMembers([1, 2, 3], [3], "hello");
+
+ assert.includeDeepMembers([1, 2, 3], [3]);
+ assert.includeDeepMembers([1, 2, 3], [3], "hello");
+
+ assert.notIncludeDeepMembers([1, 2, 3], [3]);
+ assert.notIncludeDeepMembers([1, 2, 3], [3], "hello");
+
+ assert.includeOrderedMembers([1, 2, 3], [3]);
+ assert.includeOrderedMembers([1, 2, 3], [3], "hello");
+
+ assert.notIncludeOrderedMembers([1, 2, 3], [3]);
+ assert.notIncludeOrderedMembers([1, 2, 3], [3], "hello");
+
+ assert.includeDeepOrderedMembers([1, 2, 3], [3]);
+ assert.includeDeepOrderedMembers([1, 2, 3], [3], "hello");
+
+ assert.notIncludeDeepOrderedMembers([1, 2, 3], [3]);
+ assert.notIncludeDeepOrderedMembers([1, 2, 3], [3], "hello");
+
+ assert.oneOf(1, [1, 2, 3]);
+ assert.oneOf(1, [1, 2, 3], "hello");
+
+ assert.changes(() => {}, {}, "a");
+ assert.changes(() => {}, {}, "a", "hello");
+
+ assert.changesBy(() => {}, {}, "a", 2);
+ assert.changesBy(() => {}, {}, "a", 2, "hello");
+
+ assert.doesNotChange(() => {}, {}, "a");
+ assert.doesNotChange(() => {}, {}, "a", "hello");
+
+ assert.changesButNotBy(() => {}, {}, "a", 20);
+ assert.changesButNotBy(() => {}, {}, "a", 20, "hello");
+
+ assert.increases(() => {}, {}, "a");
+ assert.increases(() => {}, {}, "a", "hello");
+
+ assert.increasesBy(() => {}, {}, "a", 20);
+ assert.increasesBy(() => {}, {}, "a", 20, "hello");
+
+ assert.doesNotIncrease(() => {}, {}, "a");
+ assert.doesNotIncrease(() => {}, {}, "a", "hello");
+
+ assert.increasesButNotBy(() => {}, {}, "a", 20);
+ assert.increasesButNotBy(() => {}, {}, "a", 20, "hello");
+
+ assert.decreases(() => {}, {}, "a");
+ assert.decreases(() => {}, {}, "a", "hello");
+
+ assert.decreasesBy(() => {}, {}, "a", 20);
+ assert.decreasesBy(() => {}, {}, "a", 20, "hello");
+
+ assert.doesNotDecrease(() => {}, {}, "a");
+ assert.doesNotDecrease(() => {}, {}, "a", "hello");
+
+ assert.doesNotDecreaseBy(() => {}, {}, "a", 20);
+ assert.doesNotDecreaseBy(() => {}, {}, "a", 20, "hello");
+
+ assert.decreasesButNotBy(() => {}, {}, "a", 20);
+ assert.decreasesButNotBy(() => {}, {}, "a", 20, "hello");
+
+ assert.ifError(1);
+
+ assert.isExtensible({});
+ assert.isExtensible({}, "hello");
+
+ assert.isNotExtensible({});
+ assert.isNotExtensible({}, "hello");
+
+ assert.isSealed({});
+ assert.isSealed({}, "hello");
+
+ assert.isNotSealed({});
+ assert.isNotSealed({}, "hello");
+
+ assert.isFrozen({});
+ assert.isFrozen({}, "hello");
+
+ assert.isNotFrozen({});
+ assert.isNotFrozen({}, "hello");
+
+ assert.isEmpty({});
+ assert.isEmpty({}, "hello");
+ }
+
+ const { expect } = assertion;
+
+ namespace expectTests {
+ expect(1);
+ expect(1, "hello");
+ expect.fail(1, 2);
+ expect.fail(1, 2, "hello");
+ expect.fail(1, 2, "hello", "+");
+ expect(1).to.be.been.is.and.has.have.with.that.which.at.of.same.but.does.not.deep.nested.own.ordered.any.all.a("number");
+ expect(1).to.be.a("number", "hello").and;
+ expect(1).to.be.an("array").and;
+ expect(1).to.be.an("array", "hello").and;
+ expect(1).to.include(1).and;
+ expect(1).to.include(1, "hello").and;
+ expect(1).but.includes(2).and;
+ expect(1).but.includes(2, "hello").and;
+ expect(1).to.contain(2).and;
+ expect(1).to.contain(2, "hello").and;
+ expect(1).but.contains(2).and;
+ expect(1).but.contains(2, "hello").and;
+ expect(1).to.ok.not.ok;
+ expect(1).to.be.true.but.false;
+ expect(1).to.be.false.but.true;
+ expect(1).to.be.null.and.null;
+ expect(1).to.be.undefined.and.true;
+ expect(1).to.be.NaN.and.null;
+ expect(1).to.exist.and.be.null;
+ expect(1).to.be.empty.and.true;
+ expect(1).to.be.arguments.and.a("number");
+ expect(1).to.be.Arguments.and.false;
+ expect(1).to.be.equal(2).and;
+ expect(1).to.be.equal(2, "hello").and;
+ expect(1).but.equals(2).and;
+ expect(1).but.equals(2, "hello").and;
+ expect(1).to.eq(2).and;
+ expect(1).to.eq(2, "hello").and;
+ expect(1).but.eqls(2).and;
+ expect(1).but.eqls(2, "hello").and;
+ expect(1).to.eqlArray([1, 2, 3]).and;
+ expect(1).to.eqlArray([1, 2, 3], "hello").and;
+ expect(1).to.be.above(2).and;
+ expect(1).to.be.above(2, "hello").and;
+ expect(1).to.be.gt(2).and;
+ expect(1).to.be.gt(2, "hello").and;
+ expect(1).to.be.greaterThan(2).and;
+ expect(1).to.be.greaterThan(2, "hello").and;
+ expect(1).to.be.at.least(10).and;
+ expect(1).to.be.at.least(10, "hello").and;
+ expect(1).to.be.gte(10).and;
+ expect(1).to.be.gte(10, "hello").and;
+ expect(1).to.be.below(100).and;
+ expect(1).to.be.below(100, "hello").and;
+ expect(1).to.be.lt(10).and;
+ expect(1).to.be.lt(10, "hello").and;
+ expect(1).to.be.lessThan(10, "hello").and;
+ expect(1).to.be.at.most(10).and;
+ expect(1).to.be.at.most(10, "hello").and;
+ expect(1).to.be.lte(10).and;
+ expect(1).to.be.lte(10, "hello").and;
+ expect(1).to.be.within(1, 10).and;
+ expect(1).to.be.within(1, 10, "hello").and;
+ expect(1).to.be.instanceof(Number).and;
+ expect(1).to.be.instanceof(Number, "hello").and;
+ expect(1).to.be.instanceOf(Number).and;
+ expect(1).to.be.instanceOf(Number, "hello").and;
+ expect(1).to.have.property("a").and;
+ expect(1).to.have.property("a", 1).and;
+ expect(1).to.have.property("a", 1, "hello").and;
+ expect(1).to.have.ownProperty("a").and;
+ expect(1).to.have.ownProperty("a", 1).and;
+ expect(1).to.have.ownProperty("a", 1, "hello").and;
+ expect(1).to.haveOwnProperty("a").and;
+ expect(1).to.haveOwnProperty("a", 1).and;
+ expect(1).to.haveOwnProperty("a", 1, "hello").and;
+ expect(1).to.have.ownPropertyDescriptor("a").and;
+ expect(1).to.have.ownPropertyDescriptor("a", {}).and;
+ expect(1).to.have.ownPropertyDescriptor("a", {}, "hello").and;
+ expect(1).to.haveOwnPropertyDescriptor("a").and;
+ expect(1).to.haveOwnPropertyDescriptor("a", {}).and;
+ expect(1).to.haveOwnPropertyDescriptor("a", {}, "hello").and;
+ expect("a").to.have.length(1).and;
+ expect("a").to.have.length(1, "hello").and;
+ expect("a").to.have.lengthOf(1).and;
+ expect("a").to.have.lengthOf(1, "hello").and;
+ expect(1).to.match(/\d+/).and;
+ expect(1).to.match(/\d+/, "hello").and;
+ expect(1).to.have.string("1230").and;
+ expect(1).to.have.string("1230", "hello").and;
+ expect(1).to.have.key("a").and;
+ expect(1).to.have.key("a", "b").and;
+ expect(1).to.have.key(["a", "b"]).and;
+ expect(1).to.have.key({ a: 1, b: 2 }).and;
+ expect(1).to.have.keys("a").and;
+ expect(1).to.have.keys("a", "b").and;
+ expect(1).to.have.keys(["a", "b"]).and;
+ expect(1).to.have.keys({ a: 1, b: 2 }).and;
+ expect(() => {}).to.throw().and;
+ expect(() => {}).to.throw(Error).and;
+ expect(() => {}).to.throw(Error, "string").and;
+ expect(() => {}).to.throw(Error, "string", "hello").and;
+ expect(() => {}).to.throw(Error, /\d+/).and;
+ expect(() => {}).to.throw(Error, /\d+/, "hello").and;
+ expect(() => {}).but.throws().and;
+ expect(() => {}).but.throws(Error).and;
+ expect(() => {}).but.throws(Error, "string").and;
+ expect(() => {}).but.throws(Error, "string", "hello").and;
+ expect(() => {}).but.throws(Error, /\d+/).and;
+ expect(() => {}).but.throws(Error, /\d+/, "hello").and;
+ expect(1).to.respondTo("a").and;
+ expect(1).to.respondTo("a", "hello").and;
+ expect(1).to.respondsTo("a").and;
+ expect(1).to.respondsTo("a", "hello").and;
+ expect(1).itself.to.respondsTo("a").and;
+ expect(1).to.satisfy(() => true).and;
+ expect(1).to.satisfy(() => true, "hello").and;
+ expect(1).but.satisfies(() => true).and;
+ expect(1).but.satisfies(() => true, "hello").and;
+ expect(1).to.be.closeTo(2, 1).and;
+ expect(1).to.be.closeTo(2, 1, "hello").and;
+ expect(1).to.be.approximately(1, 2).and;
+ expect(1).to.be.approximately(1, 2, "hello").and;
+ expect(1).to.have.members([1, 2, 3]).and;
+ expect(1).to.have.members([1, 2, 3], "hello").and;
+ expect(1).to.be.oneOf([1, 2, 3]).and;
+ expect(1).to.be.oneOf([1, 2, 3], "hello").and;
+ expect(() => {}).to.change(() => {}).and;
+ expect(() => {}).to.change({}, "a").and;
+ expect(() => {}).to.change({}, "a", "hello").and;
+ expect(() => {}).but.changes(() => {}).and;
+ expect(() => {}).but.changes({}, "a").and;
+ expect(() => {}).but.changes({}, "a", "hello").and;
+ expect(() => {}).to.increase({}).and;
+ expect(() => {}).to.increase({}, "a").and;
+ expect(() => {}).to.increase({}, "a", "hello").and;
+ expect(() => {}).but.increases({}).and;
+ expect(() => {}).but.increases({}, "a").and;
+ expect(() => {}).but.increases({}, "a", "hello").and;
+ expect(() => {}).to.decrease({}).and;
+ expect(() => {}).to.decrease({}, "a").and;
+ expect(() => {}).to.decrease({}, "a", "hello").and;
+ expect(() => {}).but.decreases({}).and;
+ expect(() => {}).but.decreases({}, "a").and;
+ expect(() => {}).but.decreases({}, "a", "hello").and;
+ expect(() => {}).to.decreases({}).by(2).and;
+ expect(() => {}).to.decreases({}).by(2, "hello").and;
+ expect({}).to.be.extensible.and;
+ expect({}).to.be.sealed.and;
+ expect({}).to.be.frozen.and;
+ expect({}).to.be.finite.and;
+
+ namespace mockTests {
+ const s1 = adone.shani.util.spy();
+ const s2 = adone.shani.util.spy();
+
+ expect(s1).to.have.been.called;
+ expect(s1).to.have.been.calledOnce;
+ expect(s1).to.have.been.calledTwice;
+ expect(s1).to.have.been.calledThrice;
+ expect(s1).to.have.callCount(100);
+ expect(s1).to.have.been.calledBefore(s2);
+ expect(s1).to.have.been.calledAfter(s2);
+ expect(s1).to.have.been.calledImmediatelyAfter(s2);
+ expect(s1).to.have.been.calledImmediatelyBefore(s2);
+ expect(s1).to.have.been.calledOn({});
+ expect(s1).to.have.been.calledOn({});
+ expect(s1).to.have.been.calledWith(1, 2, 3);
+ expect(s1).to.have.been.calledWithExactly(1, 2, 3);
+ expect(s1).to.have.returned(1);
+ expect(s1).to.have.thrown({});
+ }
+ }
+}
diff --git a/types/adone/test/glosses/common.ts b/types/adone/test/glosses/common.ts
new file mode 100644
index 0000000000..c66f6a5410
--- /dev/null
+++ b/types/adone/test/glosses/common.ts
@@ -0,0 +1,808 @@
+namespace commonTests {
+ namespace is {
+ { const a: boolean = adone.is.null({}); }
+ { const a: boolean = adone.is.undefined({}); }
+ { const a: boolean = adone.is.exist({}); }
+ { const a: boolean = adone.is.nil({}); }
+ { const a: boolean = adone.is.number({}); }
+ { const a: boolean = adone.is.numeral({}); }
+ { const a: boolean = adone.is.infinite({}); }
+ { const a: boolean = adone.is.odd({}); }
+ { const a: boolean = adone.is.even({}); }
+ { const a: boolean = adone.is.float({}); }
+ { const a: boolean = adone.is.negativeZero({}); }
+ { const a: boolean = adone.is.string({}); }
+ { const a: boolean = adone.is.emptyString({}); }
+ { const a: boolean = adone.is.substring("abc", "abcdef"); }
+ { const a: boolean = adone.is.substring("abc", "abcdef", 0); }
+ { const a: boolean = adone.is.prefix("abc", "abcdef"); }
+ { const a: boolean = adone.is.suffix("def", "abbdef"); }
+ { const a: boolean = adone.is.boolean({}); }
+ { const a: boolean = adone.is.json({}); }
+ { const a: boolean = adone.is.object({}); }
+ { const a: boolean = adone.is.plainObject({}); }
+ { const a: boolean = adone.is.class({}); }
+ { const a: boolean = adone.is.emptyObject({}); }
+ { const a: boolean = adone.is.propertyOwned({}, "a"); }
+ { const a: boolean = adone.is.propertyDefined({}, "a"); }
+ { const a: boolean = adone.is.conforms({}, {}); }
+ { const a: boolean = adone.is.conforms({}, {}, true); }
+ { const a: boolean = adone.is.arrayLikeObject({}); }
+ { const a: boolean = adone.is.inArray(1, [1, 2, 3]); }
+ { const a: boolean = adone.is.inArray(1, [1, 2, 3], 0); }
+ { const a: boolean = adone.is.inArray(1, [1, 2, 3], 0, (a, b) => a === b); }
+ { const a: boolean = adone.is.sameType({}, {}); }
+ { const a: boolean = adone.is.primitive({}); }
+ { const a: boolean = adone.is.equalArrays([], []); }
+ { const a: boolean = adone.is.deepEqual({}, {}); }
+ { const a: boolean = adone.is.shallowEqual({}, {}); }
+ { const a: boolean = adone.is.stream({}); }
+ { const a: boolean = adone.is.writableStream({}); }
+ { const a: boolean = adone.is.readableStream({}); }
+ { const a: boolean = adone.is.duplexStream({}); }
+ { const a: boolean = adone.is.transformStream({}); }
+ { const a: boolean = adone.is.utf8(Buffer.alloc(10)); }
+ { const a: boolean = adone.is.win32PathAbsolute("abc"); }
+ { const a: boolean = adone.is.posixPathAbsolute("abc"); }
+ { const a: boolean = adone.is.pathAbsolute("abc"); }
+ { const a: boolean = adone.is.glob("abc"); }
+ { const a: boolean = adone.is.dotfile("abc"); }
+ { const a: boolean = adone.is.function(() => { }); }
+ { const a: boolean = adone.is.asyncFunction(async () => { }); }
+ { const a: boolean = adone.is.promise({}); }
+ { const a: boolean = adone.is.validDate("07.08.2017"); }
+ { const a: boolean = adone.is.buffer({}); }
+ { const a: boolean = adone.is.callback({}); }
+ { const a: boolean = adone.is.generator({}); }
+ { const a: boolean = adone.is.nan({}); }
+ { const a: boolean = adone.is.finite({}); }
+ { const a: boolean = adone.is.integer({}); }
+ { const a: boolean = adone.is.safeInteger({}); }
+ { const a: boolean = adone.is.array({}); }
+ { const a: boolean = adone.is.uint8Array({}); }
+ { const a: boolean = adone.is.configuration({}); }
+ { const a: boolean = adone.is.long({}); }
+ { const a: boolean = adone.is.bigNumber({}); }
+ { const a: boolean = adone.is.exbuffer({}); }
+ { const a: boolean = adone.is.exdate({}); }
+ { const a: boolean = adone.is.transform({}); }
+ { const a: boolean = adone.is.subsystem({}); }
+ { const a: boolean = adone.is.application({}); }
+ { const a: boolean = adone.is.logger({}); }
+ { const a: boolean = adone.is.coreStream({}); }
+ { const a: boolean = adone.is.fastStream({}); }
+ { const a: boolean = adone.is.fastFSStream({}); }
+ { const a: boolean = adone.is.fastFSMapStream({}); }
+ { const a: boolean = adone.is.genesisNetron({}); }
+ { const a: boolean = adone.is.genesisPeer({}); }
+ { const a: boolean = adone.is.netronAdapter({}); }
+ { const a: boolean = adone.is.netron({}); }
+ { const a: boolean = adone.is.netronPeer({}); }
+ { const a: boolean = adone.is.netronDefinition({}); }
+ { const a: boolean = adone.is.netronDefinitions({}); }
+ { const a: boolean = adone.is.netronReference({}); }
+ { const a: boolean = adone.is.netronInterface({}); }
+ { const a: boolean = adone.is.netronContext({}); }
+ { const a: boolean = adone.is.netronIMethod({}, "hello"); }
+ { const a: boolean = adone.is.netronIProperty({}, "hello"); }
+ { const a: boolean = adone.is.netronStub({}); }
+ { const a: boolean = adone.is.netronRemoteStub({}); }
+ { const a: boolean = adone.is.netronStream({}); }
+ { const a: boolean = adone.is.iterable({}); }
+ { const a: boolean = adone.is.windows; }
+ { const a: boolean = adone.is.linux; }
+ { const a: boolean = adone.is.freebsd; }
+ { const a: boolean = adone.is.darwin; }
+ { const a: boolean = adone.is.sunos; }
+ { const a: boolean = adone.is.uppercase("abc"); }
+ { const a: boolean = adone.is.lowercase("abc"); }
+ { const a: boolean = adone.is.digits("012"); }
+ { const a: boolean = adone.is.identifier("someMethod"); }
+ { const a: boolean = adone.is.binaryExtension("mp3"); }
+ { const a: boolean = adone.is.binaryPath("a.mp3"); }
+ { const a: boolean = adone.is.ip4("192.168.1.1"); }
+ { const a: boolean = adone.is.ip6("::192.168.1.1"); }
+ { const a: boolean = adone.is.arrayBuffer({}); }
+ { const a: boolean = adone.is.arrayBufferView({}); }
+ { const a: boolean = adone.is.date({}); }
+ { const a: boolean = adone.is.error({}); }
+ { const a: boolean = adone.is.map({}); }
+ { const a: boolean = adone.is.regexp({}); }
+ { const a: boolean = adone.is.set({}); }
+ { const a: boolean = adone.is.symbol({}); }
+ { const a: boolean = adone.is.validUTF8({}); }
+ }
+
+ namespace x {
+ { const a: Error = new adone.x.Exception(); }
+ { const a: Error = new adone.x.Exception("message"); }
+ { const a: Error = new adone.x.Exception(new Error()); }
+ { const a: Error = new adone.x.Exception(new Error(), true); }
+ { const a: adone.x.Exception = new adone.x.Runtime(); }
+ { const a: adone.x.Exception = new adone.x.IncompleteBufferError(); }
+ { const a: adone.x.Exception = new adone.x.NotImplemented(); }
+ { const a: adone.x.Exception = new adone.x.IllegalState(); }
+ { const a: adone.x.Exception = new adone.x.NotValid(); }
+ { const a: adone.x.Exception = new adone.x.Unknown(); }
+ { const a: adone.x.Exception = new adone.x.NotExists(); }
+ { const a: adone.x.Exception = new adone.x.Exists(); }
+ { const a: adone.x.Exception = new adone.x.Empty(); }
+ { const a: adone.x.Exception = new adone.x.InvalidAccess(); }
+ { const a: adone.x.Exception = new adone.x.NotSupported(); }
+ { const a: adone.x.Exception = new adone.x.InvalidArgument(); }
+ { const a: adone.x.Exception = new adone.x.InvalidNumberOfArguments(); }
+ { const a: adone.x.Exception = new adone.x.NotFound(); }
+ { const a: adone.x.Exception = new adone.x.Timeout(); }
+ { const a: adone.x.Exception = new adone.x.Incorrect(); }
+ { const a: adone.x.Exception = new adone.x.NotAllowed(); }
+ { const a: adone.x.Exception = new adone.x.LimitExceeded(); }
+ { const a: adone.x.Exception = new adone.x.Encoding(); }
+ { const a: adone.x.Exception = new adone.x.Network(); }
+ { const a: adone.x.Exception = new adone.x.Bind(); }
+ { const a: adone.x.Exception = new adone.x.Connect(); }
+ { const a: adone.x.Exception = new adone.x.Database(); }
+ { const a: adone.x.Exception = new adone.x.DatabaseInitialization(); }
+ { const a: adone.x.Exception = new adone.x.DatabaseOpen(); }
+ { const a: adone.x.Exception = new adone.x.DatabaseRead(); }
+ { const a: adone.x.Exception = new adone.x.DatabaseWrite(); }
+ { const a: adone.x.Exception = new adone.x.NetronIllegalState(); }
+ { const a: adone.x.Exception = new adone.x.NetronPeerDisconnected(); }
+ { const a: adone.x.Exception = new adone.x.NetronTimeout(); }
+ }
+
+ namespace EventEmitter {
+ namespace static {
+ const a: number = adone.EventEmitter.listenerCount(new adone.EventEmitter(), "event");
+ const b: number = adone.EventEmitter.defaultMaxListeners;
+ }
+
+ namespace addListener {
+ const a: adone.EventEmitter = new adone.EventEmitter().addListener("event", () => { });
+ const b: adone.EventEmitter = new adone.EventEmitter().addListener(Symbol("event"), () => { });
+ }
+
+ namespace on {
+ const a: adone.EventEmitter = new adone.EventEmitter().on("event", () => { });
+ const b: adone.EventEmitter = new adone.EventEmitter().on(Symbol("event"), () => { });
+ }
+
+ namespace once {
+ const a: adone.EventEmitter = new adone.EventEmitter().once("event", () => { });
+ const b: adone.EventEmitter = new adone.EventEmitter().once(Symbol("event"), () => { });
+ }
+
+ namespace prependListener {
+ const a: adone.EventEmitter = new adone.EventEmitter().prependListener("event", () => { });
+ const b: adone.EventEmitter = new adone.EventEmitter().prependListener(Symbol("event"), () => { });
+ }
+
+ namespace prependOnceListener {
+ const a: adone.EventEmitter = new adone.EventEmitter().prependOnceListener("event", () => { });
+ const b: adone.EventEmitter = new adone.EventEmitter().prependOnceListener(Symbol("event"), () => { });
+ }
+
+ namespace prependOnceListener {
+ const a: adone.EventEmitter = new adone.EventEmitter().prependOnceListener("event", () => { });
+ const b: adone.EventEmitter = new adone.EventEmitter().prependOnceListener(Symbol("event"), () => { });
+ }
+
+ namespace removeListener {
+ const a: adone.EventEmitter = new adone.EventEmitter().removeListener("event", () => { });
+ const b: adone.EventEmitter = new adone.EventEmitter().removeListener(Symbol("event"), () => { });
+ }
+
+ namespace removeAllListeners {
+ const a: adone.EventEmitter = new adone.EventEmitter().removeAllListeners("event");
+ const b: adone.EventEmitter = new adone.EventEmitter().removeAllListeners(Symbol("event"));
+ }
+
+ namespace setMaxListeners {
+ const a: adone.EventEmitter = new adone.EventEmitter().setMaxListeners(10);
+ }
+
+ namespace getMaxListeners {
+ const a: number = new adone.EventEmitter().getMaxListeners();
+ }
+
+ namespace listeners {
+ const a: Array<(...args: any[]) => any> = new adone.EventEmitter().listeners("event");
+ const b: Array<(...args: any[]) => any> = new adone.EventEmitter().listeners(Symbol("event"));
+ }
+
+ namespace emit {
+ const a: boolean = new adone.EventEmitter().emit("event", 1, 2, 3);
+ const b: boolean = new adone.EventEmitter().emit(Symbol("event"), 1, 2, 3);
+ }
+
+ namespace eventNames {
+ const a: Array = new adone.EventEmitter().eventNames();
+ const b: Array = new adone.EventEmitter().eventNames();
+ }
+
+ namespace listenerCount {
+ const a: number = new adone.EventEmitter().listenerCount("event");
+ const b: number = new adone.EventEmitter().listenerCount(Symbol("event"));
+ }
+ }
+
+ namespace AsyncEmitter {
+ const a: adone.EventEmitter = new adone.AsyncEmitter();
+ new adone.AsyncEmitter(10);
+
+ namespace setConcurrency {
+ const a: adone.AsyncEmitter = new adone.AsyncEmitter().setConcurrency();
+ const b: adone.AsyncEmitter = new adone.AsyncEmitter().setConcurrency(10);
+ }
+
+ namespace emitParallel {
+ const a: Promise = new adone.AsyncEmitter().emitParallel("even");
+ const b: Promise = new adone.AsyncEmitter().emitParallel("even", 1, 2, 3);
+ }
+
+ namespace emitSerial {
+ const a: Promise = new adone.AsyncEmitter().emitSerial("even");
+ const b: Promise = new adone.AsyncEmitter().emitSerial("even", 1, 2, 3);
+ }
+
+ namespace emitReduce {
+ const a: Promise = new adone.AsyncEmitter().emitReduce("even");
+ const b: Promise = new adone.AsyncEmitter().emitReduce("even", 1, 2, 3);
+ }
+
+ namespace emitReduceRight {
+ const a: Promise = new adone.AsyncEmitter().emitReduceRight("even");
+ const b: Promise = new adone.AsyncEmitter().emitReduceRight("even", 1, 2, 3);
+ }
+
+ namespace subscribe {
+ const a: () => void = new adone.AsyncEmitter().subscribe("event", () => { });
+ const b: () => void = new adone.AsyncEmitter().subscribe("event", () => { }, true);
+ }
+ }
+
+ namespace ExBuffer {
+ new adone.ExBuffer();
+ new adone.ExBuffer(10);
+ new adone.ExBuffer(10, true);
+
+ const buffer = new adone.ExBuffer();
+
+ namespace readBitSet {
+ const a: number[] = buffer.readBitSet();
+ const b: number[] = buffer.readBitSet(10);
+ }
+
+ namespace read {
+ const a: adone.ExBuffer = buffer.read(1);
+ const b: adone.ExBuffer = buffer.read(1, 10);
+ }
+
+ namespace readInt8 {
+ const a: number = buffer.readInt8();
+ const b: number = buffer.readInt8(10);
+ }
+
+ namespace readUInt8 {
+ const a: number = buffer.readUInt8();
+ const b: number = buffer.readUInt8(10);
+ }
+
+ namespace readInt16LE {
+ const a: number = buffer.readInt16LE();
+ const b: number = buffer.readInt16LE(10);
+ }
+
+ namespace readUInt16LE {
+ const a: number = buffer.readUInt16LE();
+ const b: number = buffer.readUInt16LE(10);
+ }
+
+ namespace readInt16BE {
+ const a: number = buffer.readInt16BE();
+ const b: number = buffer.readInt16BE(10);
+ }
+
+ namespace readUInt16BE {
+ const a: number = buffer.readUInt16BE();
+ const b: number = buffer.readUInt16BE(10);
+ }
+
+ namespace readInt32LE {
+ const a: number = buffer.readInt32LE();
+ const b: number = buffer.readInt32LE(10);
+ }
+
+ namespace readUInt32LE {
+ const a: number = buffer.readUInt32LE();
+ const b: number = buffer.readUInt32LE(10);
+ }
+
+ namespace readInt32BE {
+ const a: number = buffer.readInt32BE();
+ const b: number = buffer.readInt32BE(10);
+ }
+
+ namespace readUInt32BE {
+ const a: number = buffer.readUInt32BE();
+ const b: number = buffer.readUInt32BE(10);
+ }
+
+ namespace readInt64LE {
+ const a: adone.math.Long = buffer.readInt64LE();
+ const b: adone.math.Long = buffer.readInt64LE(10);
+ }
+
+ namespace readUInt64LE {
+ const a: adone.math.Long = buffer.readUInt64LE();
+ const b: adone.math.Long = buffer.readUInt64LE(10);
+ }
+
+ namespace readInt64BE {
+ const a: adone.math.Long = buffer.readInt64BE();
+ const b: adone.math.Long = buffer.readInt64BE(10);
+ }
+
+ namespace readUInt64BE {
+ const a: adone.math.Long = buffer.readUInt64BE();
+ const b: adone.math.Long = buffer.readUInt64BE(10);
+ }
+
+ namespace readFloatLE {
+ const a: number = buffer.readFloatLE();
+ const b: number = buffer.readFloatLE(10);
+ }
+
+ namespace readFloatBE {
+ const a: number = buffer.readFloatBE();
+ const b: number = buffer.readFloatBE(10);
+ }
+
+ namespace readDoubleLE {
+ const a: number = buffer.readDoubleLE();
+ const b: number = buffer.readDoubleLE(10);
+ }
+
+ namespace readDoubleBE {
+ const a: number = buffer.readDoubleBE();
+ const b: number = buffer.readDoubleBE(10);
+ }
+
+ namespace write {
+ const a: adone.ExBuffer = buffer.write("1");
+ const b: adone.ExBuffer = buffer.write(new adone.ExBuffer());
+ const c: adone.ExBuffer = buffer.write(Buffer.alloc(10));
+ const d: adone.ExBuffer = buffer.write(new Uint8Array([1, 2, 3]));
+ const e: adone.ExBuffer = buffer.write(new ArrayBuffer(10));
+ const f: adone.ExBuffer = buffer.write("1", 10);
+ const g: adone.ExBuffer = buffer.write("1", 10, 10);
+ const h: adone.ExBuffer = buffer.write("1", 10, 10, "utf8");
+ }
+
+ namespace writeBitSet {
+ const a: adone.ExBuffer = buffer.writeBitSet([1, 2, 3]);
+ const b: number = buffer.writeBitSet([1, 2, 3], 10);
+ }
+
+ namespace writeInt8 {
+ const a: adone.ExBuffer = buffer.writeInt8(10);
+ const b: adone.ExBuffer = buffer.writeInt8(10, 10);
+ }
+
+ namespace writeUInt8 {
+ const a: adone.ExBuffer = buffer.writeUInt8(10);
+ const b: adone.ExBuffer = buffer.writeUInt8(10, 10);
+ }
+
+ namespace writeInt16LE {
+ const a: adone.ExBuffer = buffer.writeInt16LE(10);
+ const b: adone.ExBuffer = buffer.writeInt16LE(10, 10);
+ }
+
+ namespace writeInt16BE {
+ const a: adone.ExBuffer = buffer.writeInt16BE(10);
+ const b: adone.ExBuffer = buffer.writeInt16BE(10, 10);
+ }
+
+ namespace writeUInt16LE {
+ const a: adone.ExBuffer = buffer.writeUInt16LE(10);
+ const b: adone.ExBuffer = buffer.writeUInt16LE(10, 10);
+ }
+
+ namespace writeUInt16BE {
+ const a: adone.ExBuffer = buffer.writeUInt16BE(10);
+ const b: adone.ExBuffer = buffer.writeUInt16BE(10, 10);
+ }
+
+ namespace writeInt32LE {
+ const a: adone.ExBuffer = buffer.writeInt32LE(10);
+ const b: adone.ExBuffer = buffer.writeInt32LE(10, 10);
+ }
+
+ namespace writeInt32BE {
+ const a: adone.ExBuffer = buffer.writeInt32BE(10);
+ const b: adone.ExBuffer = buffer.writeInt32BE(10, 10);
+ }
+
+ namespace writeUInt32LE {
+ const a: adone.ExBuffer = buffer.writeUInt32LE(10);
+ const b: adone.ExBuffer = buffer.writeUInt32LE(10, 10);
+ }
+
+ namespace writeUInt32BE {
+ const a: adone.ExBuffer = buffer.writeUInt32BE(10);
+ const b: adone.ExBuffer = buffer.writeUInt32BE(10, 10);
+ }
+
+ namespace writeInt64LE {
+ const a: adone.ExBuffer = buffer.writeInt64LE(10);
+ const b: adone.ExBuffer = buffer.writeInt64LE(10, 10);
+ }
+
+ namespace writeInt64BE {
+ const a: adone.ExBuffer = buffer.writeInt64BE(10);
+ const b: adone.ExBuffer = buffer.writeInt64BE(10, 10);
+ }
+
+ namespace writeUInt64LE {
+ const a: adone.ExBuffer = buffer.writeUInt64LE(10);
+ const b: adone.ExBuffer = buffer.writeUInt64LE(10, 10);
+ }
+
+ namespace writeUInt64BE {
+ const a: adone.ExBuffer = buffer.writeUInt64BE(10);
+ const b: adone.ExBuffer = buffer.writeUInt64BE(10, 10);
+ }
+
+ namespace writeFloatLE {
+ const a: adone.ExBuffer = buffer.writeFloatLE(10);
+ const b: adone.ExBuffer = buffer.writeFloatLE(10, 10);
+ }
+
+ namespace writeFloatBE {
+ const a: adone.ExBuffer = buffer.writeFloatBE(10);
+ const b: adone.ExBuffer = buffer.writeFloatBE(10, 10);
+ }
+
+ namespace writeDoubleLE {
+ const a: adone.ExBuffer = buffer.writeDoubleLE(10);
+ const b: adone.ExBuffer = buffer.writeDoubleLE(10, 10);
+ }
+
+ namespace writeDoubleBE {
+ const a: adone.ExBuffer = buffer.writeDoubleBE(10);
+ const b: adone.ExBuffer = buffer.writeDoubleBE(10, 10);
+ }
+
+ namespace writeVarInt32 {
+ const a: adone.ExBuffer = buffer.writeVarint32(10);
+ const b: number = buffer.writeVarint32(10, 10);
+ }
+
+ namespace writeVarInt32ZigZag {
+ const a: adone.ExBuffer = buffer.writeVarint32ZigZag(10);
+ const b: number = buffer.writeVarint32ZigZag(10, 10);
+ }
+
+ namespace readVarint32 {
+ const a: number = buffer.readVarint32();
+ const b: { value: number, length: number } = buffer.readVarint32(10);
+ }
+
+ namespace readVarint32ZigZag {
+ const a: number = buffer.readVarint32ZigZag();
+ const b: { value: number, length: number } = buffer.readVarint32ZigZag(10);
+ }
+
+ namespace writeVarint64 {
+ const a: adone.ExBuffer = buffer.writeVarint64(10);
+ const b: number = buffer.writeVarint64(10, 10);
+ }
+
+ namespace writeVarint64ZigZag {
+ const a: adone.ExBuffer = buffer.writeVarint64ZigZag(10);
+ const b: number = buffer.writeVarint64ZigZag(10, 10);
+ }
+
+ namespace readVarint64 {
+ const a: adone.math.Long = buffer.readVarint64();
+ const b: { value: adone.math.Long, length: number } = buffer.readVarint64(10);
+ }
+
+ namespace readVarint64ZigZag {
+ const a: adone.math.Long = buffer.readVarint64ZigZag();
+ const b: { value: adone.math.Long, length: number } = buffer.readVarint64ZigZag(10);
+ }
+
+ namespace writeCString {
+ const a: adone.ExBuffer = buffer.writeCString("asd");
+ const b: number = buffer.writeCString("123", 10);
+ }
+
+ namespace readCString {
+ const a: string = buffer.readCString();
+ const b: { string: string, length: number } = buffer.readCString(10);
+ }
+
+ namespace writeString {
+ const a: adone.ExBuffer = buffer.writeString("abc");
+ const b: number = buffer.writeString("abc", 10);
+ }
+
+ namespace readString {
+ const a: string = buffer.readString(10);
+ const b: string = buffer.readString(10, "b");
+ const c: string = buffer.readString(10, "c");
+ const d: { string: string, length: number } = buffer.readString(10, "c", 10);
+ }
+
+ namespace writeVString {
+ const a: adone.ExBuffer = buffer.writeVString("abc");
+ const b: number = buffer.writeVString("abc", 10);
+ }
+
+ namespace readVString {
+ const a: string = buffer.readVString();
+ const b: { string: string, length: number } = buffer.readVString(10);
+ }
+
+ namespace appendTo {
+ const a: adone.ExBuffer = buffer.appendTo(new adone.ExBuffer());
+ const b: adone.ExBuffer = buffer.appendTo(new adone.ExBuffer(), 10);
+ }
+
+ namespace assert {
+ const a: adone.ExBuffer = buffer.assert();
+ const b: adone.ExBuffer = buffer.assert(true);
+ }
+
+ namespace capacity {
+ const a: number = buffer.capacity();
+ }
+
+ namespace clear {
+ const a: adone.ExBuffer = buffer.clear();
+ }
+
+ namespace compact {
+ const a: adone.ExBuffer = buffer.compact();
+ const b: adone.ExBuffer = buffer.compact(1);
+ const c: adone.ExBuffer = buffer.compact(1, 10);
+ }
+
+ namespace copyTo {
+ const a: adone.ExBuffer = buffer.copyTo(new adone.ExBuffer());
+ const b: adone.ExBuffer = buffer.copyTo(new adone.ExBuffer(), 0);
+ const c: adone.ExBuffer = buffer.copyTo(new adone.ExBuffer(), 0, 0);
+ const d: adone.ExBuffer = buffer.copyTo(new adone.ExBuffer(), 0, 0, 10);
+ }
+
+ namespace ensureCapacity {
+ const a: adone.ExBuffer = buffer.ensureCapacity(10);
+ }
+
+ namespace fill {
+ const a: adone.ExBuffer = buffer.fill("0");
+ const b: adone.ExBuffer = buffer.fill(0);
+ const c: adone.ExBuffer = buffer.fill(0, 0);
+ const d: adone.ExBuffer = buffer.fill(0, 0, 10);
+ }
+
+ namespace flip {
+ const a: adone.ExBuffer = buffer.flip();
+ }
+
+ namespace mark {
+ const a: adone.ExBuffer = buffer.mark();
+ const b: adone.ExBuffer = buffer.mark(10);
+ }
+
+ namespace prepend {
+ const a: adone.ExBuffer = buffer.prepend("");
+ const b: adone.ExBuffer = buffer.prepend(new adone.ExBuffer());
+ const c: adone.ExBuffer = buffer.prepend(Buffer.alloc(10));
+ const d: adone.ExBuffer = buffer.prepend(new Uint8Array([1, 2, 3]));
+ const e: adone.ExBuffer = buffer.prepend(new ArrayBuffer(10));
+ const f: adone.ExBuffer = buffer.prepend("", "utf8");
+ const g: adone.ExBuffer = buffer.prepend("", "utf8", 10);
+ const h: adone.ExBuffer = buffer.prepend("", 10);
+ }
+
+ namespace prependTo {
+ const a: adone.ExBuffer = buffer.prependTo(new adone.ExBuffer());
+ const b: adone.ExBuffer = buffer.prependTo(new adone.ExBuffer(), 10);
+ }
+
+ namespace remaining {
+ const a: number = buffer.remaining();
+ }
+
+ namespace reset {
+ const a: adone.ExBuffer = buffer.reset();
+ }
+
+ namespace resize {
+ const a: adone.ExBuffer = buffer.resize(10);
+ }
+
+ namespace reverse {
+ const a: adone.ExBuffer = buffer.reverse();
+ const b: adone.ExBuffer = buffer.reverse(1);
+ const c: adone.ExBuffer = buffer.reverse(1, 10);
+ }
+
+ namespace skip {
+ const a: adone.ExBuffer = buffer.skip(10);
+ }
+
+ namespace slice {
+ const a: adone.ExBuffer = buffer.slice();
+ const b: adone.ExBuffer = buffer.slice(1);
+ const c: adone.ExBuffer = buffer.slice(1, 10);
+ }
+
+ namespace toBuffer {
+ const a: Buffer = buffer.toBuffer();
+ const b: Buffer = buffer.toBuffer(true);
+ const c: Buffer = buffer.toBuffer(true, 0);
+ const d: Buffer = buffer.toBuffer(true, 0, 10);
+ }
+
+ namespace toArrayBuffer {
+ const a: ArrayBuffer = buffer.toArrayBuffer();
+ }
+
+ namespace toString {
+ const a: string = buffer.toString();
+ const b: string = buffer.toString("utf8");
+ const c: string = buffer.toString("utf8", 0);
+ const d: string = buffer.toString("utf8", 0, 10);
+ }
+
+ namespace toBase64 {
+ const a: string = buffer.toBase64();
+ const b: string = buffer.toBase64(0);
+ const c: string = buffer.toBase64(0, 10);
+ }
+
+ namespace toBinary {
+ const a: string = buffer.toBinary();
+ const b: string = buffer.toBinary(0);
+ const c: string = buffer.toBinary(0, 10);
+ }
+
+ namespace toDebug {
+ const a: string = buffer.toDebug();
+ const b: string = buffer.toDebug(true);
+ }
+
+ namespace toUTF8 {
+ const a: string = buffer.toUTF8();
+ const b: string = buffer.toUTF8(0);
+ const c: string = buffer.toUTF8(0, 10);
+ }
+
+ namespace static {
+ namespace accessor {
+ const a: typeof Buffer = adone.ExBuffer.accessor();
+ }
+
+ namespace allocate {
+ const a: adone.ExBuffer = adone.ExBuffer.allocate();
+ const b: adone.ExBuffer = adone.ExBuffer.allocate(10);
+ const c: adone.ExBuffer = adone.ExBuffer.allocate(10, true);
+ }
+
+ namespace concat {
+ const a: adone.ExBuffer = adone.ExBuffer.concat([
+ new adone.ExBuffer(),
+ Buffer.alloc(10),
+ new Uint8Array([1, 2, 3]),
+ new ArrayBuffer(10)
+ ]);
+ const b: adone.ExBuffer = adone.ExBuffer.concat([
+ new adone.ExBuffer(),
+ Buffer.alloc(10),
+ new Uint8Array([1, 2, 3]),
+ new ArrayBuffer(10)
+ ], "utf8");
+ const c: adone.ExBuffer = adone.ExBuffer.concat([
+ new adone.ExBuffer(),
+ Buffer.alloc(10),
+ new Uint8Array([1, 2, 3]),
+ new ArrayBuffer(10)
+ ], "utf8", true);
+ }
+
+ namespace type {
+ const a: typeof Buffer = adone.ExBuffer.type();
+ }
+
+ namespace wrap {
+ const a: adone.ExBuffer = adone.ExBuffer.wrap("");
+ const b: adone.ExBuffer = adone.ExBuffer.wrap(new adone.ExBuffer());
+ const c: adone.ExBuffer = adone.ExBuffer.wrap(Buffer.alloc(10));
+ const d: adone.ExBuffer = adone.ExBuffer.wrap(new Uint8Array([1, 2, 3]));
+ const e: adone.ExBuffer = adone.ExBuffer.wrap(new ArrayBuffer(10));
+ const f: adone.ExBuffer = adone.ExBuffer.wrap("", "utf8");
+ const g: adone.ExBuffer = adone.ExBuffer.wrap("", "utf8", true);
+ }
+
+ namespace calculateVarint32 {
+ const a: number = adone.ExBuffer.calculateVarint32(10);
+ }
+
+ namespace zigZagEncode32 {
+ const a: number = adone.ExBuffer.zigZagEncode32(10);
+ }
+
+ namespace zigZagDecode32 {
+ const a: number = adone.ExBuffer.zigZagDecode32(10);
+ }
+
+ namespace calculateVarint64 {
+ const a: number = adone.ExBuffer.calculateVarint64(10);
+ const b: number = adone.ExBuffer.calculateVarint64("10");
+ }
+
+ namespace zigZagEncode64 {
+ const a: adone.math.Long = adone.ExBuffer.zigZagEncode64(10);
+ const b: adone.math.Long = adone.ExBuffer.zigZagEncode64("10");
+ const c: adone.math.Long = adone.ExBuffer.zigZagEncode64(adone.math.Long.fromValue(10));
+ }
+
+ namespace zigZagDecode64 {
+ const a: adone.math.Long = adone.ExBuffer.zigZagDecode64(10);
+ const b: adone.math.Long = adone.ExBuffer.zigZagDecode64("10");
+ const c: adone.math.Long = adone.ExBuffer.zigZagDecode64(adone.math.Long.fromValue(10));
+ }
+
+ namespace calculateUTF8Chars {
+ const a: number = adone.ExBuffer.calculateUTF8Chars("123");
+ }
+
+ namespace calculateString {
+ const a: number = adone.ExBuffer.calculateString("123");
+ }
+
+ namespace fromBase64 {
+ const a: adone.ExBuffer = adone.ExBuffer.fromBase64("123");
+ }
+
+ namespace btoa {
+ const a: string = adone.ExBuffer.btoa("123");
+ }
+
+ namespace atob {
+ const a: string = adone.ExBuffer.atob("123");
+ }
+
+ namespace fromBinary {
+ const a: adone.ExBuffer = adone.ExBuffer.fromBinary("123");
+ }
+
+ namespace fromDebug {
+ const a: adone.ExBuffer = adone.ExBuffer.fromDebug("12");
+ const b: adone.ExBuffer = adone.ExBuffer.fromDebug("12", true);
+ }
+
+ namespace fromHex {
+ const a: adone.ExBuffer = adone.ExBuffer.fromHex("192");
+ const b: adone.ExBuffer = adone.ExBuffer.fromHex("192", true);
+ }
+
+ namespace fromUTF8 {
+ const a: adone.ExBuffer = adone.ExBuffer.fromUTF8("123");
+ const b: adone.ExBuffer = adone.ExBuffer.fromUTF8("123", true);
+ }
+
+ namespace constants {
+ const a: number = adone.ExBuffer.DEFAULT_CAPACITY;
+ const b: boolean = adone.ExBuffer.DEFAULT_NOASSERT;
+ const c: number = adone.ExBuffer.MAX_VARINT32_BYTES;
+ const d: number = adone.ExBuffer.MAX_VARINT64_BYTES;
+ const e: string = adone.ExBuffer.METRICS_CHARS;
+ const f: string = adone.ExBuffer.METRICS_BYTES;
+ }
+ }
+ }
+}
diff --git a/types/adone/test/glosses/math.ts b/types/adone/test/glosses/math.ts
new file mode 100644
index 0000000000..8a9e9bc1cf
--- /dev/null
+++ b/types/adone/test/glosses/math.ts
@@ -0,0 +1,259 @@
+const { math } = adone;
+
+namespace mathTests {
+ namespace Long {
+ new math.Long();
+ new math.Long(0);
+ new math.Long(0, 0);
+ new math.Long(0, 0, true);
+
+ namespace toInt {
+ const a: number = new math.Long().toInt();
+ }
+
+ namespace toNumber {
+ const a: number = new math.Long().toNumber();
+ }
+
+ namespace toString {
+ const a: string = new math.Long().toString();
+ const b: string = new math.Long().toString(16);
+ }
+
+ namespace getHighBits {
+ const a: number = new math.Long().getHighBits();
+ }
+
+ namespace getLowBits {
+ const a: number = new math.Long().getLowBits();
+ }
+
+ namespace getLowBitsUnsigned {
+ const a: number = new math.Long().getLowBitsUnsigned();
+ }
+
+ namespace getHighBitsUnsigned {
+ const a: number = new math.Long().getHighBitsUnsigned();
+ }
+
+ namespace getNumBitsAbs {
+ const a: number = new math.Long().getNumBitsAbs();
+ }
+
+ namespace isZero {
+ const a: boolean = new math.Long().isZero();
+ }
+
+ namespace isNegative {
+ const a: boolean = new math.Long().isNegative();
+ }
+
+ namespace isPositive {
+ const a: boolean = new math.Long().isPositive();
+ }
+
+ namespace isOdd {
+ const a: boolean = new math.Long().isOdd();
+ }
+
+ namespace isEven {
+ const a: boolean = new math.Long().isEven();
+ }
+
+ namespace equals {
+ const a = new math.Long();
+ const b: boolean = a.equals(new math.Long());
+ const c: boolean = a.equals(1);
+ const d: boolean = a.equals("1");
+ const e: boolean = a.equals({ low: 0, high: 0 });
+ }
+
+ namespace lessThan {
+ const a = new math.Long();
+ const b: boolean = a.lessThan(new math.Long());
+ const c: boolean = a.lessThan(1);
+ const d: boolean = a.lessThan("1");
+ const e: boolean = a.lessThan({ low: 0, high: 0 });
+ }
+
+ namespace lessThanOrEqual {
+ const a = new math.Long();
+ const b: boolean = a.lessThanOrEqual(new math.Long());
+ const c: boolean = a.lessThanOrEqual(1);
+ const d: boolean = a.lessThanOrEqual("1");
+ const e: boolean = a.lessThanOrEqual({ low: 0, high: 0 });
+ }
+
+ namespace greaterThan {
+ const a = new math.Long();
+ const b: boolean = a.greaterThan(new math.Long());
+ const c: boolean = a.greaterThan(1);
+ const d: boolean = a.greaterThan("1");
+ const e: boolean = a.greaterThan({ low: 0, high: 0 });
+ }
+
+ namespace greaterThanOrEqual {
+ const a = new math.Long();
+ const b: boolean = a.greaterThanOrEqual(new math.Long());
+ const c: boolean = a.greaterThanOrEqual(1);
+ const d: boolean = a.greaterThanOrEqual("1");
+ const e: boolean = a.greaterThanOrEqual({ low: 0, high: 0 });
+ }
+
+ namespace greaterThanOrEqual {
+ const a = new math.Long();
+ const b: number = a.compare(new math.Long());
+ const c: number = a.compare(1);
+ const d: number = a.compare("1");
+ const e: number = a.compare({ low: 0, high: 0 });
+ }
+
+ namespace negate {
+ const a: adone.math.Long = new math.Long().negate();
+ }
+
+ namespace add {
+ const a = new math.Long();
+ const b: adone.math.Long = a.add(new math.Long());
+ const c: adone.math.Long = a.add(1);
+ const d: adone.math.Long = a.add("1");
+ const e: adone.math.Long = a.add({ low: 0, high: 0 });
+ }
+
+ namespace sub {
+ const a = new math.Long();
+ const b: adone.math.Long = a.sub(new math.Long());
+ const c: adone.math.Long = a.sub(1);
+ const d: adone.math.Long = a.sub("1");
+ const e: adone.math.Long = a.sub({ low: 0, high: 0 });
+ }
+
+ namespace mul {
+ const a = new math.Long();
+ const b: adone.math.Long = a.mul(new math.Long());
+ const c: adone.math.Long = a.mul(1);
+ const d: adone.math.Long = a.mul("1");
+ const e: adone.math.Long = a.mul({ low: 0, high: 0 });
+ }
+
+ namespace div {
+ const a = new math.Long();
+ const b: adone.math.Long = a.div(new math.Long());
+ const c: adone.math.Long = a.div(1);
+ const d: adone.math.Long = a.div("1");
+ const e: adone.math.Long = a.div({ low: 0, high: 0 });
+ }
+
+ namespace mod {
+ const a = new math.Long();
+ const b: adone.math.Long = a.mod(new math.Long());
+ const c: adone.math.Long = a.mod(1);
+ const d: adone.math.Long = a.mod("1");
+ const e: adone.math.Long = a.mod({ low: 0, high: 0 });
+ }
+
+ namespace not {
+ const a: adone.math.Long = new math.Long().not();
+ }
+
+ namespace and {
+ const a = new math.Long();
+ const b: adone.math.Long = a.and(new math.Long());
+ const c: adone.math.Long = a.and(1);
+ const d: adone.math.Long = a.and("1");
+ const e: adone.math.Long = a.and({ low: 0, high: 0 });
+ }
+
+ namespace or {
+ const a = new math.Long();
+ const b: adone.math.Long = a.or(new math.Long());
+ const c: adone.math.Long = a.or(1);
+ const d: adone.math.Long = a.or("1");
+ const e: adone.math.Long = a.or({ low: 0, high: 0 });
+ }
+
+ namespace xor {
+ const a = new math.Long();
+ const b: adone.math.Long = a.xor(new math.Long());
+ const c: adone.math.Long = a.xor(1);
+ const d: adone.math.Long = a.xor("1");
+ const e: adone.math.Long = a.xor({ low: 0, high: 0 });
+ }
+
+ namespace shl {
+ const a = new math.Long();
+ const b: adone.math.Long = a.shl(new math.Long());
+ const c: adone.math.Long = a.shl(1);
+ }
+
+ namespace shr {
+ const a = new math.Long();
+ const b: adone.math.Long = a.shr(new math.Long());
+ const c: adone.math.Long = a.shr(1);
+ }
+
+ namespace shru {
+ const a = new math.Long();
+ const b: adone.math.Long = a.shr(new math.Long());
+ const c: adone.math.Long = a.shr(1);
+ }
+
+ namespace toSigned {
+ const a: adone.math.Long = new math.Long().toSigned();
+ }
+
+ namespace toUnsigned {
+ const a: adone.math.Long = new math.Long().toUnsigned();
+ }
+
+ namespace toBytes {
+ const a: number[] = new math.Long().toBytes();
+ }
+
+ namespace toBytesLE {
+ const a: number[] = new math.Long().toBytesLE();
+ }
+
+ namespace static {
+ namespace fromInt {
+ const a: adone.math.Long = math.Long.fromInt(123);
+ const b: adone.math.Long = math.Long.fromInt(123, true);
+ }
+
+ namespace fromNumber {
+ const a: adone.math.Long = math.Long.fromNumber(123);
+ const b: adone.math.Long = math.Long.fromNumber(123, true);
+ }
+
+ namespace fromBits {
+ const a: adone.math.Long = math.Long.fromBits(0, 0);
+ const b: adone.math.Long = math.Long.fromBits(123, 0, true);
+ }
+
+ namespace fromString {
+ const a: adone.math.Long = math.Long.fromString("123");
+ const b: adone.math.Long = math.Long.fromString("123", true);
+ const c: adone.math.Long = math.Long.fromString("123", 16);
+ const d: adone.math.Long = math.Long.fromString("123", true, 16);
+ }
+
+ namespace fromValue {
+ const a: adone.math.Long = math.Long.fromValue(new math.Long());
+ const b: adone.math.Long = math.Long.fromValue(1);
+ const c: adone.math.Long = math.Long.fromValue("1");
+ const e: adone.math.Long = math.Long.fromValue({ low: 0, high: 0 });
+ }
+
+ namespace constants {
+ const a: adone.math.Long = math.Long.MIN_VALUE;
+ const b: adone.math.Long = math.Long.MAX_VALUE;
+ const c: adone.math.Long = math.Long.MAX_UNSIGNED_VALUE;
+ const d: adone.math.Long = math.Long.ZERO;
+ const e: adone.math.Long = math.Long.UZERO;
+ const f: adone.math.Long = math.Long.ONE;
+ const g: adone.math.Long = math.Long.UONE;
+ const h: adone.math.Long = math.Long.NEG_ONE;
+ }
+ }
+ }
+}
diff --git a/types/adone/test/glosses/promise.ts b/types/adone/test/glosses/promise.ts
new file mode 100644
index 0000000000..c16d1a4852
--- /dev/null
+++ b/types/adone/test/glosses/promise.ts
@@ -0,0 +1,97 @@
+namespace promiseTests {
+ const { promise } = adone;
+
+ namespace defer {
+ const a = promise.defer();
+ a.promise.then((x) => 2);
+ a.resolve(2);
+ a.reject(3);
+ const b = promise.defer();
+ b.resolve("3");
+ b.reject(2);
+ b.promise.then((x: string) => x);
+ }
+
+ namespace delay {
+ const a: Promise = promise.delay(10);
+ const b: Promise = promise.delay(10, 2);
+ promise.delay(20, "3").then((x: string) => x);
+ }
+
+ namespace timeout {
+ promise.timeout(Promise.resolve(2), 100).then((x: number) => x);
+ }
+
+ namespace nodeify {
+ promise.nodeify(Promise.resolve(2), (err: any, value: number) => value).then((x: number) => x);
+ promise.nodeify(Promise.resolve(2), () => 42).then((x: number) => x);
+ }
+
+ namespace promisify {
+ type Callback = (err?: any, result?: T) => void;
+ namespace noargs {
+ const f = (cb: Callback) => {
+ cb(null, 32);
+ };
+ promise.promisify(f)().then((x: number) => { });
+ }
+ namespace nargs1 {
+ const f = (a: number, cb: Callback) => {
+ cb(null, 32);
+ };
+ promise.promisify(f)(1).then((x: number) => { });
+ }
+
+ namespace nargs2 {
+ const f = (a: number, b: string, cb: Callback) => {
+ cb(null, 32);
+ };
+ promise.promisify(f)(1, "1").then((x: number) => { });
+ }
+
+ namespace nargs3 {
+ const f = (a: number, b: string, c: number, cb: Callback) => {
+ cb(null, 32);
+ };
+ promise.promisify(f)(1, "1", 1).then((x: number) => { });
+ }
+
+ namespace nargs4 {
+ const f = (a: number, b: string, c: number, d: string, cb: Callback) => {
+ cb(null, 32);
+ };
+ promise.promisify(f)(1, "1", 1, "1").then((x: number) => { });
+ }
+
+ namespace nargs5 {
+ const f = (a: number, b: string, c: number, d: string, e: number, cb: Callback) => {
+ cb(null, 32);
+ };
+ promise.promisify(f)(1, "1", 1, "1", 1).then((x: number) => { });
+ }
+
+ namespace moreargs {
+ const f = (a: number, b: string, c: number, d: string, e: number, f: string, cb: Callback) => {
+ cb(null, 32);
+ };
+ promise.promisify(f)(1, 2, 3).then((x) => x);
+ }
+
+ namespace options {
+ promise.promisify((cb: Callback) => cb(null, 42), {});
+ promise.promisify((cb: Callback) => cb(null, 42), { context: {} });
+ }
+ }
+
+ namespace promisifyAll {
+ const a: object = promise.promisifyAll({});
+ promise.promisifyAll({}, {});
+ promise.promisifyAll({}, { context: {} });
+ promise.promisifyAll({}, { filter: () => true });
+ promise.promisifyAll({}, { suffix: "Async" });
+ }
+
+ namespace _finally {
+ promise.finally(Promise.resolve(2), () => 2).then((x: number) => {});
+ }
+}
diff --git a/types/adone/test/glosses/shani-global.ts b/types/adone/test/glosses/shani-global.ts
new file mode 100644
index 0000000000..b59dce4b6a
--- /dev/null
+++ b/types/adone/test/glosses/shani-global.ts
@@ -0,0 +1,163 @@
+namespace shaniGlobalTests {
+ namespace describeTests {
+ describe("hello", () => {});
+
+ describe("hello", function () {
+ this.skip();
+ this.timeout(10);
+ this.a;
+ });
+
+ describe("1", "2", "3", "4", "45", function () {
+ this.skip();
+ this.timeout(10);
+ this.a;
+ });
+
+ describe("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", function () {
+ this.skip();
+ this.timeout(10);
+ this.a;
+ });
+
+ context("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", function () {
+ this.skip();
+ this.timeout(10);
+ this.a;
+ });
+ }
+
+ namespace itTests {
+ it("should be here", () => {});
+
+ it("should be here", function () {
+ this.timeout(100);
+ this.skip();
+ this.a;
+ });
+
+ it("should be here", function (done: () => void) {
+ this.timeout(1000);
+ done();
+ this.a;
+ });
+
+ it("hello", {}, () => {});
+
+ it("hello", {
+ skip: true
+ }, () => {});
+
+ it("hello", {
+ skip: () => true
+ }, () => {});
+
+ it("hello", {
+ timeout: () => 1202
+ }, () => {});
+
+ it("hello", {
+ timeout: 1010
+ }, () => {});
+
+ it("hello", {
+ before() {}
+ }, () => {});
+
+ it("hello", {
+ before: ["hello", () => {}]
+ }, () => {});
+
+ it("hello", {
+ after() {}
+ }, () => {});
+
+ it("hello", {
+ after: ["hello", () => {}]
+ }, () => {});
+
+ specify("hello", {
+ after: ["hello", () => {}]
+ }, () => {});
+ }
+
+ namespace beforeTests {
+ before(function() {
+ this.timeout(100);
+ this.a;
+ });
+
+ before("description", function () {
+ this.timeout(100);
+ this.a;
+ });
+
+ before("description", function (done) {
+ this.timeout(100);
+ done();
+ this.a;
+ });
+ }
+
+ namespace afterTests {
+ after(function () {
+ this.timeout(10);
+ this.a;
+ });
+
+ after("description", function () {
+ this.timeout(10);
+ this.a;
+ });
+
+ after("description", function (done) {
+ this.timeout(10);
+ this.a;
+ });
+ }
+
+ namespace beforeEachTests {
+ beforeEach(function () {
+ this.timeout(100);
+ this.a;
+ });
+
+ beforeEach("hello", function () {
+ this.timeout(100);
+ this.a;
+ });
+
+ beforeEach("hello", function (done) {
+ this.timeout(100);
+ done();
+ this.a;
+ });
+ }
+
+ namespace afterEachTests {
+ afterEach(function () {
+ this.timeout(100);
+ this.a;
+ });
+
+ afterEach("asd", function () {
+ this.timeout(100);
+ this.a;
+ });
+
+ afterEach("asd", function (done) {
+ this.timeout(100);
+ done();
+ this.a;
+ });
+ }
+
+ expect(1).to.be.a("number");
+ assert.equal(1, 1);
+ fakeClock.install().tick(100);
+ stub()(1, 2, 3);
+ expect(spy()).to.have.been.calledOnce;
+ match(2).and(match(2));
+ mock().alwaysCalledOn({});
+ request({}).expectBody("");
+}
diff --git a/types/adone/test/glosses/shani.ts b/types/adone/test/glosses/shani.ts
new file mode 100644
index 0000000000..1c09ef3837
--- /dev/null
+++ b/types/adone/test/glosses/shani.ts
@@ -0,0 +1,544 @@
+namespace shaniTests {
+ const { shani } = adone;
+
+ namespace engineOptionsTests {
+ new shani.Engine();
+ new shani.Engine({});
+ new shani.Engine({ callGc: true });
+ new shani.Engine({ defaultTimeout: 1000 });
+ new shani.Engine({ defaultHookTimeout: 1000 });
+ new shani.Engine({ transpilerOptions: {} });
+ }
+
+ namespace contextTests {
+ const e = new adone.shani.Engine();
+ const c = e.context();
+
+ namespace describeTests {
+ c.describe("hello", () => {});
+
+ c.describe("hello", function () {
+ this.skip();
+ this.timeout(10);
+ this.a;
+ });
+
+ c.describe("1", "2", "3", "4", "45", function () {
+ this.skip();
+ this.timeout(10);
+ this.a;
+ });
+
+ c.describe("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", function () {
+ this.skip();
+ this.timeout(10);
+ this.a;
+ });
+
+ c.context("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", function () {
+ this.skip();
+ this.timeout(10);
+ this.a;
+ });
+ }
+
+ namespace itTests {
+ c.it("should be here", () => {});
+
+ c.it("should be here", function () {
+ this.timeout(100);
+ this.skip();
+ this.a;
+ });
+
+ c.it("should be here", function (done) {
+ this.timeout(100);
+ this.skip();
+ done();
+ this.a;
+ });
+
+ c.it("hello", {}, () => { });
+
+ c.it("hello", {
+ skip: true
+ }, () => { });
+
+ c.it("hello", {
+ skip: () => true
+ }, () => { });
+
+ c.it("hello", {
+ timeout: () => 1202
+ }, () => { });
+
+ c.it("hello", {
+ timeout: 1010
+ }, () => { });
+
+ c.it("hello", {
+ before() { }
+ }, () => { });
+
+ c.it("hello", {
+ before: ["hello", () => { }]
+ }, () => { });
+
+ c.it("hello", {
+ after() { }
+ }, () => { });
+
+ c.it("hello", {
+ after: ["hello", () => { }]
+ }, () => { });
+
+ c.specify("hello", {
+ after: ["hello", () => { }]
+ }, () => { });
+ }
+
+ namespace beforeTests {
+ c.before(function () {
+ this.timeout(100);
+ this.a;
+ });
+
+ c.before("description", function () {
+ this.timeout(100);
+ this.a;
+ });
+
+ c.before("description", function (done) {
+ this.timeout(100);
+ done();
+ this.a;
+ });
+ }
+
+ namespace afterTests {
+ c.after(function () {
+ this.timeout(10);
+ this.a;
+ });
+
+ c.after("description", function () {
+ this.timeout(10);
+ this.a;
+ });
+
+ c.after("description", function (done) {
+ this.timeout(10);
+ done();
+ this.a;
+ });
+ }
+
+ namespace beforeEachTests {
+ c.beforeEach(function () {
+ this.timeout(100);
+ this.a;
+ });
+
+ c.beforeEach("hello", function () {
+ this.timeout(100);
+ this.a;
+ });
+
+ c.beforeEach("hello", function (done) {
+ this.timeout(100);
+ done();
+ this.a;
+ });
+ }
+
+ namespace afterEachTests {
+ c.afterEach(function () {
+ this.timeout(100);
+ this.a;
+ });
+
+ c.afterEach("asd", function () {
+ this.timeout(100);
+ this.a;
+ });
+
+ c.afterEach("asd", function (done) {
+ this.timeout(100);
+ done();
+ this.a;
+ });
+ }
+
+ namespace rootTests {
+ const { root } = c;
+ root.children[0];
+ root.prepare().then((x) => { });
+ root.addChild(root);
+ const check = (hook: adone.shani.I.Hook) => {
+ hook.run().then((x) => x);
+ hook.cause();
+ hook.failed() === true;
+ hook.timeout() + 2;
+ hook.timeout(10).timeout(10).timeout() + 2;
+ };
+ for (const hook of root.beforeHooks()) {
+ check(hook);
+ }
+ for (const hook of root.afterHooks()) {
+ check(hook);
+ }
+ for (const hook of root.beforeEachHooks()) {
+ check(hook);
+ }
+ for (const hook of root.afterEachHooks()) {
+ check(hook);
+ }
+ root.isInclusive() === true;
+ root.isExclusive() === false;
+ root.hasInclusive() === true;
+ root.skip().only().skip();
+ const a: number | null = root.timeout();
+ root.timeout(100).timeout(100);
+ root.level() + 2;
+ root.level(2).level() + 2;
+ root.chain().toLowerCase();
+ root.blockChain()[0].blockChain()[0].addChild(root);
+ }
+
+ namespace eventEmitterTests {
+ const a = c.start();
+ a.on("enter block", ({ block }) => {
+ block.addChild(block);
+ }).on("exit block", ({ block }) => {
+ block.addChild(block);
+ }).on("start test", ({ block, test }) => {
+ block.addChild(test);
+ test.chain();
+ }).on("end test", ({ block, test, meta }) => {
+ block.addChild(test);
+ test.chain();
+ meta.err;
+ meta.elapsed + 2;
+ }).on("start before hook", ({ block, hook }) => {
+ block.addChild(block);
+ hook.desctiption;
+ }).on("end before hook", ({ block, hook, meta }) => {
+ block.addChild(block);
+ hook.desctiption;
+ meta.err;
+ meta.elapsed;
+ }).on("start after hook", ({ block, hook }) => {
+ block.addChild(block);
+ hook.desctiption;
+ }).on("end after hook", ({ block, hook, meta }) => {
+ block.addChild(block);
+ hook.desctiption;
+ meta.err;
+ meta.elapsed;
+ }).on("start before each hook", ({ block, hook }) => {
+ block.addChild(block);
+ hook.desctiption;
+ }).on("end before each hook", ({ block, hook, meta }) => {
+ block.addChild(block);
+ hook.desctiption;
+ meta.err;
+ meta.elapsed;
+ }).on("start after each hook", ({ block, hook }) => {
+ block.addChild(block);
+ hook.desctiption;
+ }).on("end after each hook", ({ block, hook, meta }) => {
+ block.addChild(block);
+ hook.desctiption;
+ meta.err;
+ meta.elapsed;
+ }).on("start before test hook", ({ block, hook }) => {
+ block.addChild(block);
+ hook.desctiption;
+ }).on("end before test hook", ({ block, hook, meta }) => {
+ block.addChild(block);
+ hook.desctiption;
+ meta.err;
+ meta.elapsed;
+ }).on("start after test hook", ({ block, hook }) => {
+ block.addChild(block);
+ hook.desctiption;
+ }).on("end after test hook", ({ block, hook, meta }) => {
+ block.addChild(block);
+ hook.desctiption;
+ meta.err;
+ meta.elapsed;
+ }).on("error", (err) => {}).on("done", () => {}).stop();
+ }
+ }
+
+ namespace utilTests {
+ const { util } = shani;
+
+ namespace spyCallTests {
+ const call = util.spy().firstCall;
+ call.calledBefore(call) === true;
+ call.calledAfter(call) === true;
+ call.calledWithNew(call) === true;
+ call.thisValue;
+ call.args[0];
+ call.exception;
+ call.returnValue;
+ call.calledOn({}) === true;
+ call.calledWith(1, 2, 3) === true;
+ call.calledWithExactly(1, 2, 3) === true;
+ call.calledWithMatch(1, 2, 3) === true;
+ call.notCalledWith(1, 2, 3) === true;
+ call.notCalledWithMatch(1, 2, 3) === true;
+ call.returned(1) === true;
+ call.threw() === true;
+ call.threw("12") === true;
+ call.threw({}) === true;
+ call.callArg(1);
+ call.callArgOn(1, {});
+ call.callArgWith(1, 1, 2, 3);
+ call.callArgOnWith(1, {}, 1, 2, 3);
+ call.yield(1, 2, 3);
+ call.yieldOn({}, 1, 2, 3);
+ call.yieldToOn("a", {}, 1, 2, 3);
+ }
+
+ namespace spyTests {
+ util.spy().alwaysCalledOn({});
+ util.spy(() => { }).alwaysCalledOn({});
+ const a: number = util.spy().callCount;
+ const s = util.spy();
+ s.called === true;
+ s.notCalled === true;
+ s.calledOnce === true;
+ s.calledTwice === true;
+ s.calledThrice === true;
+ s.firstCall.args;
+ s.secondCall.args;
+ s.thirdCall.args;
+ s.lastCall.args;
+ s.thisValues[0];
+ s.args[0][0];
+ s.exceptions[0];
+ s.returnValues[0];
+ s(1, 2, 3);
+ s.calledBefore(s);
+ s.calledAfter(s);
+ s.calledImmediatelyAfter(s);
+ s.calledImmediatelyBefore(s);
+ s.calledWithNew() === true;
+ s.withArgs(1, 2, 3).firstCall.args;
+ s.alwaysCalledOn({}) === true;
+ s.alwaysCalledWith(1, 2, 3) === true;
+ s.alwaysCalledWithExactly(1, 2, 3) === true;
+ s.alwaysCalledWithMatch(1, 2, 3) === true;
+ s.neverCalledWith(1, 2, 3) === true;
+ s.neverCalledWithMatch(1, 2, 3) === true;
+ s.alwaysThrew() === true;
+ s.alwaysThrew("a") === true;
+ s.alwaysThrew({}) === true;
+ s.alwaysReturned({}) === true;
+ s.invokeCallback(1, 2, 3);
+ s.getCall(0).args;
+ s.getCalls()[0].args;
+ s.reset();
+ s.printf("%s", "1").toLowerCase();
+ s.restore();
+ }
+
+ namespace stubTests {
+ util.stub({});
+ class A {
+ a() {}
+ }
+ util.stub(new A(), "a").resetHistory();
+ const s = util.stub();
+ s.resetBehavior();
+ s.resetHistory();
+ s.usingPromise({}).alwaysCalledOn(2);
+ s.returns({}).resetBehavior();
+ s.returnsArg(1).resetBehavior();
+ s.returnsThis().resetBehavior();
+ s.resolves().resetBehavior();
+ s.resolves(1).resetBehavior();
+ s.throws().resetBehavior();
+ s.throws("1").resetBehavior();
+ s.throwsArg(1).resetBehavior();
+ s.throwsException().resetBehavior();
+ s.throwsException("1").resetBehavior();
+ s.throwsException({}).resetBehavior();
+ s.rejects().resetBehavior();
+ s.rejects("string").resetBehavior();
+ s.rejects(1).resetBehavior();
+ s.callsArg(1).resetBehavior();
+ s.callThrough().resetBehavior();
+ s.callsArgOn(1, {}).resetBehavior();
+ s.callsArgOnWith(1, {}, 123).resetBehavior();
+ s.callsArgAsync(1).resetBehavior();
+ s.callsArgOnAsync(1, {}).resetBehavior();
+ s.callsArgOnWithAsync(1, {}, 1, 2, 3).resetBehavior();
+ s.callsFake(() => { }).resetBehavior();
+ s.get(() => { }).resetBehavior();
+ s.set((v) => 1).resetBehavior();
+ s.onCall(1).resetBehavior();
+ s.onFirstCall().resetBehavior();
+ s.onSecondCall().resetBehavior();
+ s.onThirdCall().resetBehavior();
+ s.value(1).resetBehavior();
+ s.yields(1, 2, 3).resetBehavior();
+ s.yieldsOn({}, 1, 2).resetBehavior();
+ s.yieldsRight(1, 2, 3).resetBehavior();
+ s.yieldsTo("a", 1, 2, 3).resetBehavior();
+ s.yieldsToOn("a", {}, 1, 2, 3).resetBehavior();
+ s.yieldsAsync(1, 2, 3).resetBehavior();
+ s.yieldsOnAsync({}, 1, 2, 3).resetBehavior();
+ s.yieldsToAsync("a", 1, 2, 3).resetBehavior();
+ s.yieldsToOnAsync("1", {}, 1, 2, 3).resetBehavior();
+ s.withArgs(1, 2, 3).resetBehavior();
+ }
+
+ namespace expectationTests {
+ util.expectation.create("");
+ const e = util.expectation.create();
+ e.atLeast(1).never();
+ e.atMost(2).never();
+ e.never().never();
+ e.once().never();
+ e.twice().never();
+ e.thrice().never();
+ e.exactly(1).never();
+ e.withArgs(1, 2, 3).never();
+ e.withExactArgs(1, 2, 3).never();
+ e.on({}).never();
+ e.verify().never();
+ e.restore();
+ }
+
+ namespace mockTests {
+ util.mock().never();
+ util.mock({}).expects("").restore();
+ util.mock({}).verify();
+ }
+
+ namespace assertTests {
+ util.assert.failException;
+ util.assert.fail();
+ util.assert.fail("1");
+ util.assert.pass(1);
+ const s = util.spy();
+ util.assert.notCalled(s);
+ util.assert.called(s);
+ util.assert.calledOnce(s);
+ util.assert.calledTwice(s);
+ util.assert.calledThrice(s);
+ util.assert.callCount(s, 10);
+ util.assert.callOrder(s, s, s, s);
+ util.assert.calledOn(s, {});
+ util.assert.calledOn(s, {});
+ util.assert.alwaysCalledOn(s, {});
+ util.assert.calledWith(s, {});
+ util.assert.neverCalledWith(s, {});
+ util.assert.calledWithExactly(s, {});
+ util.assert.alwaysCalledWithExactly(s, {});
+ util.assert.calledWithMatch(s, {});
+ util.assert.alwaysCalledWithMatch(s, {});
+ util.assert.neverCalledWithMatch(s, {});
+ util.assert.threw(s);
+ util.assert.threw(s, "a");
+ util.assert.threw(s, {});
+ util.assert.alwaysThrew(s);
+ util.assert.alwaysThrew(s, "");
+ util.assert.alwaysThrew(s, {});
+ util.assert.expose({});
+ util.assert.expose({}, { includeFail: true });
+ util.assert.expose({}, { prefix: "a" });
+ }
+
+ namespace matchTests {
+ util.match(1).and(util.match(1));
+ util.match("1").and(util.match(1));
+ util.match(/1/).and(util.match(1));
+ util.match({}).and(util.match(1));
+ util.match((v: any) => true).and(util.match(1));
+ util.match((v: any) => true, "a").and(util.match(1));
+ util.match.any.and;
+ util.match.defined.and;
+ util.match.truthy.and;
+ util.match.falsy.and;
+ util.match.bool.and;
+ util.match.number.and;
+ util.match.string.and;
+ util.match.object.and;
+ util.match.func.and;
+ util.match.map.contains(new Map());
+ util.match.map.deepEquals(new Map());
+ util.match.set.contains(new Set());
+ util.match.array.contains([]);
+ util.match.array.deepEquals([]);
+ util.match.array.endsWith([]);
+ util.match.array.startsWith([]);
+ util.match.regexp.and;
+ util.match.date.and;
+ util.match.symbol.and;
+ util.match.same({}).and;
+ util.match.typeOf("string").and;
+ util.match.instanceOf({}).and;
+ util.match.has("a").and;
+ util.match.has("a", {}).and;
+ util.match.hasOwn("a").and;
+ util.match.hasOwn("a", {}).and;
+ }
+
+ namespace sandboxTests {
+ util.sandbox.create();
+ util.sandbox.create({});
+ util.sandbox.create({ injectInto: {} });
+ util.sandbox.create({ properties: ["a"] });
+ const s = util.sandbox.create();
+ s.assert.alwaysCalledOn(s.spy(), {});
+ s.spy().args;
+ s.stub().args;
+ s.mock().args;
+ s.restore();
+ s.reset();
+ s.resetHistory();
+ s.resetBehavior();
+ s.usingPromise({}).reset();
+ s.verify();
+ s.verifyAndRestore();
+ }
+ }
+
+ namespace requestTests {
+ const r = request({});
+ r.get("/").head("/").post("/").put("/").options("/");
+ r.attach("fname", "hello");
+ r.attach("fname", "hello", {});
+ r.attach("fname", "hello", { type: "application/javascript" });
+ r.attach("fname", "hello", { filename: "a.js" });
+ r.field("a", "basd");
+ r.send("asd");
+ r.setHeader("Cookie", "key=value");
+ r.auth("user", "pass");
+ r.expect(() => true);
+ r.expect(async () => true);
+ r.expect((response) => {
+ assert.equal(response.statusCode, 200);
+ return response.body.length === 0;
+ });
+ r.expectStatus(200);
+ r.expectStatusMessage("OK");
+ r.expectBody("body");
+ r.expectBody(Buffer.from("body"));
+ r.expectBody(/body/);
+ r.expectBody({ a: 1 });
+ r.expectBody("body", {});
+ r.expectBody("body", { decompress: true });
+ r.expectEmptyBody();
+ r.expectHeader("Cookie", "key=value");
+ r.expectHeaderExists("Cookie");
+ r.then((x: adone.shani.util.I.Response) => {
+ x.statusCode === 200;
+ x.body.fill(0);
+ });
+ }
+}
diff --git a/types/adone/test/glosses/std.ts b/types/adone/test/glosses/std.ts
new file mode 100644
index 0000000000..611f9401e9
--- /dev/null
+++ b/types/adone/test/glosses/std.ts
@@ -0,0 +1,161 @@
+import adone from "adone";
+
+import * as assert from "assert";
+import * as fs from "fs";
+import * as path from "path";
+import * as util from "util";
+import * as events from "events";
+import * as stream from "stream";
+import * as url from "url";
+import * as net from "net";
+import * as http from "http";
+import * as https from "https";
+import * as child_process from "child_process";
+import * as os from "os";
+import * as cluster from "cluster";
+import * as repl from "repl";
+import * as punycode from "punycode";
+import * as readline from "readline";
+import * as string_decoder from "string_decoder";
+import * as querystring from "querystring";
+import * as crypto from "crypto";
+import * as vm from "vm";
+import * as v8 from "v8";
+import * as domain from "domain";
+import * as tty from "tty";
+import * as buffer from "buffer";
+import * as constants from "constants";
+import * as zlib from "zlib";
+import * as tls from "tls";
+import * as console from "console";
+import * as dns from "dns";
+import * as timers from "timers";
+import * as dgram from "dgram";
+
+const { std } = adone;
+
+namespace stdTests {
+ namespace assert {
+ std.assert(true);
+ }
+
+ namespace fs {
+ std.fs.readFileSync("test").length;
+ }
+
+ namespace path {
+ std.path.join("a", "b").charAt(0);
+ }
+
+ namespace util {
+ std.util.format("hello").charAt(0);
+ }
+
+ namespace events {
+ new std.events.EventEmitter().on("event", () => {});
+ }
+
+ namespace steam {
+ new std.stream.PassThrough().resume();
+ }
+
+ namespace url {
+ std.url.parse("https://adone.io").hostname;
+ }
+
+ namespace net {
+ std.net.connect(31337).write("hello");
+ }
+
+ namespace http {
+ std.http.get("http://localhost").end();
+ }
+
+ namespace https {
+ std.https.get("https://adone.io").end();
+ }
+
+ namespace child_process {
+ std.child_process.fork(__filename, [], { stdio: ["ipc"] }).send("hello");
+ }
+
+ namespace os {
+ std.os.tmpdir().charAt(0);
+ }
+
+ namespace cluster {
+ std.cluster.fork().kill();
+ }
+
+ namespace repl {
+ std.repl.start().close();
+ }
+
+ namespace punycode {
+ std.punycode.decode("ads").charAt(0);
+ }
+
+ namespace readline {
+ std.readline.clearLine(process.stdout, 1);
+ }
+
+ namespace string_decoder {
+ new std.string_decoder.StringDecoder().end().charAt(0);
+ }
+
+ namespace querystring {
+ std.querystring.escape("hello").charAt(0);
+ }
+
+ namespace crypto {
+ std.crypto.createHash("sha1").update("hello").digest("hex");
+ }
+
+ namespace vm {
+ std.vm.runInContext("a + 2", std.vm.createContext({ a: 1 }));
+ }
+
+ namespace v8 {
+ std.v8.getHeapStatistics().heap_size_limit + 2;
+ }
+
+ namespace domain {
+ std.domain.create().members;
+ }
+
+ namespace tty {
+ std.tty.isatty(1) === true;
+ }
+
+ namespace buffer {
+ std.buffer.Buffer.alloc(10);
+ }
+
+ namespace constants {
+ std.constants.EACCES + 2;
+ }
+
+ namespace zlib {
+ std.zlib.createDeflate().write("ttt");
+ }
+
+ namespace tls {
+ std.tls.connect({}).end();
+ }
+
+ namespace console {
+ std.console.trace("message");
+ }
+
+ namespace dns {
+ std.dns.resolve4("adone.io", (err, data) => {});
+ }
+
+ namespace timers {
+ std.timers.setTimeout(() => {}, 2000).unref();
+ }
+
+ namespace dgram {
+ std.dgram.createSocket("udp4").bind(31337);
+ }
+}
diff --git a/types/adone/test/glosses/utils.ts b/types/adone/test/glosses/utils.ts
new file mode 100644
index 0000000000..9372fb4b30
--- /dev/null
+++ b/types/adone/test/glosses/utils.ts
@@ -0,0 +1,737 @@
+const { util } = adone;
+
+namespace utilTests {
+ namespace arrify {
+ const a: number[] = util.arrify([1, 2, 3]);
+ const b: number[] = util.arrify(1);
+ const c: string[] = util.arrify("2");
+ const d: string[] = util.arrify(["1"]);
+ }
+
+ namespace slice {
+ const a: number[] = util.slice([1, 2, 3]);
+ const b: number[] = util.slice([1, 2, 3], 1);
+ const c: number[] = util.slice([1, 2, 3], 1, 4);
+ const d: string[] = util.slice(["1"]);
+ }
+
+ namespace spliceOne {
+ util.spliceOne([1, 2, 3], 0);
+ }
+
+ namespace normalizePath {
+ const a: string = util.normalizePath("path");
+ const b: string = util.normalizePath("path", true);
+ }
+
+ namespace unixifyPath {
+ const a: string = util.unixifyPath("path");
+ const b: string = util.unixifyPath("path", true);
+ }
+
+ namespace functionName {
+ const a: string = util.functionName(function f() { });
+ const b: string = util.functionName((a, b, c) => { });
+ }
+
+ namespace mapArguments {
+ const a: (...args: any[]) => any = util.mapArguments(() => { });
+ const b: (...args: T[]) => T[] = util.mapArguments(1);
+ const c: (...args: any[]) => any = util.mapArguments([1]);
+ const d: (x: T) => T = util.mapArguments();
+ }
+
+ namespace parseMs {
+ const result: {
+ days: number;
+ hours: number;
+ milliseconds: number;
+ minutes: number;
+ } = util.parseMs(123);
+ }
+
+ namespace pluralizeWord {
+ const a: string = util.pluralizeWord("day");
+ const b: string = util.pluralizeWord("day", "days");
+ const c: string = util.pluralizeWord("day", "days", 1);
+ }
+
+ namespace functionParams {
+ const a: string[] = util.functionParams((a: any, b: any, c: any) => { });
+ }
+
+ namespace randomChoice {
+ const a: number = util.randomChoice([1, 2, 3]);
+ const b: string = util.randomChoice(["1", "2", "3"]);
+ }
+
+ namespace shuffleArray {
+ const a: number[] = util.shuffleArray([1, 2, 3]);
+ const b: string[] = util.shuffleArray(["1", "2", "3"]);
+ }
+
+ namespace enumerate {
+ {
+ const a = util.enumerate([1, 2, 3]);
+ const it = a[Symbol.iterator]();
+ const value: [number, number] = it.next().value;
+ for (const i of a) {
+ const [idx, value]: [number, number] = i;
+ }
+ }
+ {
+ const a = util.enumerate(["1", "2"]);
+ const it = a[Symbol.iterator]();
+ const value: [number, string] = it.next().value;
+ for (const i of a) {
+ const [idx, value]: [number, string] = i;
+ }
+ }
+ }
+
+ namespace zip {
+ {
+ const a = util.zip([1, 2, 3], ["4", "5", "6"]);
+ const it = a[Symbol.iterator]();
+ const value: [number, string] = it.next().value;
+ for (const i of a) {
+ const [i1, i2]: [number, string] = i;
+ }
+ }
+ {
+ const a = util.zip(
+ [1, 2, 3],
+ ["4", "5", "6"],
+ [7, 8, 9]
+ );
+ const it = a[Symbol.iterator]();
+ const value: [number, string, number] = it.next().value;
+ for (const i of a) {
+ const [i1, i2, i3]: [number, string, number] = i;
+ }
+ }
+ {
+ const a = util.zip(
+ [1, 2, 3],
+ ["4", "5", "6"],
+ [7, 8, 9],
+ ["10", "11", "12"]
+ );
+ const it = a[Symbol.iterator]();
+ const value: [number, string, number, string] = it.next().value;
+ for (const i of a) {
+ const [i1, i2, i3, i4]: [number, string, number, string] = i;
+ }
+ }
+ {
+ const a = util.zip(
+ [1, 2, 3],
+ ["4", "5", "6"],
+ [7, 8, 9],
+ ["10", "11", "12"],
+ [13, 14, 15, 16]
+ );
+ const it = a[Symbol.iterator]();
+ const value: any[] = it.next().value;
+ for (const i of a) {
+ const [i1, i2, i3, i4]: any[] = i;
+ }
+ }
+ }
+
+ namespace keys {
+ const a: string[] = util.keys({});
+ const b: string[] = util.keys({}, { all: true });
+ const c: string[] = util.keys({}, { followProto: true });
+ const d: string[] = util.keys({}, { onlyEnumerable: true });
+ }
+
+ namespace values {
+ const a: any[] = util.values({});
+ const b: any[] = util.values({}, { all: true });
+ const c: any[] = util.values({}, { followProto: true });
+ const d: any[] = util.values({}, { onlyEnumerable: true });
+ }
+
+ namespace entries {
+ const a: Array<[string, any]> = util.entries({});
+ const b: Array<[string, any]> = util.entries({}, { all: true });
+ const c: Array<[string, any]> = util.entries({}, { followProto: true });
+ const d: Array<[string, any]> = util.entries({}, { onlyEnumerable: true });
+ }
+
+ namespace toDotNotation {
+ const a: object = util.toDotNotation({ a: 1 });
+ }
+
+ namespace flatten {
+ const a: number[] = util.flatten([1, [2, 3]]);
+ const b: number[] = util.flatten([1, [2, 3]], {});
+ const c: number[] = util.flatten([1, [2, 3]], { depth: 1 });
+ }
+
+ namespace globParent {
+ const a: string = util.globParent("a/b/c/**");
+ }
+
+ namespace by {
+ const a: (a: number, b: number) => any = util.by((x: number): number => x);
+ const b: (a: number, b: number) => number = util.by((x: number): string => `${x}`, (a: string, b: string) => a.length - b.length);
+ }
+
+ namespace toFastProperties {
+ const a: object = util.toFastProperties({});
+ }
+
+ namespace stripBom {
+ const a: string = util.stripBom("123");
+ }
+
+ namespace sortKeys {
+ const a: object = util.sortKeys({});
+ const b: object = util.sortKeys({}, {});
+ const c: object = util.sortKeys({}, { deep: true });
+ const d: object = util.sortKeys({}, { compare: (a, b) => 2 });
+ }
+
+ namespace globize {
+ const a: string = util.globize("test");
+ const b: string = util.globize("test", {});
+ const c: string = util.globize("test", { exts: "" });
+ const d: string = util.globize("test", { recursively: true });
+ }
+
+ namespace unique {
+ const a: number[] = util.unique([1, 2, 3]);
+ const b: string[] = util.unique(["1", "2", "3"]);
+ const c: object[] = util.unique([{ a: 1 }, { a: 2 }], (obj: any) => obj.a);
+ }
+
+ namespace invertObject {
+ const a: object = util.invertObject({});
+ const b: object = util.invertObject({}, {});
+ const c: object = util.invertObject({}, { all: true });
+ const d: object = util.invertObject({}, { followProto: true });
+ const e: object = util.invertObject({}, { onlyEnumerable: true });
+ }
+
+ namespace humanizeTime {
+ const a: string = util.humanizeTime(12345);
+ const b: string = util.humanizeTime(12345, {});
+ const c: string = util.humanizeTime(12345, { compact: true });
+ const d: string = util.humanizeTime(12345, { msDecimalDigits: 2 });
+ const e: string = util.humanizeTime(12345, { secDecimalDigits: 2 });
+ const f: string = util.humanizeTime(12345, { verbose: true });
+ }
+
+ namespace humanizeSize {
+ const a: string = util.humanizeSize(12345);
+ const b: string = util.humanizeSize(12345, "");
+ }
+
+ namespace parseSize {
+ const a: number | null = util.parseSize(123);
+ const b: number | null = util.parseSize("123Kb");
+ }
+
+ namespace clone {
+ const a: object = util.clone({});
+ const b: object = util.clone({}, {});
+ const c: object = util.clone({}, { deep: true });
+ }
+
+ namespace toUTF8Array {
+ const a: number[] = util.toUTF8Array("hello");
+ }
+
+ namespace asyncIter {
+ util.asyncIter([1, 2, 3], () => { }, () => { });
+ }
+
+ namespace asyncFor {
+ util.asyncFor({}, () => { }, () => { });
+ }
+
+ namespace once {
+ {
+ const f = () => 2;
+ const a: () => number = util.once(f);
+ }
+ {
+ const f = (a: number) => `${a}`;
+ const a: (a: number) => string = util.once(f);
+ }
+ }
+
+ namespace asyncWaterfall {
+ util.asyncWaterfall([
+ (callback: (a: any, b: any, c: any) => void) => {
+ callback(null, 'one', 'two');
+ }
+ ], (err: any, result: any) => {
+ //
+ });
+ }
+
+ namespace xrange {
+ for (const i of util.xrange(10)) {
+ const a: number = i;
+ }
+ for (const i of util.xrange(1, 10)) {
+ const a: number = i;
+ }
+ for (const i of util.xrange(1, 10, 2)) {
+ const a: number = i;
+ }
+ }
+ namespace range {
+ const a: number[] = util.range(10);
+ const b: number[] = util.range(1, 10);
+ const c: number[] = util.range(1, 10, 2);
+ }
+
+ namespace reFindAll {
+ const a: RegExpExecArray[] = util.reFindAll(/\d+/, "1 2 3 4 5");
+ }
+
+ namespace assignDeep {
+ const a: object = util.assignDeep({ a: 1 }, { a: 2 });
+ }
+
+ namespace match {
+ const a: number | boolean = util.match(["a", "b", "c"], "a");
+ const b: (a: any, b: any) => number | boolean = util.match("a", { index: true });
+ const c: number | boolean = util.match(["a", "b", "c"], "a", { dot: true });
+ const d: (a: any, b: any) => number | boolean = util.match("a", { end: 2 });
+ const e: (a: any, b: any) => number | boolean = util.match("a", { start: 2 });
+ const f: (a: any, b: any) => number | boolean = util.match("a");
+ }
+
+ namespace toposort {
+ const a: number[] = util.toposort([
+ [0, 1],
+ [2, 3],
+ [4, 5],
+ [6, 7]
+ ]);
+ const b: number[] = util.toposort.array([0, 1, 2], [
+ [0, 1],
+ [2, 3],
+ [4, 5],
+ [6, 7]
+ ]);
+ }
+
+ namespace jsesc {
+ const a: string = util.jsesc({ a: 1 });
+ const b: string = util.jsesc({ a: 1 }, { escapeEverything: true });
+ const c: string = util.jsesc({ a: 1 }, { minimal: true });
+ const d: string = util.jsesc({ a: 1 }, { isScriptContext: true });
+ const e: string = util.jsesc({ a: 1 }, { quotes: "'" });
+ const f: string = util.jsesc({ a: 1 }, { wrap: true });
+ const g: string = util.jsesc({ a: 1 }, { es6: true });
+ const h: string = util.jsesc({ a: 1 }, { json: true });
+ const i: string = util.jsesc({ a: 1 }, { compact: true });
+ const j: string = util.jsesc({ a: 1 }, { lowercaseHex: true });
+ const k: string = util.jsesc({ a: 1 }, { numbers: "decimal" });
+ const l: string = util.jsesc({ a: 1 }, { indent: " " });
+ const m: string = util.jsesc({ a: 1 }, { indentLevel: 4 });
+ const n: string = util.jsesc({ a: 1 }, { __inline1__: true });
+ const o: string = util.jsesc({ a: 1 }, { __inline2__: true });
+ }
+
+ namespace typeOf {
+ const a: string = util.typeOf(1);
+ }
+
+ namespace memcpy {
+ const a: number = util.memcpy.utou(Buffer.alloc(10), 0, Buffer.alloc(10), 0, 10);
+ const b: number = util.memcpy.atoa(new ArrayBuffer(10), 0, new ArrayBuffer(10), 0, 10);
+ const c: number = util.memcpy.atou(Buffer.alloc(10), 0, new ArrayBuffer(10), 0, 10);
+ const d: number = util.memcpy.utoa(new ArrayBuffer(10), 0, Buffer.alloc(10), 0, 10);
+ const e: number = util.memcpy.copy(Buffer.alloc(10), 0, Buffer.alloc(10), 0, 10);
+ const f: number = util.memcpy.copy(new ArrayBuffer(10), 0, new ArrayBuffer(10), 0, 10);
+ const g: number = util.memcpy.copy(Buffer.alloc(10), 0, new ArrayBuffer(10), 0, 10);
+ const h: number = util.memcpy.copy(new ArrayBuffer(10), 0, Buffer.alloc(10), 0, 10);
+ }
+
+ namespace uuid {
+ namespace v1 {
+ const a: string = util.uuid.v1();
+ const b: number[] = util.uuid.v1({}, []);
+ const c: number[] = util.uuid.v1({}, [], 1);
+ const d: string = util.uuid.v1({});
+ const e: string = util.uuid.v1({ clockseq: 1 });
+ const f: string = util.uuid.v1({ msecs: 1 });
+ const g: string = util.uuid.v1({ nsecs: 1 });
+ }
+
+ namespace v4 {
+ const a: string = util.uuid.v4();
+ const b: number[] = util.uuid.v4({}, []);
+ const c: number[] = util.uuid.v4({}, [], 1);
+ const d: string = util.uuid.v4({});
+ const e: string = util.uuid.v4({ clockseq: 1 });
+ const f: string = util.uuid.v4({ msecs: 1 });
+ const g: string = util.uuid.v4({ nsecs: 1 });
+ }
+
+ namespace v5 {
+ const a: string = util.uuid.v5([], []);
+ const b: number[] = util.uuid.v5([], [], []);
+ const c: number[] = util.uuid.v5([], [], [], 1);
+ }
+ }
+
+ namespace delegate {
+ const a = util.delegate({}, "a");
+ a.getter("a").access("b").method("c").setter("d");
+ }
+
+ namespace GlobExp {
+ {
+ const glob = new util.GlobExp("*.js");
+ const a: boolean = glob.hasMagic();
+ const b: string[] = glob.expandBraces();
+ const c: RegExp = glob.makeRe();
+ const d: boolean = glob.test("a.js");
+ }
+ {
+ const a: boolean = util.GlobExp.hasMagic("*.js");
+ const b: string[] = util.GlobExp.expandBraces("*.js");
+ const c: RegExp = util.GlobExp.makeRe("*.js");
+ const d: boolean = util.GlobExp.test("*.js", "a.js");
+ }
+ new util.GlobExp("");
+ new util.GlobExp("", {});
+ new util.GlobExp("", { dot: true });
+ new util.GlobExp("", { flipNegate: true });
+ new util.GlobExp("", { matchBase: true });
+ new util.GlobExp("", { nobrace: true });
+ new util.GlobExp("", { nocase: true });
+ new util.GlobExp("", { nocomment: true });
+ new util.GlobExp("", { noext: true });
+ new util.GlobExp("", { noglobstar: true });
+ new util.GlobExp("", { nonegate: true });
+ util.GlobExp.hasMagic("", {});
+ util.GlobExp.hasMagic("", { dot: true });
+ util.GlobExp.hasMagic("", { flipNegate: true });
+ util.GlobExp.hasMagic("", { matchBase: true });
+ util.GlobExp.hasMagic("", { nobrace: true });
+ util.GlobExp.hasMagic("", { nocase: true });
+ util.GlobExp.hasMagic("", { nocomment: true });
+ util.GlobExp.hasMagic("", { noext: true });
+ util.GlobExp.hasMagic("", { noglobstar: true });
+ util.GlobExp.hasMagic("", { nonegate: true });
+ util.GlobExp.expandBraces("", {});
+ util.GlobExp.expandBraces("", { dot: true });
+ util.GlobExp.expandBraces("", { flipNegate: true });
+ util.GlobExp.expandBraces("", { matchBase: true });
+ util.GlobExp.expandBraces("", { nobrace: true });
+ util.GlobExp.expandBraces("", { nocase: true });
+ util.GlobExp.expandBraces("", { nocomment: true });
+ util.GlobExp.expandBraces("", { noext: true });
+ util.GlobExp.expandBraces("", { noglobstar: true });
+ util.GlobExp.expandBraces("", { nonegate: true });
+ util.GlobExp.makeRe("", {});
+ util.GlobExp.makeRe("", { dot: true });
+ util.GlobExp.makeRe("", { flipNegate: true });
+ util.GlobExp.makeRe("", { matchBase: true });
+ util.GlobExp.makeRe("", { nobrace: true });
+ util.GlobExp.makeRe("", { nocase: true });
+ util.GlobExp.makeRe("", { nocomment: true });
+ util.GlobExp.makeRe("", { noext: true });
+ util.GlobExp.makeRe("", { noglobstar: true });
+ util.GlobExp.makeRe("", { nonegate: true });
+ util.GlobExp.test("a", "b", {});
+ util.GlobExp.test("a", "b", { dot: true });
+ util.GlobExp.test("a", "b", { flipNegate: true });
+ util.GlobExp.test("a", "b", { matchBase: true });
+ util.GlobExp.test("a", "b", { nobrace: true });
+ util.GlobExp.test("a", "b", { nocase: true });
+ util.GlobExp.test("a", "b", { nocomment: true });
+ util.GlobExp.test("a", "b", { noext: true });
+ util.GlobExp.test("a", "b", { noglobstar: true });
+ util.GlobExp.test("a", "b", { nonegate: true });
+ }
+
+ namespace iconv {
+ // TODO
+ }
+
+ namespace sqlstring {
+ namespace escapeId {
+ const a: string = util.sqlstring.escapeId("asd");
+ const b: string = util.sqlstring.escapeId(["asd"]);
+ const c: string = util.sqlstring.escapeId(["asd"], true);
+ }
+
+ namespace dateToString {
+ const a: string = util.sqlstring.dateToString(Date.now());
+ const b: string = util.sqlstring.dateToString(123, "local");
+ }
+
+ namespace arrayToList {
+ const a: string = util.sqlstring.arrayToList(["1", "a"]);
+ }
+
+ namespace bufferToString {
+ const a: string = util.sqlstring.bufferToString(Buffer.alloc(10));
+ }
+
+ namespace objectToValues {
+ const a: string = util.sqlstring.objectToValues({ a: 1 });
+ const b: string = util.sqlstring.objectToValues({ a: 1 }, "local");
+ }
+
+ namespace escape {
+ const a: string = util.sqlstring.escape(1);
+ const b: string = util.sqlstring.escape(1, true);
+ const c: string = util.sqlstring.escape(1, true, "local");
+ }
+
+ namespace format {
+ const a: string = util.sqlstring.format("??");
+ const b: string = util.sqlstring.format("??", "a");
+ const c: string = util.sqlstring.format("??", ["a"]);
+ const d: string = util.sqlstring.format("??", ["a"], true);
+ }
+ }
+
+ namespace Editor {
+ namespace options {
+ new util.Editor();
+ new util.Editor({});
+ new util.Editor({ text: "" });
+ new util.Editor({ editor: "" });
+ new util.Editor({ path: "" });
+ new util.Editor({ ext: "" });
+ }
+
+ const a: string = util.Editor.DEFAULT;
+ new util.Editor().spawn().then((x: adone.std.child_process.ChildProcess) => { });
+ new util.Editor().run().then((x: string) => { });
+ new util.Editor().cleanup().then((x: undefined) => { });
+ util.Editor.edit().then((x: string) => { });
+ }
+
+ namespace binarySearch {
+ const a: number = util.binarySearch.GREATEST_LOWER_BOUND;
+ const b: number = util.binarySearch.GREATEST_LOWER_BOUND;
+ const c: number = util.binarySearch([1, 2, 3], 2);
+ const d: number = util.binarySearch([1, 2, 3], 2, 0);
+ const e: number = util.binarySearch([1, 2, 3], 2, 0, 10);
+ const f: number = util.binarySearch([1, 2, 3], 2, 0, 10, (a, b) => a - b);
+ const g: number = util.binarySearch([1, 2, 3], 2, 0, 10, (a, b) => a - b, util.binarySearch.GREATEST_LOWER_BOUND);
+ }
+
+ namespace buffer {
+ const a: Buffer = util.buffer.concat([Buffer.alloc(10), Buffer.alloc(20)], 30);
+ util.buffer.mask(Buffer.alloc(10), Buffer.alloc(10), Buffer.alloc(10), 0, 10);
+ util.buffer.unmask(Buffer.alloc(10), Buffer.alloc(10));
+ }
+
+ namespace shebang {
+ const a: string | null = util.shebang("#!/bin/sh");
+ }
+
+ namespace ReInterval {
+ new util.ReInterval(() => { }, 1000);
+ new util.ReInterval(() => { }, 1000, [1]);
+ const a = new util.ReInterval(() => { }, 1000);
+ a.reschedule(400);
+ a.clear();
+ a.destroy();
+ }
+
+ namespace RateLimiter {
+ new util.RateLimiter();
+ new util.RateLimiter(1);
+ new util.RateLimiter(1, 1000);
+ new util.RateLimiter(1, 1000, true);
+ const a = new util.RateLimiter();
+ a.removeTokens(1).then((x: number) => { });
+ const b: boolean = a.tryRemoveTokens(10);
+ const c: number = a.getTokensRemaining();
+ }
+
+ namespace throttle {
+ const a: () => Promise = util.throttle(() => 42);
+ const b: (a: number) => Promise = util.throttle((a: number) => `${a}`);
+ const c: (a: number, b: string) => Promise = util.throttle((a: number, b: string) => String(a) + b);
+ const d = util.throttle(() => { }, {});
+ const e = util.throttle(() => { }, { interval: 1000 });
+ const f = util.throttle(() => { }, { max: 10 });
+ const g = util.throttle(() => { }, { ordered: true });
+ const h = util.throttle(() => { }, { waitForReturn: true });
+ }
+
+ namespace fakeClock {
+ namespace timers {
+ const a: typeof global.setTimeout = util.fakeClock.timers.setTimeout;
+ const b: typeof global.clearTimeout = util.fakeClock.timers.clearTimeout;
+ const c: typeof global.setInterval = util.fakeClock.timers.setInterval;
+ const d: typeof global.clearInterval = util.fakeClock.timers.clearInterval;
+ const e: typeof global.setImmediate = util.fakeClock.timers.setImmediate;
+ const f: typeof global.clearImmediate = util.fakeClock.timers.clearImmediate;
+ const g: typeof global.Date = util.fakeClock.timers.Date;
+ const h: typeof global.process.hrtime = util.fakeClock.timers.hrtime;
+ const i: typeof global.process.nextTick = util.fakeClock.timers.nextTick;
+ }
+
+ namespace install {
+ util.fakeClock.install();
+ util.fakeClock.install(100);
+ util.fakeClock.install(new Date());
+ util.fakeClock.install({});
+ util.fakeClock.install({ advanceTimeDelta: 20 });
+ util.fakeClock.install({ loopLimit: 20 });
+ util.fakeClock.install({ now: 20 });
+ util.fakeClock.install({ shouldAdvanceTime: false });
+ util.fakeClock.install({ target: {} });
+ const clock = util.fakeClock.install({ toFake: ["setTimeout", "clearTimeout"] });
+ {
+ const timer = clock.setTimeout(() => {}, 100, 1, 2, 3);
+ const id: number = timer.id;
+ timer.ref();
+ timer.unref();
+ clock.clearTimeout(timer);
+ }
+ {
+ const timer = clock.setInterval(() => {}, 1, 2, 3);
+ const id: number = timer.id;
+ timer.ref();
+ timer.unref();
+ clock.clearInterval(timer);
+ }
+ {
+ const timer = clock.setImmediate(() => {}, 1, 2, 3);
+ const id: number = timer.id;
+ timer.ref();
+ timer.unref();
+ clock.clearImmediate(timer);
+ }
+ clock.nextTick(() => {}, 1, 2, 3);
+ clock.updateHrTime(10);
+ const a: number = clock.tick(100);
+ const b: number = clock.next();
+ const c: number = clock.runAll();
+ const d: number = clock.runToLast();
+ clock.setSystemTime(100);
+ const e: [number, number] = clock.hrtime();
+ const f: [number, number] = clock.hrtime(e);
+ clock.uninstall();
+ }
+
+ namespace createClock {
+ util.fakeClock.createClock();
+ util.fakeClock.createClock(0);
+ const clock = util.fakeClock.createClock(0, 100);
+ {
+ const timer = clock.setTimeout(() => {}, 100, 1, 2, 3);
+ const id: number = timer.id;
+ timer.ref();
+ timer.unref();
+ clock.clearTimeout(timer);
+ }
+ {
+ const timer = clock.setInterval(() => {}, 1, 2, 3);
+ const id: number = timer.id;
+ timer.ref();
+ timer.unref();
+ clock.clearInterval(timer);
+ }
+ {
+ const timer = clock.setImmediate(() => {}, 1, 2, 3);
+ const id: number = timer.id;
+ timer.ref();
+ timer.unref();
+ clock.clearImmediate(timer);
+ }
+ clock.nextTick(() => {}, 1, 2, 3);
+ clock.updateHrTime(10);
+ const a: number = clock.tick(100);
+ const b: number = clock.next();
+ const c: number = clock.runAll();
+ const d: number = clock.runToLast();
+ clock.setSystemTime(100);
+ const e: [number, number] = clock.hrtime();
+ const f: [number, number] = clock.hrtime(e);
+ }
+
+ namespace ltgt {
+ namespace contains {
+ const a: boolean = util.ltgt.contains({ lt: 2 }, 2);
+ const b: boolean = util.ltgt.contains({ lt: 2 }, 2, (a, b) => b - a);
+ const c: boolean = util.ltgt.contains({ lt: "2" }, "2");
+ const d: boolean = util.ltgt.contains({ lt: "2" }, "2", (a, b) => b.charCodeAt(0) - a.charCodeAt(0));
+ }
+
+ namespace filter {
+ const a: (a: number) => boolean = util.ltgt.filter({ lt: 2 });
+ const b: (a: number) => boolean = util.ltgt.filter({ lt: 2 }, (a, b) => b - a);
+ const c: (a: string) => boolean = util.ltgt.filter({ lt: "2" });
+ const d: (a: string) => boolean = util.ltgt.filter({ lt: "2" }, (a, b) => b.charCodeAt(0) - a.charCodeAt(0));
+ }
+
+ namespace toLtgt {
+ const a: adone.util.ltgt.I.Range = util.ltgt.toLtgt({ lt: 2 }, {});
+ const b: adone.util.ltgt.I.Range = util.ltgt.toLtgt({ lt: 2 }, {}, (a) => `${a}`);
+ const c: adone.util.ltgt.I.Range = util.ltgt.toLtgt({ lt: 2 }, {}, (a) => a, 2);
+ const d: adone.util.ltgt.I.Range = util.ltgt.toLtgt({ lt: 2 }, {}, (a) => a, 2, 5);
+ }
+
+ namespace endEnclusive {
+ const a: boolean = util.ltgt.endInclusive({ lt: 2 });
+ }
+
+ namespace startInclusive {
+ const a: boolean = util.ltgt.startInclusive({ lt: 2 });
+ }
+
+ namespace end {
+ const a: number | undefined = util.ltgt.end({ lt: 2 });
+ const b: number | string = util.ltgt.end({ lt: 2 }, "2");
+ const c: number = util.ltgt.end({ lt: 2 }, 2);
+ }
+
+ namespace start {
+ const a: number | undefined = util.ltgt.start({ lt: 2 });
+ const b: number | string = util.ltgt.start({ lt: 2 }, "2");
+ const c: number = util.ltgt.start({ lt: 2 }, 2);
+ }
+
+ namespace upperBound {
+ const a: number | undefined = util.ltgt.upperBound({ lt: 2 });
+ const b: number | string = util.ltgt.upperBound({ lt: 2 }, "2");
+ const c: number = util.ltgt.upperBound({ lt: 2 }, 2);
+ }
+
+ namespace upperBoundKey {
+ const a: number | undefined = util.ltgt.upperBoundKey({ lt: 2 });
+ }
+
+ namespace upperBoundExclusive {
+ const a: boolean = util.ltgt.upperBoundInclusive({ lt: 2 });
+ }
+
+ namespace lowerBoundExclusive {
+ const a: boolean = util.ltgt.lowerBoundInclusive({ lt: 2 });
+ }
+
+ namespace upperBoundInclusive {
+ const a: boolean = util.ltgt.upperBoundInclusive({ lt: 2 });
+ }
+
+ namespace lowerBoundInclusive {
+ const a: boolean = util.ltgt.lowerBoundInclusive({ lt: 2 });
+ }
+
+ namespace lowerBound {
+ const a: number | undefined = util.ltgt.lowerBound({ lt: 2 });
+ const b: number | string = util.ltgt.lowerBound({ lt: 2 }, "2");
+ const c: number = util.ltgt.lowerBound({ lt: 2 }, 2);
+ }
+ }
+ }
+}
diff --git a/types/adone/test/index-import.ts b/types/adone/test/index-import.ts
new file mode 100644
index 0000000000..906e57938c
--- /dev/null
+++ b/types/adone/test/index-import.ts
@@ -0,0 +1,6 @@
+import adone from "adone";
+
+namespace AdoneRootImportTests {
+ adone.falsely() === false;
+ adone.std.fs.createReadStream(__filename).close();
+}
diff --git a/types/adone/test/index.ts b/types/adone/test/index.ts
new file mode 100644
index 0000000000..a6cd5093f3
--- /dev/null
+++ b/types/adone/test/index.ts
@@ -0,0 +1,71 @@
+namespace AdoneRootTests {
+ { const a: symbol = adone.null; }
+ adone.noop();
+ { const a: number = adone.identity(2); }
+ { const a: string = adone.identity("2"); }
+ { const a: number[] = adone.identity([1, 2]); }
+ { adone.truly() === true; }
+ { adone.falsely() === false; }
+ { const a: string = adone.ok; }
+ { const a: string = adone.bad; }
+ { const a: string[] = adone.exts; }
+ adone.log();
+ adone.fatal();
+ adone.error();
+ adone.warn();
+ adone.info();
+ adone.debug();
+ adone.trace();
+ { const a: object = adone.o(); }
+ { const a: object = adone.o({}); }
+ { const a: typeof Date = adone.Date; }
+ { const a: typeof process.hrtime = adone.hrtime; }
+ { const a: typeof setTimeout = adone.setTimeout; }
+ { const a: typeof clearTimeout = adone.clearTimeout; }
+ { const a: typeof setInterval = adone.setInterval; }
+ { const a: typeof clearInterval = adone.clearInterval; }
+ { const a: typeof setImmediate = adone.setImmediate; }
+ { const a: typeof clearImmediate = adone.clearImmediate; }
+ adone.lazify({});
+ adone.lazify({}, {});
+ adone.lazify({}, {}, () => { });
+ adone.lazify({}, {}, () => { }, { configurable: true });
+ adone.tag.set({}, "123");
+ adone.tag.has({}, "123") === true;
+ adone.tag.define("12");
+ adone.tag.define("123", "456");
+ { const a: symbol = adone.tag.SUBSYSTEM; }
+ { const a: symbol = adone.tag.APPLICATION; }
+ { const a: symbol = adone.tag.TRANSFORM; }
+ { const a: symbol = adone.tag.CORE_STREAM; }
+ { const a: symbol = adone.tag.LOGGER; }
+ { const a: symbol = adone.tag.LONG; }
+ { const a: symbol = adone.tag.BIGNUMBER; }
+ { const a: symbol = adone.tag.EXBUFFER; }
+ { const a: symbol = adone.tag.EXDATE; }
+ { const a: symbol = adone.tag.CONFIGURATION; }
+ { const a: symbol = adone.tag.GENESIS_NETRON; }
+ { const a: symbol = adone.tag.GENESIS_PEER; }
+ { const a: symbol = adone.tag.NETRON; }
+ { const a: symbol = adone.tag.NETRON_PEER; }
+ { const a: symbol = adone.tag.NETRON_ADAPTER; }
+ { const a: symbol = adone.tag.NETRON_DEFINITION; }
+ { const a: symbol = adone.tag.NETRON_DEFINITIONS; }
+ { const a: symbol = adone.tag.NETRON_REFERENCE; }
+ { const a: symbol = adone.tag.NETRON_INTERFACE; }
+ { const a: symbol = adone.tag.NETRON_STUB; }
+ { const a: symbol = adone.tag.NETRON_REMOTESTUB; }
+ { const a: symbol = adone.tag.NETRON_STREAM; }
+ { const a: symbol = adone.tag.FAST_STREAM; }
+ { const a: symbol = adone.tag.FAST_FS_STREAM; }
+ { const a: symbol = adone.tag.FAST_FS_MAP_STREAM; }
+ { const a: Promise = adone.run({}); }
+ { const a: Promise = adone.run({}, false); }
+ { const a: object = adone.bind("library"); } // hmm
+ { const a: string = adone.getAssetAbsolutePath("asset"); }
+ { const a: Buffer | string = adone.loadAsset("asset"); }
+ { const a: object = adone.require("path"); }
+ { const a: object = adone.package; }
+ { const a: typeof adone.assertion.assert = adone.assert; }
+ { const a: typeof adone.assertion.expect = adone.expect; }
+}
diff --git a/types/adone/tsconfig.json b/types/adone/tsconfig.json
new file mode 100644
index 0000000000..ad90d2b5d7
--- /dev/null
+++ b/types/adone/tsconfig.json
@@ -0,0 +1,42 @@
+{
+ "compilerOptions": {
+ "module": "commonjs",
+ "target": "es2017",
+ "lib": [
+ "es6"
+ ],
+ "noImplicitAny": true,
+ "noImplicitThis": true,
+ "strictNullChecks": true,
+ "baseUrl": "../",
+ "typeRoots": [
+ "../"
+ ],
+ "types": [],
+ "noEmit": true,
+ "forceConsistentCasingInFileNames": true
+ },
+ "files": [
+ "index.d.ts",
+ "adone.d.ts",
+ "glosses/common.d.ts",
+ "glosses/math.d.ts",
+ "glosses/std.d.ts",
+ "glosses/utils.d.ts",
+ "glosses/assertion.d.ts",
+ "glosses/promise.d.ts",
+ "glosses/shani.d.ts",
+ "glosses/shani-global.d.ts",
+ "adone-tests.ts",
+ "test/index.ts",
+ "test/index-import.ts",
+ "test/glosses/common.ts",
+ "test/glosses/math.ts",
+ "test/glosses/std.ts",
+ "test/glosses/utils.ts",
+ "test/glosses/assertion.ts",
+ "test/glosses/promise.ts",
+ "test/glosses/shani.ts",
+ "test/glosses/shani-global.ts"
+ ]
+}
diff --git a/types/adone/tslint.json b/types/adone/tslint.json
new file mode 100644
index 0000000000..f0ae61d2bf
--- /dev/null
+++ b/types/adone/tslint.json
@@ -0,0 +1,15 @@
+{
+ "extends": "dtslint/dt.json",
+ "rules": {
+ // TODOs
+ "align": false,
+ "no-namespace": false,
+ "strict-export-declare-modifiers": false,
+ "no-boolean-literal-compare": false,
+ "no-mergeable-namespace": false,
+ "no-single-declare-module": false,
+ "no-unnecessary-qualifier": false,
+ "unified-signatures": false,
+ "space-before-function-paren": false
+ }
+}
\ No newline at end of file
diff --git a/types/ag-grid/ag-grid-tests.ts b/types/ag-grid/ag-grid-tests.ts
deleted file mode 100644
index 7c4ebb0c8c..0000000000
--- a/types/ag-grid/ag-grid-tests.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-
-checkGridOptions({});
-checkColDef({});
-
-function checkGridOptions(gridOptions: ag.grid.GridOptions): void {
-
- gridOptions.virtualPaging = true;
- gridOptions.toolPanelSuppressPivot = true;
- gridOptions.toolPanelSuppressValues = true;
- gridOptions.rowsAlreadyGrouped = true;
- gridOptions.suppressRowClickSelection = true;
- gridOptions.suppressCellSelection = true;
- gridOptions.sortingOrder = ['asc','desc'];
- gridOptions.suppressMultiSort = true;
- gridOptions.suppressHorizontalScroll = true;
- gridOptions.unSortIcon = true;
- gridOptions.rowHeight = 0;
- gridOptions.rowBuffer = 0;
- gridOptions.enableColResize = true;
- gridOptions.enableCellExpressions = true;
- gridOptions.enableSorting = true;
- gridOptions.enableServerSideSorting = true;
- gridOptions.enableFilter = true;
- gridOptions.enableServerSideFilter = true;
- gridOptions.colWidth = 0;
- gridOptions.suppressMenuHide = true;
- gridOptions.singleClickEdit = true;
- gridOptions.debug = true;
- gridOptions.icons = {};
- gridOptions.angularCompileRows = true;
- gridOptions.angularCompileFilters = true;
- gridOptions.angularCompileHeaders = true;
- gridOptions.localeText = {};
- gridOptions.localeTextFunc = function() {}
- gridOptions.suppressScrollLag = true;
- gridOptions.groupSuppressAutoColumn = true;
- gridOptions.groupSelectsChildren = true;
- gridOptions.groupHidePivotColumns = true;
- gridOptions.groupIncludeFooter = true;
- gridOptions.groupUseEntireRow = true;
- gridOptions.groupSuppressRow = true;
- gridOptions.groupSuppressBlankHeader = true;
- gridOptions.forPrint = true;
- gridOptions.groupColumnDef = {};
- gridOptions.context = {};
- gridOptions.rowStyle = {color: 'red'};
- gridOptions.rowClass = 'green';
- gridOptions.groupDefaultExpanded = false;
- gridOptions.slaveGrids = [];
- gridOptions.rowSelection = 'single';
- gridOptions.rowDeselection = true;
- gridOptions.rowData = [];
- gridOptions.floatingTopRowData = [];
- gridOptions.floatingBottomRowData = [];
- gridOptions.showToolPanel = true;
- gridOptions.groupKeys = ['a','b']
- gridOptions.groupAggFields = ['a','b']
- gridOptions.columnDefs = [];
- gridOptions.datasource = {};
- gridOptions.pinnedColumnCount = 0;
- gridOptions.groupHeaders = true;
- gridOptions.headerHeight = 0;
- gridOptions.groupRowInnerRenderer = function(params) {};
- gridOptions.groupRowRenderer = {};
- gridOptions.isScrollLag = function() {return true;}
- gridOptions.isExternalFilterPresent = function() { return true; };
- gridOptions.doesExternalFilterPass = function(node: ag.grid.RowNode) { return false; };
- gridOptions.getRowStyle = function() {};
- gridOptions.getRowClass = function() {};
- gridOptions.headerCellRenderer = function() {};
- gridOptions.groupAggFunction = function(nodes: any[]) {};
- gridOptions.onReady = function(api: any) {};
- gridOptions.onModelUpdated = function() {};
- gridOptions.onCellClicked = function(params) {};
- gridOptions.onCellDoubleClicked = function(params) {};
- gridOptions.onCellContextMenu = function(params) {};
- gridOptions.onCellValueChanged = function(params) {};
- gridOptions.onCellFocused = function(params) {};
- gridOptions.onRowSelected = function(params) {};
- gridOptions.onSelectionChanged = function() {};
- gridOptions.onBeforeFilterChanged = function() {};
- gridOptions.onAfterFilterChanged = function() {};
- gridOptions.onFilterModified = function() {};
- gridOptions.onBeforeSortChanged = function() {};
- gridOptions.onAfterSortChanged = function() {};
- gridOptions.onVirtualRowRemoved = function(params) {};
- gridOptions.onRowClicked = function(params) {};
- gridOptions.api = null;
- gridOptions.columnApi = null;
-
-}
-
-function checkColDef(colDef: ag.grid.ColDef): void {
-
- colDef.sort = 'test';
- colDef.sortedAt = 0;
- colDef.sortingOrder = ['asc','desc'];
- colDef.headerName = 'test';
- colDef.field = 'test';
- colDef.headerValueGetter = 'test';
- colDef.colId = 'test';
- colDef.hide = true;
- colDef.headerTooltip = 'test';
- colDef.valueGetter = 'test';
- colDef.headerCellRenderer = {};
- colDef.headerClass = 'test';
- colDef.width = 0;
- colDef.minWidth = 0;
- colDef.maxWidth = 0;
- colDef.cellClass = 'test';
- colDef.cellStyle = {color: 'test'};
- colDef.cellRenderer = function() {};
- colDef.floatingCellRenderer = function() {};
- colDef.aggFunc = 'test';
- colDef.comparator = function() {};
- colDef.checkboxSelection = true;
- colDef.suppressMenu = true;
- colDef.suppressSorting = true;
- colDef.unSortIcon = true;
- colDef.suppressSizeToFit = true;
- colDef.suppressResize = true;
- colDef.headerGroup = 'test';
- colDef.headerGroupShow = 'test';
- colDef.editable = true;
- colDef.newValueHandler = function() {};
- colDef.volatile = true;
- colDef.template = 'test';
- colDef.templateUrl = 'test';
- colDef.filter = 'test';
- colDef.filterParams = {};
- colDef.onCellValueChanged = function() {};
- colDef.onCellClicked = function() {};
- colDef.onCellDoubleClicked = function() {};
- colDef.onCellContextMenu = function() {};
- colDef.cellClassRules = {};
-}
diff --git a/types/ag-grid/index.d.ts b/types/ag-grid/index.d.ts
deleted file mode 100644
index 3fe37571b1..0000000000
--- a/types/ag-grid/index.d.ts
+++ /dev/null
@@ -1,1991 +0,0 @@
-// Type definitions for ag-grid v2.1.2
-// Project: http://www.ag-grid.com/
-// Definitions by: Niall Crosby
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-declare namespace ag.grid {
- class ColumnChangeEvent {
- private type;
- private column;
- private columnGroup;
- private fromIndex;
- private toIndex;
- private pinnedColumnCount;
- constructor(type: string);
- toString(): string;
- withColumn(column: Column): ColumnChangeEvent;
- withColumnGroup(columnGroup: ColumnGroup): ColumnChangeEvent;
- withFromIndex(fromIndex: number): ColumnChangeEvent;
- withPinnedColumnCount(pinnedColumnCount: number): ColumnChangeEvent;
- withToIndex(toIndex: number): ColumnChangeEvent;
- getFromIndex(): number;
- getToIndex(): number;
- getPinnedColumnCount(): number;
- getType(): string;
- getColumn(): Column;
- getColumnGroup(): ColumnGroup;
- isPivotChanged(): boolean;
- isValueChanged(): boolean;
- isIndividualColumnResized(): boolean;
- }
-}
-declare namespace ag.grid {
- class Utils {
- private static isSafari;
- private static isIE;
- static iterateObject(object: any, callback: (key: string, value: any) => void): void;
- static cloneObject(object: any): any;
- static map(array: TItem[], callback: (item: TItem) => TResult): TResult[];
- static forEach