vhad/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/gosticks/DefinitelyTyped.git synced 2026-08-11 12:30:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge upstream changes (#3)

Browse Source
This commit is contained in:
Zev Spitz
2017-09-10 08:44:56 +03:00
committed by GitHub
parent 3ec0a9d9ed
commit 4319f2ed28
5227 changed files with 151505 additions and 79493 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.github/CODEOWNERS
+3413
View File
File diff suppressed because it is too large Load Diff
README.md
+36 -1
View File
@@ -133,6 +133,7 @@ For a good example package, see [base64-js](https://github.com/DefinitelyTyped/D
* First, follow advice from the [handbook](http://www.typescriptlang.org/docs/handbook/declaration-files/do-s-and-don-ts.html).
* Formatting: Either use all tabs, or always use 4 spaces.
* `function sum(nums: number[]): number`: Use `ReadonlyArray` if a function does not write to its parameters.
* `interface Foo { new(): Foo; }`:
This defines a type of objects that are new-able. You probably want `declare class Foo { constructor(); }`.
* `const Class: { new(): IClass; }`:
@@ -143,6 +144,10 @@ For a good example package, see [base64-js](https://github.com/DefinitelyTyped/D
Example where a type parameter is acceptable: `function id<T>(value: T): T;`.
Example where it is not acceptable: `function parseJson<T>(json: string): T;`.
Exception: `new Map<string, number>()` is OK.
* Using the types `Function` and `Object` is almost never a good idea. In 99% of cases it's possible to specify a more specific type. Examples are `(x: number) => number` for [functions](http://www.typescriptlang.org/docs/handbook/functions.html#function-types) and `{ x: number, y: number }` for objects. If there is no certainty at all about the type, [`any`](http://www.typescriptlang.org/docs/handbook/basic-types.html#any) is the right choice, not `Object`. If the only known fact about the type is that it's some object, use the type [`object`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#object-type), not `Object` or `{ [key: string]: any }`.
* `var foo: string | any`:
When `any` is used in a union type, the resulting type is still `any`. So while the `string` portion of this type annotation may _look_ useful, it in fact offers no additional typechecking over simply using `any`.
Depending on the intention, acceptable alternatives could be `any`, `string`, or `string | object`.
#### Removing a package
@@ -177,6 +182,18 @@ If a `tslint.json` turns rules off, this is because that hasn't been fixed yet.
(To indicate that a lint rule truly does not apply, use `// tslint:disable rule-name` or better, `//tslint:disable-next-line rule-name`.)
To assert that an expression is of a given type, use `$ExpectType`. To assert that an expression causes a compile error, use `$ExpectError`.
```js
// $ExpectType void
f(1);
// $ExpectError
f("one");
```
For more details, see [dtslint](https://github.com/Microsoft/dtslint#write-tests) readme.
Test by running `npm run lint package-name` where `package-name` is the name of your package.
This script uses [dtslint](https://github.com/Microsoft/dtslint).
@@ -186,7 +203,14 @@ This script uses [dtslint](https://github.com/Microsoft/dtslint).
#### What exactly is the relationship between this repository and the `@types` packages on NPM?
The `master` branch is automatically published to the `@types` scope on NPM thanks to [types-publisher](https://github.com/Microsoft/types-publisher).
This usually happens within an hour of changes being merged.
#### I've submitted a pull request. How long until it is merged?
It depends, but most pull requests will be merged within a week. PRs that have been approved by an author listed in the definition's header are usually merged more quickly; PRs for new definitions will take more time as they require more review from maintainers. Each PR is reviewed by a TypeScript or DefinitelyTyped team member before being merged, so please be patient as human factors may cause delays. Check the [PR Burndown Board](https://github.com/DefinitelyTyped/DefinitelyTyped/projects/3?card_filter_query=is%3Aopen) to see progress as maintainers work through the open PRs.
#### My PR is merged; when will the `@types` NPM package be updated?
NPM packages should update within a few hours. If it's been more than 24 hours, ping @RyanCavanaugh and @andy-ms on the PR to investigate.
#### I'm writing a definition that depends on another definition. Should I use `<reference types="" />` or an import?
@@ -264,6 +288,17 @@ Also, `/// <reference types=".." />` will not work with path mapping, so depende
Types for a scoped package `@foo/bar` should go in `types/foo__bar`. Note the double underscore.
When `dts-gen` is used to scaffold a scoped package, the `paths` property has to be manually adapted in the generated
`tsconfig.json` to correctly reference the scoped package:
```json
{
"paths":{
"@foo/bar": ["foo__bar"]
}
}
```
#### The file history in GitHub looks incomplete.
notNeededPackages.json
+72
View File
@@ -1,11 +1,35 @@
{
"packages": [
{
"libraryName": "3d-bin-packing",
"typingsPackageName": "3d-bin-packing",
"sourceRepoURL": "https://github.com/betterwaysystems/packer",
"asOfVersion": "1.1.3"
},
{
"libraryName": "ag-grid",
"typingsPackageName": "ag-grid",
"sourceRepoURL": "https://github.com/ceolter/ag-grid",
"asOfVersion": "3.2.0"
},
{
"libraryName": "ajv",
"typingsPackageName": "ajv",
"sourceRepoURL": "https://github.com/epoberezkin/ajv",
"asOfVersion": "1.0.0"
},
{
"libraryName": "angular-ui-router-default",
"typingsPackageName": "angular-ui-router-default",
"sourceRepoURL": "https://github.com/nonplus/angular-ui-router-default",
"asOfVersion": "0.0.5"
},
{
"libraryName": "angular-ui-router-uib-modal",
"typingsPackageName": "angular-ui-router-uib-modal",
"sourceRepoURL": "https://github.com/nonplus/angular-ui-router-uib-modal",
"asOfVersion": "0.0.11"
},
{
"libraryName": "antd",
"typingsPackageName": "antd",
@@ -60,6 +84,12 @@
"sourceRepoURL": "http://www.babylonjs.com/",
"asOfVersion": "2.4.1"
},
{
"libraryName": "base64url",
"typingsPackageName": "base64url",
"sourceRepoURL": "https://github.com/brianloveswords/base64url",
"asOfVersion": "2.0.0"
},
{
"libraryName": "BigInteger.js",
"typingsPackageName": "big-integer",
@@ -252,6 +282,12 @@
"sourceRepoURL": "https://github.com/blakeembrey/is-upper-case",
"asOfVersion": "1.1.2"
},
{
"libraryName": "jpush-react-native",
"typingsPackageName": "jpush-react-native",
"sourceRepoURL": "https://github.com/jpush/jpush-react-native",
"asOfVersion": "2.0.0"
},
{
"libraryName": "jquery.ajaxfile",
"typingsPackageName": "jquery.ajaxfile",
@@ -450,6 +486,12 @@
"sourceRepoURL": "https://github.com/getsentry/raven-js",
"asOfVersion": "3.10.0"
},
{
"libraryName": "raw-body",
"typingsPackageName": "raw-body",
"sourceRepoURL": "https://github.com/stream-utils/raw-body",
"asOfVersion": "2.3.0"
},
{
"libraryName": "react-day-picker",
"typingsPackageName": "react-day-picker",
@@ -516,6 +558,30 @@
"sourceRepoURL": "https://github.com/tildeio/route-recognizer",
"asOfVersion": "0.3.0"
},
{
"libraryName": "router5",
"typingsPackageName": "router5",
"sourceRepoURL": "https://github.com/router5/router5",
"asOfVersion": "5.0.0"
},
{
"libraryName": "samchon",
"typingsPackageName": "samchon",
"sourceRepoURL": "https://github.com/samchon/framework",
"asOfVersion": "2.0.22"
},
{
"libraryName": "samchon-framework",
"typingsPackageName": "samchon-framework",
"sourceRepoURL": "https://github.com/samchon/framework",
"asOfVersion": "2.0.21"
},
{
"libraryName": "samchon-library",
"typingsPackageName": "samchon-library",
"sourceRepoURL": "https://github.com/samchon/framework",
"asOfVersion": "0.1.0"
},
{
"libraryName": "node-scanf",
"typingsPackageName": "scanf",
@@ -600,6 +666,12 @@
"sourceRepoURL": "https://github.com/cbowdon/TsMonad",
"asOfVersion": "0.5.0"
},
{
"libraryName": "tstl",
"typingsPackageName": "tstl",
"sourceRepoURL": "https://github.com/samchon/tstl",
"asOfVersion": "1.5.7"
},
{
"libraryName": "TypeScript",
"typingsPackageName": "typescript",
package.json
+1 -4
View File
@@ -21,10 +21,7 @@
"lint": "dtslint types"
},
"devDependencies": {
"dtslint": "Microsoft/dtslint#production",
"dtslint": "github:Microsoft/dtslint#production",
"types-publisher": "Microsoft/types-publisher#production"
},
"dependencies": {
"jslint": "^0.10.3"
}
}
scripts/fix-tslint.ts
+10 -1
View File
@@ -39,7 +39,16 @@ function fix(config: any): any {
const out: any = {};
for (const key in config) {
let value = config[key];
out[key] = value;
out[key] = key === "rules" ? fixRules(value) : value;
}
return out;
}
function fixRules(rules: any): any {
const out: any = {};
for (const key in rules) {
out[key] = rules[key];
}
return out;
}
types/3d-bin-packing/3d-bin-packing-tests.ts
-50
View File
@@ -1,50 +0,0 @@
import packer = require("3d-bin-packing");
import samchon = require("samchon");
function main(): void
{
///////////////////////////
// CONSTRUCT OBJECTS
///////////////////////////
let wrapperArray: bws.packer.WrapperArray = new packer.WrapperArray();
let instanceArray: bws.packer.InstanceArray = new packer.InstanceArray();
// Wrappers
wrapperArray.push
(
new packer.Wrapper("Large", 1000, 40, 40, 15, 0),
new packer.Wrapper("Medium", 700, 20, 20, 10, 0),
new packer.Wrapper("Small", 500, 15, 15, 8, 0)
);
///////
// Each Instance is repeated #15
///////
instanceArray.insert(instanceArray.end(), 15, new packer.Product("Eraser", 1, 2, 5));
instanceArray.insert(instanceArray.end(), 15, new packer.Product("Book", 15, 30, 3));
instanceArray.insert(instanceArray.end(), 15, new packer.Product("Drink", 3, 3, 10));
instanceArray.insert(instanceArray.end(), 15, new packer.Product("Umbrella", 5, 5, 20));
// Wrappers also can be packed into another Wrapper.
instanceArray.insert(instanceArray.end(), 15, new packer.Wrapper("Notebook-Box", 2000, 30, 40, 4, 2));
instanceArray.insert(instanceArray.end(), 15, new packer.Wrapper("Tablet-Box", 2500, 20, 28, 2, 0));
///////////////////////////
// BEGINS PACKING
///////////////////////////
// CONSTRUCT PACKER
let my_packer: bws.packer.Packer = new packer.Packer(wrapperArray, instanceArray);
///////
// PACK (OPTIMIZE)
let result: bws.packer.WrapperArray = my_packer.optimize();
///////
///////////////////////////
// TRACE PACKING RESULT
///////////////////////////
let xml: samchon.library.XML = result.toXML();
console.log(xml.toString());
}
main();
types/3d-bin-packing/index.d.ts
Vendored
-1383
View File
File diff suppressed because it is too large Load Diff
types/3d-bin-packing/tsconfig.json
-23
View File
@@ -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"
]
}
types/abbrev/abbrev-tests.ts
+13
View File
@@ -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<string> = [];
abbrs = roArr.abbrev();
abbrs = ({}).abbrev();
types/abbrev/index.d.ts
Vendored
+27
View File
@@ -0,0 +1,27 @@
// Type definitions for abbrev 1.1
// Project: https://github.com/isaacs/abbrev-js#readme
// Definitions by: BendingBender <https://github.com/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<T> {
abbrev(): {[abbreviation: string]: string};
}
interface ReadonlyArray<T> {
abbrev(): {[abbreviation: string]: string};
}
interface Object {
abbrev(): {[abbreviation: string]: string};
}
}
types/abbrev/tsconfig.json
+22
View File
@@ -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"
]
}
types/raw-body/tslint.json → types/abbrev/tslint.json
View File
types/ably/index.d.ts
Vendored
+3 -3
View File
@@ -1,6 +1,6 @@
// Type definitions for Ably Realtime and Rest client library 0.9
// Project: https://www.ably.io/
// Definitions by: Ably <https://github.com/ably/>
// Definitions by: Ably <https://github.com/ably>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
export namespace ablyLib {
@@ -287,7 +287,7 @@ export namespace ablyLib {
}
// Common Listeners
type paginatedResultCallback<T> = (error: ErrorInfo, results: PaginatedResult<T> ) => void;
type paginatedResultCallback<T> = (error: ErrorInfo, results: PaginatedResult<T>) => void;
type standardCallback = (error: ErrorInfo, results: any) => void;
type messageCallback<T> = (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 {
types/ably/tslint.json
+6 -1
View File
@@ -1 +1,6 @@
{ "extends": "dtslint/dt.json" }
{
"extends": "dtslint/dt.json",
"rules": {
"no-any-union": false
}
}
types/accounting/index.d.ts
Vendored
+2 -2
View File
@@ -1,7 +1,7 @@
// Type definitions for accounting.js 0.4
// Project: http://openexchangerates.github.io/accounting.js/
// Definitions by: Sergey Gerasimov <https://github.com/gerich-home/>
// Christopher Eck <https://github.com/chrisleck/>
// Definitions by: Sergey Gerasimov <https://github.com/gerich-home>
// Christopher Eck <https://github.com/chrisleck>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
declare namespace accounting {
types/acl/index.d.ts
Vendored
+4 -1
View File
@@ -50,7 +50,10 @@ interface Acl {
allowedPermissions: (userId: Value, resources: strings, cb?: AnyCallback) => Promise<void>;
isAllowed: (userId: Value, resources: strings, permissions: strings, cb?: AllowedCallback) => Promise<boolean>;
areAnyRolesAllowed: (roles: strings, resource: strings, permissions: strings, cb?: AllowedCallback) => Promise<any>;
whatResources: (roles: strings, permissions: strings, cb?: AnyCallback) => Promise<any>;
whatResources: {
(roles: strings, cb?: AnyCallback): Promise<any>;
(roles: strings, permissions: strings, cb?: AnyCallback): Promise<any>;
}
permittedResources: (roles: strings, permissions: strings, cb?: Function) => Promise<void>;
middleware: (numPathComponents?: number, userId?: Value | GetUserId, actions?: strings) => express.RequestHandler;
}
types/acl/test/index.ts
+12
View File
@@ -66,6 +66,18 @@ acl.isAllowed('joed', 'blogs', 'view', (err, res) => {
}
});
acl.whatResources('foo', (err, res) => {
if (res) {
console.log(res);
}
});
acl.whatResources('foo', 'view', (err, res) => {
if (res) {
console.log(res);
}
});
acl.isAllowed('jsmith', 'blogs', ['edit','view','delete'])
.then((result) => {
console.dir('jsmith is allowed blogs ' + result);
types/activex-adodb/activex-adodb-tests.ts
+1 -3
View File
@@ -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
types/activex-adodb/package.json
+6 -1
View File
@@ -1 +1,6 @@
{ "dependencies": { "activex-helpers": "*"}}
{
"private": true,
"dependencies": {
"activex-helpers": "*"
}
}
types/activex-adodb/tsconfig.json
-1
View File
@@ -6,7 +6,6 @@
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strict": true,
"baseUrl": "../",
"typeRoots": [
"../"
types/activex-scripting/activex-scripting-tests.ts
+16 -16
View File
@@ -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 + '<br>';
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);
};
}
types/activex-scripting/package.json
+6 -1
View File
@@ -1 +1,6 @@
{ "dependencies": { "activex-helpers": "*"}}
{
"private": true,
"dependencies": {
"activex-helpers": "*"
}
}
types/activex-scripting/tsconfig.json
-1
View File
@@ -6,7 +6,6 @@
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strict": true,
"baseUrl": "../",
"typeRoots": [
"../"
types/activex-wia/activex-wia-tests.ts
+8 -8
View File
@@ -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<WIA.Property>(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;
}
}
types/activex-wia/package.json
+6 -1
View File
@@ -1 +1,6 @@
{ "dependencies": { "activex-helpers": "*"}}
{
"private": true,
"dependencies": {
"activex-helpers": "*"
}
}
types/activex-wia/tsconfig.json
-1
View File
@@ -6,7 +6,6 @@
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strict": true,
"baseUrl": "../",
"typeRoots": [
"../"
types/adal/index.d.ts
Vendored
+2
View File
@@ -31,6 +31,8 @@ declare namespace adal {
resource?: string;
extraQueryParameter?: string;
navigateToLoginRequestUrl?: boolean;
logOutUri?: string;
isAngular?: boolean;
}
interface User {
types/adone/adone-tests.ts
+3
View File
@@ -0,0 +1,3 @@
// Actual tests inside ./test/
const a: string = adone.ok;
types/adone/adone.d.ts
Vendored
+85
View File
@@ -0,0 +1,85 @@
/// <reference types="node" />
declare const _null: symbol;
export { _null as null };
export function noop(): void;
export function identity<T>(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<void>;
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;
types/adone/glosses/assertion.d.ts
Vendored
+1074
View File
File diff suppressed because it is too large Load Diff
types/adone/glosses/common.d.ts
Vendored
+465
View File
@@ -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<T>(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<string | symbol>;
listenerCount(type: string | symbol): number;
}
export class AsyncEmitter extends EventEmitter {
constructor(concurrency?: number);
setConcurrency(max?: number): this;
emitParallel(event: string, ...args: any[]): Promise<any[]>;
emitSerial(event: string, ...args: any[]): Promise<any[]>;
emitReduce(event: string, ...args: any[]): Promise<any>;
emitReduceRight(event: string, ...args: any[]): Promise<any>;
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;
}
types/adone/glosses/math.d.ts
Vendored
+118
View File
@@ -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;
}
}
types/adone/glosses/promise.d.ts
Vendored
+114
View File
@@ -0,0 +1,114 @@
/**
* promise helpers
*/
export namespace promise {
namespace I {
interface Deferred<T> {
/**
* Resolves the promise
*/
resolve(value?: T): void;
/**
* Rejects the promise
*/
reject(value?: any): void;
promise: Promise<T>;
}
}
/**
* Creates a promise and returns an interface to control the state
*/
export function defer<T>(): I.Deferred<T>;
/**
* Creates a promise that will be resolved after given milliseconds
*
* @param ms delay in milliseconds
* @param value resolving value
*/
export function delay<T>(ms: number, value?: T): Promise<T>;
/**
* 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<T>(promise: Promise<T>, ms: number): Promise<T>;
/**
* Converts a promise to node.js style callback
*/
export function nodeify<T>(promise: Promise<T>, callback: (err?: any, value?: T) => void): Promise<T>;
namespace I {
interface PromisifyOptions {
/**
* Context to bind to new function
*/
context?: object;
}
}
/**
* Converts a callback function to a promise-based function
*/
export function promisify<R>(fn: (callback: (err?: any, result?: R) => void) => void, options?: I.PromisifyOptions): () => Promise<R>;
export function promisify<T, R>(fn: (a: T, callback: (err?: any, result?: R) => void) => void, options?: I.PromisifyOptions): (a: T) => Promise<R>;
export function promisify<T>(fn: (a: T, callback: (err?: any) => void) => void, options?: I.PromisifyOptions): (a: T) => Promise<void>;
export function promisify<T1, T2, R>(fn: (a: T1, b: T2, callback: (err?: any, result?: R) => void) => void, options?: I.PromisifyOptions): (a: T1, b: T2) => Promise<R>;
export function promisify<T1, T2>(fn: (a: T1, b: T2, callback: (err?: any) => void) => void, options?: I.PromisifyOptions): (a: T1, b: T2) => Promise<void>;
export function promisify<T1, T2, T3, R>(fn: (a: T1, b: T2, c: T3, callback: (err?: any, result?: R) => void) => void, options?: I.PromisifyOptions): (a: T1, b: T2, c: T3) => Promise<R>;
export function promisify<T1, T2, T3>(fn: (a: T1, b: T2, c: T3, callback: (err?: any) => void) => void, options?: I.PromisifyOptions): (a: T1, b: T2, c: T3) => Promise<void>;
export function promisify<T1, T2, T3, T4, R>(
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<R>;
export function promisify<T1, T2, T3, T4>(
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<void>;
export function promisify<T1, T2, T3, T4, T5, R>(
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<R>;
export function promisify<T1, T2, T3, T4, T5>(
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<void>;
export function promisify(fn: (...args: any[]) => void, options?: I.PromisifyOptions): (...args: any[]) => Promise<any>;
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<T>(promise: Promise<T>, onFinally?: (...args: any[]) => void): Promise<T>;
export { _finally as finally };
}
types/adone/glosses/shani-global.d.ts
Vendored
+79
View File
@@ -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;
types/adone/glosses/shani.d.ts
Vendored
+1655
View File
File diff suppressed because it is too large Load Diff
types/adone/glosses/std.d.ts
Vendored
+65
View File
@@ -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,
};
types/adone/glosses/utils.d.ts
Vendored
+473
View File
@@ -0,0 +1,473 @@
/**
* various utility functions
*/
export namespace util {
function arrify<T>(val: T[]): T[];
function arrify<T>(val: T): [T];
function slice<T>(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): <T>(...args: T[]) => T[];
function mapArguments(...args: any[]): <T>(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<T>(arrayLike: ArrayLike<T>, from?: number, to?: number): T;
function shuffleArray<T>(array: T[]): T[];
function enumerate<T>(iterable: Iterable<T>, start?: number): IterableIterator<[number, T]>;
function zip<T1, T2>(a: Iterable<T1>, b: Iterable<T2>): IterableIterator<[T1, T2]>;
function zip<T1, T2, T3>(a: Iterable<T1>, b: Iterable<T2>, c: Iterable<T3>): IterableIterator<[T1, T2, T3]>;
function zip<T1, T2, T3, T4>(a: Iterable<T1>, b: Iterable<T2>, c: Iterable<T3>, d: Iterable<T4>): IterableIterator<[T1, T2, T3, T4]>;
function zip(...iterables: Array<Iterable<any>>): IterableIterator<any[]>;
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<string | any>;
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<S, T, R> {
(a: S, b: S): R;
compare(a: T, b: T): R;
by(a: S): T;
}
}
function by<S, T, R>(by: (a: S) => T, compare?: (a: T, b: T) => R): I.ByResult<S, T, R>;
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<T>(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<T>(array: T[], iter: (elem: T, index: number, cb: () => void) => any, cb: () => void): void;
function asyncFor<T>(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<T>(fn: (...args: any[]) => T, options?: I.OnceOptions): (...args: any[]) => T;
namespace I {
type WaterFallTask = (...args: any[]) => void;
}
function asyncWaterfall<T>(tasks: I.WaterFallTask[], callback?: (err?: Error | null, ...args: any[]) => void): void;
function xrange(start?: number, stop?: number, step?: number): IterableIterator<number>;
function range(start?: number, stop?: number, step?: number): number[];
function reFindAll(regexp: RegExp, str: string): RegExpExecArray[];
function assignDeep<T>(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 {
<T>(edges: Array<[T, T]>): T[];
array<T>(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<adone.std.child_process.ChildProcess>;
run(): Promise<string>;
cleanup(): Promise<void>;
static edit(options?: I.EditorOptions): Promise<string>;
}
namespace I {
interface BinarySearchFunction {
<T>(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<number>;
tryRemoveTokens(count: number): boolean;
getTokensRemaining(): number;
}
namespace I {
interface ThrottleOptions {
max?: number;
interval?: number;
ordered?: boolean;
waitForReturn?: boolean;
}
}
function throttle<R>(fn: () => R, options?: I.ThrottleOptions): () => Promise<R>;
function throttle<T1, R>(fn: (a: T1) => R, options?: I.ThrottleOptions): (a: T1) => Promise<R>;
function throttle<T1, T2, R>(fn: (a: T1, b: T2) => R, options?: I.ThrottleOptions): (a: T1, b: T2) => Promise<R>;
function throttle<T1, T2, T3, R>(fn: (a: T1, b: T2, c: T3) => R, options?: I.ThrottleOptions): (a: T1, b: T2, c: T3) => Promise<R>;
function throttle<T1, T2, T3, T4, R>(fn: (a: T1, b: T2, c: T3, d: T4) => R, options?: I.ThrottleOptions): (a: T1, b: T2, c: T3, d: T4) => Promise<R>;
function throttle<T1, T2, T3, T4, T5, R>(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<R>;
function throttle<R>(fn: (...args: any[]) => R, options?: I.ThrottleOptions): (...args: any[]) => Promise<R>;
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<T> {
lt?: T;
lte?: T;
gt?: T;
gte?: T;
min?: T;
max?: T;
start?: T;
end?: T;
reverse?: boolean;
}
type Comparator<T> = (a: T, b: T) => number;
}
function contains<T>(range: I.Range<T>, key: T, compare?: I.Comparator<T>): boolean;
function filter<T>(range: I.Range<T>, compare?: I.Comparator<T>): (key: T) => boolean;
function toLtgt<T, R>(
range: I.Range<T>,
_range: object,
map?: (value: T, isUpperBound: boolean) => R,
lowerBound?: T,
upperBound?: T
): I.Range<R>;
function endInclusive<T>(range: I.Range<T>): boolean;
function startInclusive<T>(range: I.Range<T>): boolean;
function end<T>(range: I.Range<T>): T | undefined;
function end<T, R>(range: I.Range<T>, defaultValue: R): T | R;
function start<T>(range: I.Range<T>): T | undefined;
function start<T, R>(range: I.Range<T>, defaultValue?: R): T | R;
function upperBound<T>(range: I.Range<T>): T | undefined;
function upperBound<T, R>(range: I.Range<T>, defaultValue: R): T | R;
function upperBoundKey<T>(range: I.Range<T>): T | undefined;
function upperBoundExclusive<T>(range: I.Range<T>): boolean;
function lowerBoundExclusive<T>(range: I.Range<T>): boolean;
function upperBoundInclusive<T>(range: I.Range<T>): boolean;
function lowerBoundInclusive<T>(range: I.Range<T>): boolean;
function lowerBound<T>(range: I.Range<T>): T | undefined;
function lowerBound<T, R>(range: I.Range<T>, defaultValue: R): T | R;
function lowerBoundKey<T>(range: I.Range<T>): T | undefined;
}
}
types/adone/index.d.ts
Vendored
+9
View File
@@ -0,0 +1,9 @@
// Type definitions for adone 0.6
// Project: https://github.com/ciferox/adone
// Definitions by: am <https://github.com/s0m3on3>, Maximus <https://github.com/maxveres>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.4
import * as adone from "./adone";
export default adone;
types/adone/test/glosses/assertion.ts
+653
View File
@@ -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({});
}
}
}
types/adone/test/glosses/common.ts
+808
View File
@@ -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<string | symbol> = new adone.EventEmitter().eventNames();
const b: Array<string | symbol> = 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<any[]> = new adone.AsyncEmitter().emitParallel("even");
const b: Promise<any[]> = new adone.AsyncEmitter().emitParallel("even", 1, 2, 3);
}
namespace emitSerial {
const a: Promise<any[]> = new adone.AsyncEmitter().emitSerial("even");
const b: Promise<any[]> = new adone.AsyncEmitter().emitSerial("even", 1, 2, 3);
}
namespace emitReduce {
const a: Promise<any[]> = new adone.AsyncEmitter().emitReduce("even");
const b: Promise<any[]> = new adone.AsyncEmitter().emitReduce("even", 1, 2, 3);
}
namespace emitReduceRight {
const a: Promise<any[]> = new adone.AsyncEmitter().emitReduceRight("even");
const b: Promise<any[]> = 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;
}
}
}
}
types/adone/test/glosses/math.ts
+259
View File
@@ -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;
}
}
}
}
types/adone/test/glosses/promise.ts
+97
View File
@@ -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<string>();
b.resolve("3");
b.reject(2);
b.promise.then((x: string) => x);
}
namespace delay {
const a: Promise<any> = promise.delay(10);
const b: Promise<number> = 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<T> = (err?: any, result?: T) => void;
namespace noargs {
const f = (cb: Callback<number>) => {
cb(null, 32);
};
promise.promisify(f)().then((x: number) => { });
}
namespace nargs1 {
const f = (a: number, cb: Callback<number>) => {
cb(null, 32);
};
promise.promisify(f)(1).then((x: number) => { });
}
namespace nargs2 {
const f = (a: number, b: string, cb: Callback<number>) => {
cb(null, 32);
};
promise.promisify(f)(1, "1").then((x: number) => { });
}
namespace nargs3 {
const f = (a: number, b: string, c: number, cb: Callback<number>) => {
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<number>) => {
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<number>) => {
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<number>) => {
cb(null, 32);
};
promise.promisify(f)(1, 2, 3).then((x) => x);
}
namespace options {
promise.promisify((cb: Callback<number>) => cb(null, 42), {});
promise.promisify((cb: Callback<number>) => 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) => {});
}
}
types/adone/test/glosses/shani-global.ts
+163
View File
@@ -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("");
}
types/adone/test/glosses/shani.ts
+544
View File
@@ -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);
});
}
}
types/adone/test/glosses/std.ts
+161
View File
@@ -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);
}
}
types/adone/test/glosses/utils.ts
+737
View File
@@ -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: <T>(...args: T[]) => T[] = util.mapArguments(1);
const c: (...args: any[]) => any = util.mapArguments([1]);
const d: <T>(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<number> = util.throttle(() => 42);
const b: (a: number) => Promise<string> = util.throttle((a: number) => `${a}`);
const c: (a: number, b: string) => Promise<string> = 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<number> = util.ltgt.toLtgt({ lt: 2 }, {});
const b: adone.util.ltgt.I.Range<string> = util.ltgt.toLtgt({ lt: 2 }, {}, (a) => `${a}`);
const c: adone.util.ltgt.I.Range<number> = util.ltgt.toLtgt({ lt: 2 }, {}, (a) => a, 2);
const d: adone.util.ltgt.I.Range<number> = 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);
}
}
}
}
types/adone/test/index-import.ts
+6
View File
@@ -0,0 +1,6 @@
import adone from "adone";
namespace AdoneRootImportTests {
adone.falsely() === false;
adone.std.fs.createReadStream(__filename).close();
}
types/adone/test/index.ts
+71
View File
@@ -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<void> = adone.run({}); }
{ const a: Promise<void> = 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; }
}
types/adone/tsconfig.json
+42
View File
@@ -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"
]
}
types/adone/tslint.json
+17
View File
@@ -0,0 +1,17 @@
{
"extends": "dtslint/dt.json",
"rules": {
// TODOs
"align": false,
"no-namespace": false,
"strict-export-declare-modifiers": false,
"no-any-union": false,
"no-boolean-literal-compare": false,
"no-mergeable-namespace": false,
"no-single-declare-module": false,
"no-unnecessary-generics": false,
"no-unnecessary-qualifier": false,
"unified-signatures": false,
"space-before-function-paren": false
}
}
types/aframe/tsconfig.json
+20 -20
View File
@@ -1,25 +1,25 @@
{
"compilerOptions": {
"baseUrl": "..",
"lib": [
"es5",
"dom",
"es2015.iterable",
"es2015.promise"
],
"module": "commonjs",
"noImplicitAny": true,
"noImplicitThis": true,
"removeComments": false,
"sourceMap": true,
"strictNullChecks": true,
"noEmit": true,
"forceConsistentCasingInFileNames": true,
"typeRoots": [ "../" ],
"types": [ ]
"module": "commonjs",
"lib": [
"es5",
"dom",
"es2015.iterable",
"es2015.promise"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"aframe-tests.ts"
"index.d.ts",
"aframe-tests.ts"
]
}
}
types/aframe/tslint.json
+4 -1
View File
@@ -1,3 +1,6 @@
{
"extends": "dtslint/dt.json"
"extends": "dtslint/dt.json",
"rules": {
"no-unnecessary-generics": false
}
}
types/ag-grid/ag-grid-tests.ts
-136
View File
@@ -1,136 +0,0 @@
checkGridOptions(<ag.grid.GridOptions>{});
checkColDef(<ag.grid.ColDef>{});
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 = {};
}
types/ag-grid/index.d.ts
Vendored
-1991
View File
File diff suppressed because it is too large Load Diff
types/ag-grid/tsconfig.json
-23
View File
@@ -1,23 +0,0 @@
{
"files": [
"index.d.ts",
"ag-grid-tests.ts"
],
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6",
"dom"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": false,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
}
}
types/agenda/agenda-tests.ts
+6 -4
View File
@@ -3,16 +3,16 @@ import * as Agenda from "agenda";
var mongoConnectionString = "mongodb://127.0.0.1/agenda";
var agenda = new Agenda({ db: { address: mongoConnectionString } });
agenda.define('delete old users', (job, done) => {
});
agenda.on('ready', () => {
agenda.every('3 minutes', 'delete old users');
// Alternatively, you could also do:
// Alternatively, you could also do:
agenda.every('*/3 * * * *', 'delete old users');
agenda.start();
@@ -81,6 +81,8 @@ agenda.stop(function() {
process.exit(0);
});
job.agenda.now('do the hokey pokey');
job.repeatEvery('10 minutes');
job.repeatAt('3:30pm');
types/agenda/index.d.ts
Vendored
+6 -1
View File
@@ -1,4 +1,4 @@
// Type definitions for Agenda v0.8.9
// Type definitions for Agenda v1.0.0
// Project: https://github.com/rschmukler/agenda
// Definitions by: Meir Gottlieb <https://github.com/meirgottlieb>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -337,6 +337,11 @@ declare namespace Agenda {
*/
attrs: JobAttributes;
/**
* The agenda that created the job.
*/
agenda: Agenda;
/**
* Specifies an interval on which the job should repeat.
* @param interval A human-readable format String, a cron format String, or a Number.
types/aggregate-error/aggregate-error-tests.ts
+9
View File
@@ -0,0 +1,9 @@
import AggregateError = require('aggregate-error');
const err = new AggregateError([new Error('foo'), 'bar']);
for (const el of Array.from(err)) {
const err: Error = el;
}
throw err;
types/aggregate-error/index.d.ts
Vendored
+12
View File
@@ -0,0 +1,12 @@
// Type definitions for aggregate-error 1.0
// Project: https://github.com/sindresorhus/aggregate-error#readme
// Definitions by: BendingBender <https://github.com/BendingBender>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
export = AggregateError;
declare class AggregateError extends Error implements Iterable<Error> {
constructor(errors: Iterable<Error | string>);
[Symbol.iterator](): Iterator<Error>;
}
types/aggregate-error/tsconfig.json
+22
View File
@@ -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",
"aggregate-error-tests.ts"
]
}
types/aggregate-error/tslint.json
+1
View File
@@ -0,0 +1 @@
{ "extends": "dtslint/dt.json" }
types/alertify/index.d.ts
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
// Type definitions for alertify 0.3.11
// Project: http://fabien-d.github.io/alertify.js/
// Definitions by: John Jeffery <http://github.com/jjeffery>
// Definitions by: John Jeffery <https://github.com/jjeffery>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
declare var alertify: alertify.IAlertifyStatic;
types/alexa-sdk/alexa-sdk-tests.ts
+2 -2
View File
@@ -1,13 +1,13 @@
import * as Alexa from "alexa-sdk";
const handler = (event: Alexa.RequestBody<Alexa.Request>, context: Alexa.Context, callback: () => void) => {
let alexa = Alexa.handler(event, context);
const alexa = Alexa.handler(event, context);
alexa.resources = {};
alexa.registerHandlers(handlers);
alexa.execute();
};
let handlers: Alexa.Handlers<Alexa.Request> = {
const handlers: Alexa.Handlers<Alexa.Request> = {
'LaunchRequest': function() {
this.emit('SayHello');
},
types/alexa-sdk/index.d.ts
Vendored
+25 -1
View File
@@ -7,7 +7,7 @@
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.2
export function handler<T>(event: RequestBody<T>, context: Context, callback?: (err: any, response: any) => void ): AlexaObject<T>;
export function handler<T>(event: RequestBody<T>, context: Context, callback?: (err: any, response: any) => void): AlexaObject<T>;
export function CreateStateHandler(state: string, obj: any): any;
export let StateString: string;
@@ -98,10 +98,34 @@ export interface Request {
locale?: string;
}
export interface ResolutionStatus {
code: string;
}
export interface ResolutionValue {
name: string;
id: string;
}
export interface ResolutionValueContainer {
value: ResolutionValue;
}
export interface Resolution {
authority: string;
status: ResolutionStatus;
values: ResolutionValueContainer[];
}
export interface Resolutions {
resolutionsPerAuthority: Resolution[];
}
export interface SlotValue {
confirmationStatus?: ConfirmationStatuses;
name: string;
value?: any;
resolutions?: Resolutions;
}
export interface Intent {
types/algebra.js/algebra.js-tests.ts
+34 -34
View File
@@ -5,9 +5,9 @@ import { Equation, Expression, Fraction, parse, toTex } from 'algebra.js';
expr = expr.subtract(3);
expr = expr.add("x");
expr.toString();
let eq = new Equation(expr, 4);
const eq = new Equation(expr, 4);
eq.toString();
let x = eq.solveFor("x");
const x = eq.solveFor("x");
x.toString();
}
{
@@ -29,14 +29,14 @@ import { Equation, Expression, Fraction, parse, toTex } from 'algebra.js';
x.toString();
x = x.add("y");
x.toString();
let otherExp = new Expression("x").add(6);
const otherExp = new Expression("x").add(6);
x = x.add(otherExp);
x.toString();
let expr1 = new Expression("a").add("b").add("c");
let expr2 = new Expression("c").subtract("b");
let expr3 = expr1.subtract(expr2);
expr1.toString() + " - (" + expr2.toString() + ") = " + expr3.toString();
`${expr1.toString()} - (${expr2.toString()}) = ${expr3.toString()}`;
expr1 = new Expression("x");
expr1 = expr1.add(2);
@@ -46,7 +46,7 @@ import { Equation, Expression, Fraction, parse, toTex } from 'algebra.js';
expr2 = expr2.multiply(new Fraction(1, 3));
expr2 = expr2.add(4);
expr3 = expr1.multiply(expr2);
"(" + expr1.toString() + ")(" + expr2.toString() + ") = " + expr3.toString();
`(${expr1.toString()})(${expr2.toString()}) = ${expr3.toString()}`;
x = new Expression("x").divide(2).divide(new Fraction(1, 5));
x.toString();
@@ -54,11 +54,11 @@ import { Equation, Expression, Fraction, parse, toTex } from 'algebra.js';
exp = exp.add("y");
exp = exp.add(3);
exp.toString();
let sum = exp.summation("x", 3, 6);
const sum = exp.summation("x", 3, 6);
sum.toString();
exp = new Expression("x").add(2);
let exp3 = exp.pow(3);
"(" + exp.toString() + ")^3 = " + exp3.toString();
const exp3 = exp.pow(3);
`(${exp.toString()})^3 = ${exp3.toString()}`;
let expr = new Expression("x");
expr = expr.multiply(2);
@@ -66,14 +66,14 @@ import { Equation, Expression, Fraction, parse, toTex } from 'algebra.js';
expr = expr.add("y");
expr = expr.add(new Fraction(1, 3));
expr.toString();
let answer1 = expr.eval({ x: 2 });
let answer2 = expr.eval({ x: 2, y: new Fraction(3, 4) });
const answer1 = expr.eval({ x: 2 });
const answer2 = expr.eval({ x: 2, y: new Fraction(3, 4) });
answer1.toString();
answer2.toString();
expr = new Expression("x").add(2);
expr.toString();
let sub = new Expression("y").add(4);
let answer = expr.eval({ x: sub });
const sub = new Expression("y").add(4);
const answer = expr.eval({ x: sub });
answer.toString();
exp = new Expression("x").add(2);
exp.toString();
@@ -91,23 +91,23 @@ import { Equation, Expression, Fraction, parse, toTex } from 'algebra.js';
exp.toString();
exp = exp.simplify();
exp.toString();
let z = new Expression("z");
let eq1 = new Equation(z.subtract(4).divide(9), z.add(6));
const z = new Expression("z");
const eq1 = new Equation(z.subtract(4).divide(9), z.add(6));
eq1.toString();
let eq2 = new Equation(z.add(4).multiply(9), 6);
const eq2 = new Equation(z.add(4).multiply(9), 6);
eq2.toString();
let eq3 = new Equation(z.divide(2).multiply(7), new Fraction(1, 4));
const eq3 = new Equation(z.divide(2).multiply(7), new Fraction(1, 4));
eq3.toString();
}
{
let x1 = parse("1/5 * x + 2/15");
let x2 = parse("1/7 * x + 4");
const x1 = parse("1/5 * x + 2/15");
const x2 = parse("1/7 * x + 4");
let eq = new Equation(x1 as Expression, x2 as Expression);
eq.toString();
let answer = eq.solveFor("x");
const answer = eq.solveFor("x");
"x = " + answer.toString();
let expr1 = parse("1/4 * x + 5/4");
let expr2 = parse("3 * y - 12/5");
const expr1 = parse("1/4 * x + 5/4");
const expr2 = parse("3 * y - 12/5");
eq = new Equation(expr1 as Expression, expr2 as Expression);
eq.toString();
let xAnswer = eq.solveFor("x");
@@ -116,14 +116,14 @@ import { Equation, Expression, Fraction, parse, toTex } from 'algebra.js';
"y = " + yAnswer.toString();
let n1 = parse("x + 5") as Expression;
let n2 = parse("x - 3/4") as Expression;
let quad = new Equation(n1.multiply(n2), 0);
const quad = new Equation(n1.multiply(n2), 0);
quad.toString();
let answers = quad.solveFor("x");
"x = " + answers.toString();
n1 = parse("x + 2") as Expression;
n2 = parse("x + 3") as Expression;
let n3 = parse("x + 4") as Expression;
let cubic = new Equation(n1.multiply(n2).multiply(n3), 0);
const n3 = parse("x + 4") as Expression;
const cubic = new Equation(n1.multiply(n2).multiply(n3), 0);
cubic.toString();
answers = cubic.solveFor("x");
"x = " + answers.toString();
@@ -143,20 +143,20 @@ import { Equation, Expression, Fraction, parse, toTex } from 'algebra.js';
exp.toString();
}
{
let eq = parse("x^2 + 4 * x + 4 = 0") as Equation;
const eq = parse("x^2 + 4 * x + 4 = 0") as Equation;
eq.toString();
let ans = eq.solveFor("x");
const ans = eq.solveFor("x");
"x = " + ans.toString();
let a = new Expression("x").pow(2);
let b = new Expression("x").multiply(new Fraction(5, 4));
let c = new Fraction(-21, 4);
let expr = a.add(b).add(c);
let quad = new Equation(expr, 0);
const a = new Expression("x").pow(2);
const b = new Expression("x").multiply(new Fraction(5, 4));
const c = new Fraction(-21, 4);
const expr = a.add(b).add(c);
const quad = new Equation(expr, 0);
toTex(quad);
let answers = quad.solveFor("x");
const answers = quad.solveFor("x");
toTex(answers);
let lambda = new Expression("lambda").add(3).divide(4);
let Phi = new Expression("Phi").subtract(new Fraction(1, 5)).add(lambda);
const lambda = new Expression("lambda").add(3).divide(4);
const Phi = new Expression("Phi").subtract(new Fraction(1, 5)).add(lambda);
toTex(lambda);
toTex(Phi);
}
types/algoliasearch/algoliasearch-tests.ts
+1 -1
View File
@@ -48,7 +48,7 @@ let _algoliaSecuredApiOptions: AlgoliaSecuredApiOptions = {
let _algoliaIndexSettings: AlgoliaIndexSettings = {
attributesToIndex: [""],
attributesforFaceting: [""],
attributesForFaceting: [""],
unretrievableAttributes: [""],
attributesToRetrieve: [""],
ranking: [""],
types/algoliasearch/index.d.ts
Vendored
+1 -1
View File
@@ -976,7 +976,7 @@ declare namespace algoliasearch {
* default: null
* https://github.com/algolia/algoliasearch-client-js#attributesforfaceting
*/
attributesforFaceting?: string[];
attributesForFaceting?: string[];
/**
* The list of attributes that cannot be retrieved at query time
* default: null
types/amazon-product-api/index.d.ts
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
// Type definitions for amazon-product-api
// Project: https://github.com/t3chnoboy/amazon-product-api
// Definitions by: Matti Lehtinen <https://github.com/MattiLehtinen/>
// Definitions by: Matti Lehtinen <https://github.com/MattiLehtinen>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
types/amplify-deferred/index.d.ts
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
// Type definitions for AmplifyJs (using JQuery Deferred) 1.1
// Project: http://amplifyjs.com/
// Definitions by: Jonas Eriksson <https://github.com/joeriks/>, Laurentiu Stamate <https://github.com/laurentiustamate94>
// Definitions by: Jonas Eriksson <https://github.com/joeriks>, Laurentiu Stamate <https://github.com/laurentiustamate94>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
types/amplify/amplify-tests.ts
+24 -14
View File
@@ -151,7 +151,7 @@ amplify.request.define("twitter-search", "ajax", {
}
});
amplify.request("twitter-search", { term: "amplifyjs" } );
amplify.request("twitter-search", { term: "amplifyjs" });
// Similarly, we can create a request that searches for mentions, by accepting a username:
@@ -168,19 +168,24 @@ amplify.request("twitter-mentions", { user: "amplifyjs" });
// Example:
const appEnvelopeDecoder: amplify.Decoder = (data, status, xhr, success, error) => {
if (data.status === "success") {
success(data.data);
} else if (data.status === "fail" || data.status === "error") {
error(data.message, data.status);
} else {
error(data.message, "fatal");
switch (data.status) {
case "success":
success(data.data);
break;
case "fail":
case "error":
error(data.message, data.status);
break;
default:
error(data.message, "fatal");
break;
}
};
// a new decoder can be added to the amplifyDecoders interface
declare module "amplify" {
interface Decoders {
appEnvelope: amplify.Decoder;
appEnvelope: Decoder;
}
}
@@ -213,12 +218,17 @@ amplify.request.define("decoderSingleExample", "ajax", {
url: "/myAjaxUrl",
type: "POST",
decoder(data, status, xhr, success, error) {
if (data.status === "success") {
success(data.data);
} else if (data.status === "fail" || data.status === "error") {
error(data.message, data.status);
} else {
error(data.message, "fatal");
switch (data.status) {
case "success":
success(data.data);
break;
case "fail":
case "error":
error(data.message, data.status);
break;
default:
error(data.message, "fatal");
break;
}
}
});
types/amplify/index.d.ts
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
// Type definitions for AmplifyJs 1.1
// Project: http://amplifyjs.com/
// Definitions by: Jonas Eriksson <https://github.com/joeriks/>
// Definitions by: Jonas Eriksson <https://github.com/joeriks>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
types/amqp-rpc/index.d.ts
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
// Type definitions for amqp-rpc v0.0.8
// Project: https://github.com/demchenkoe/node-amqp-rpc/
// Definitions by: Wonshik Kim <https://github.com/wokim/>
// Definitions by: Wonshik Kim <https://github.com/wokim>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference types="node" />
types/amqp/index.d.ts
Vendored
+1
View File
@@ -49,6 +49,7 @@ export interface AMQPQueue extends events.EventEmitter {
export interface AMQPExchange extends events.EventEmitter {
on(event: 'open' | 'ack' | 'error' | 'exchangeBindOk' | 'exchangeUnbindOk', callback: Callback<void>): this;
publish(routingKey: string, message: Buffer | {}, callback: (err?: boolean, msg?: string) => void): void;
publish(routingKey: string, message: Buffer | {}, options: ExchangePublishOptions, callback?: (err?: boolean, msg?: string) => void): void;
/**
types/amqplib/amqplib-tests.ts
+18 -8
View File
@@ -16,13 +16,19 @@ amqp.connect('amqp://localhost')
.then(connection => {
return connection.createChannel()
.tap(channel => channel.checkQueue('myQueue'))
.then(channel => channel.consume('myQueue', newMsg => console.log('New Message: ' + newMsg.content.toString())))
.then(channel => {
return channel.consume('myQueue', newMsg => {
if (newMsg != null) {
// test promise api properties
if (newMsg.properties.contentType === 'application/json') {
console.log('New Message: ' + newMsg.content.toString());
}
}
});
})
.finally(() => connection.close());
});
// test promise api properties
let amqpMessage: amqp.Message;
amqpMessage.properties.contentType = 'application/json';
let amqpAssertExchangeOptions: amqp.Options.AssertExchange;
let anqpAssertExchangeReplies: amqp.Replies.AssertExchange;
@@ -49,7 +55,14 @@ amqpcb.connect('amqp://localhost', (err, connection) => {
if (!err) {
channel.assertQueue('myQueue', {}, (err, ok) => {
if (!err) {
channel.consume('myQueue', newMsg => console.log('New Message: ' + newMsg.content.toString()));
channel.consume('myQueue', newMsg => {
if (newMsg != null) {
// test callback api properties
if (newMsg.properties.contentType === 'application/json') {
console.log('New Message: ' + newMsg.content.toString());
}
}
});
}
});
}
@@ -57,8 +70,5 @@ amqpcb.connect('amqp://localhost', (err, connection) => {
}
});
// test callback api properties
let amqpcbMessage: amqpcb.Message;
amqpcbMessage.properties.contentType = 'application/json';
let amqpcbAssertExchangeOptions: amqpcb.Options.AssertExchange;
let anqpcbAssertExchangeReplies: amqpcb.Replies.AssertExchange;
types/amqplib/callback_api.d.ts
Vendored
+1 -1
View File
@@ -31,7 +31,7 @@ export interface Channel extends events.EventEmitter {
publish(exchange: string, routingKey: string, content: Buffer, options?: Options.Publish): boolean;
sendToQueue(queue: string, content: Buffer, options?: Options.Publish): boolean;
consume(queue: string, onMessage: (msg: Message) => any, options?: Options.Consume, callback?: (err: any, ok: Replies.Consume) => void): void;
consume(queue: string, onMessage: (msg: Message | null) => any, options?: Options.Consume, callback?: (err: any, ok: Replies.Consume) => void): void;
cancel(consumerTag: string, callback?: (err: any, ok: Replies.Empty) => void): void;
get(queue: string, options?: Options.Get, callback?: (err: any, ok: Message | false) => void): void;
types/amqplib/index.d.ts
Vendored
+1 -1
View File
@@ -40,7 +40,7 @@ export interface Channel extends events.EventEmitter {
publish(exchange: string, routingKey: string, content: Buffer, options?: Options.Publish): boolean;
sendToQueue(queue: string, content: Buffer, options?: Options.Publish): boolean;
consume(queue: string, onMessage: (msg: Message) => any, options?: Options.Consume): Promise<Replies.Consume>;
consume(queue: string, onMessage: (msg: Message | null) => any, options?: Options.Consume): Promise<Replies.Consume>;
cancel(consumerTag: string): Promise<Replies.Empty>;
get(queue: string, options?: Options.Get): Promise<Message | false>;
types/amqplib/tsconfig.json
+2 -2
View File
@@ -6,7 +6,7 @@
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": false,
"strictNullChecks": true,
"baseUrl": "../",
"typeRoots": [
"../"
@@ -20,4 +20,4 @@
"callback_api.d.ts",
"amqplib-tests.ts"
]
}
}
types/amqplib/tslint.json
+3 -1
View File
@@ -1,6 +1,8 @@
{
"extends": "dtslint/dt.json",
"rules": {
"no-empty-interface": false
// All are TODOs
"no-empty-interface": false,
"prefer-const": false
}
}
types/angular-block-ui/angular-block-ui-tests.ts
+1 -1
View File
@@ -37,5 +37,5 @@ app.controller('Ctrl', ($scope: ng.IScope, blockUI: angular.blockUI.BlockUIServi
blockUI.reset();
blockUI.message("Hello Types");
blockUI.done();
let b: boolean = blockUI.isBlocking();
const b: boolean = blockUI.isBlocking();
});
types/angular-block-ui/index.d.ts
Vendored
+1 -1
View File
@@ -70,7 +70,7 @@ declare module 'angular' {
* @param {angular.IRequestConfig} config - the Angular request config object.
*
*/
requestFilter?(config: angular.IRequestConfig): (string | boolean);
requestFilter?(config: IRequestConfig): (string | boolean);
/**
* When the module is started it will inject the main block element
types/angular-bootstrap-calendar/package.json
+1
View File
@@ -1,4 +1,5 @@
{
"private": true,
"dependencies": {
"moment": ">=2.14.0"
}
types/angular-clipboard/index.d.ts
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
// Type definitions for angular-clipboard v1.5
// Project: https://github.com/omichelsen/angular-clipboard
// Definitions by: Bradford Wagner <https://github.com/bradfordwagner/>
// Definitions by: Bradford Wagner <https://github.com/bradfordwagner>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
types/angular-cookies/index.d.ts
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
// Type definitions for Angular JS (ngCookies module) 1.4
// Project: http://angularjs.org
// Definitions by: Diego Vilar <http://github.com/diegovilar>, Anthony Ciccarello <http://github.com/aciccarello>
// Definitions by: Diego Vilar <https://github.com/diegovilar>, Anthony Ciccarello <https://github.com/aciccarello>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
types/angular-deferred-bootstrap/index.d.ts
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
// Type definitions for angular-deferred-bootstrap v0.1.9
// Project: https://github.com/philippd/angular-deferred-bootstrap
// Definitions by: Markus Wagner <https://github.com/Ritzlgrmft/>
// Definitions by: Markus Wagner <https://github.com/Ritzlgrmft>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
types/angular-es/index.d.ts
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
// Type definitions for angular-es v0.0.3
// Project: https://github.com/mbutsykin/angular-es
// Definitions by: mbutsykin <https://github.com/mbutsykin/>
// Definitions by: mbutsykin <https://github.com/mbutsykin>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
declare module 'angular-es' {
types/angular-feature-flags/angular-feature-flags-tests.ts
+12 -11
View File
@@ -1,8 +1,8 @@
import * as angular from "angular";
import * as ng from 'angular';
let myApp = angular.module('myApp', ['feature-flags']);
const myApp = ng.module('myApp', ['feature-flags']);
const flagsData: Array<angular.featureflags.FlagData> = [
const flagsData: Array<ng.featureflags.FlagData> = [
{
key: '1',
active: true,
@@ -17,15 +17,16 @@ const flagsData: Array<angular.featureflags.FlagData> = [
}
];
myApp.config(function (featureFlagsProvider: angular.featureflags.FeatureFlagsProvider) {
myApp.config(function(featureFlagsProvider: ng.featureflags.FeatureFlagsProvider) {
featureFlagsProvider.setInitialFlags(flagsData);
});
myApp.run(function ($q: angular.IQService, $http: angular.IHttpService, featureFlags: angular.featureflags.FeatureFlagsService) {
let deferred = $q.defer();
deferred.resolve(flagsData);
featureFlags.set(deferred.promise);
myApp.run(function(
$q: ng.IQService,
$http: ng.IHttpService,
featureFlags: ng.featureflags.FeatureFlagsService
) {
featureFlags.set($q.resolve(flagsData));
featureFlags.set($http.get('/data/flags.json'));
});
featureFlags.set($http.get<Array<ng.featureflags.FlagData>>('/data/flags.json'));
});
types/angular-feature-flags/index.d.ts
Vendored
+11 -6
View File
@@ -1,14 +1,14 @@
// Type definitions for angular-feature-flags 1.4.0
// Project: https://github.com/mjt01/angular-feature-flags
// Definitions by: Borislav Zhivkov <https://github.com/borislavjivkov/>
// Definitions by: Borislav Zhivkov <https://github.com/borislavjivkov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
/// <reference types="angular" />
import * as angular from "angular";
import * as ng from 'angular';
declare module "angular" {
declare module 'angular' {
namespace featureflags {
export interface FlagData {
/**
@@ -27,17 +27,22 @@ declare module "angular" {
name: string;
/**
* A long description of the flag to further explain the feature being toggled (only visible in the list of flags)
* A long description of the flag to further explain the feature being toggled
* (only visible in the list of flags)
*/
description: string;
}
export interface FeatureFlagsProvider {
setInitialFlags(flags: Array<FlagData>): void;
setInitialFlags(flags: ReadonlyArray<FlagData>): void;
}
export interface FeatureFlagsService {
set(flagsPromise: angular.IPromise<FlagData> | angular.IHttpPromise<FlagData>): void;
set(
flagsPromise:
| ng.IPromise<ReadonlyArray<FlagData>>
| ng.IHttpPromise<ReadonlyArray<FlagData>>
): void;
}
}
}
types/angular-file-saver/index.d.ts
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
// Type definitions for angular-file-saver 1.1
// Project: https://github.com/alferov/angular-file-saver
// Definitions by: Donald Nairn <https://github.com/deenairn/>
// Definitions by: Donald Nairn <https://github.com/deenairn>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
types/angular-gridster/angular-gridster-tests.ts
-1
View File
@@ -1,4 +1,3 @@
import * as ng from "angular";
import * as angular from "angular";
import gridster from "angular-gridster";
types/angular-gridster/index.d.ts
Vendored
+6 -6
View File
@@ -89,13 +89,13 @@ declare module "angular" {
handles?: string[];
// optional callback fired when drag is started
start?(event: angular.IAngularEvent, $element: angular.IAugmentedJQuery, options: any): void;
start?(event: IAngularEvent, $element: IAugmentedJQuery, options: any): void;
// optional callback fired when item is resized
resize?(event: angular.IAngularEvent, $element: angular.IAugmentedJQuery, options: any): void;
resize?(event: IAngularEvent, $element: IAugmentedJQuery, options: any): void;
// optional callback fired when item is finished dragging
stop?(event: angular.IAngularEvent, $element: angular.IAugmentedJQuery, options: any): void;
stop?(event: IAngularEvent, $element: IAugmentedJQuery, options: any): void;
};
// options to pass to draggable handler
@@ -113,13 +113,13 @@ declare module "angular" {
handle?: string;
// optional callback fired when drag is started
start?(event: angular.IAngularEvent, $element: angular.IAugmentedJQuery, options: any): void;
start?(event: IAngularEvent, $element: IAugmentedJQuery, options: any): void;
// optional callback fired when item is moved,
drag?(event: angular.IAngularEvent, $element: angular.IAugmentedJQuery, options: any): void;
drag?(event: IAngularEvent, $element: IAugmentedJQuery, options: any): void;
// optional callback fired when item is finished dragging
stop?(event: angular.IAngularEvent, $element: angular.IAugmentedJQuery, options: any): void;
stop?(event: IAngularEvent, $element: IAugmentedJQuery, options: any): void;
};
}
types/angular-hotkeys/index.d.ts
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@
// Definitions by: Jason Zhao <https://github.com/jlz27>, Stefan Steinhart <https://github.com/reppners>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
//readme written by David Valentine <https://github.com/dvalenti314/>
//readme written by David Valentine <https://github.com/dvalenti314>
/// <reference types="angular" />
types/angular-localforage/package.json
+1
View File
@@ -1,4 +1,5 @@
{
"private": true,
"dependencies": {
"localforage": "^1.5.0"
}
types/angular-material/angular-material-tests.ts
+1 -1
View File
@@ -49,7 +49,7 @@ myApp.config((
return c * t * t + b;
},
easeFnIndeterminate(t, b, c, d) {
return c * Math.pow(2, 10 * (t / d - 1)) + b;
return c * Math.pow(2, (t / d - 1) * 10) + b;
}
});
});
types/angular-material/index.d.ts
Vendored
+31 -28
View File
@@ -18,7 +18,7 @@ declare module 'angular' {
interface IBottomSheetOptions {
templateUrl?: string;
template?: string;
scope?: angular.IScope; // default: new child scope
scope?: IScope; // default: new child scope
preserveScope?: boolean; // default: false
controller?: string | Injectable<IControllerConstructor>;
locals?: { [index: string]: any };
@@ -28,12 +28,12 @@ declare module 'angular' {
escapeToClose?: boolean;
resolve?: ResolveObject;
controllerAs?: string;
parent?: ((scope: angular.IScope, element: JQuery) => Element | JQuery) | string | Element | JQuery; // default: root node
parent?: ((scope: IScope, element: JQuery) => Element | JQuery) | string | Element | JQuery; // default: root node
disableParentScroll?: boolean; // default: true
}
interface IBottomSheetService {
show(options: IBottomSheetOptions): angular.IPromise<any>;
show(options: IBottomSheetOptions): IPromise<any>;
hide(response?: any): void;
cancel(response?: any): void;
}
@@ -47,7 +47,7 @@ declare module 'angular' {
templateUrl(templateUrl?: string): T;
template(template?: string): T;
targetEvent(targetEvent?: MouseEvent): T;
scope(scope?: angular.IScope): T; // default: new child scope
scope(scope?: IScope): T; // default: new child scope
preserveScope(preserveScope?: boolean): T; // default: false
disableParentScroll(disableParentScroll?: boolean): T; // default: true
hasBackdrop(hasBackdrop?: boolean): T; // default: true
@@ -61,6 +61,9 @@ declare module 'angular' {
controllerAs(controllerAs?: string): T;
parent(parent?: string | Element | JQuery): T; // default: root node
ariaLabel(ariaLabel: string): T;
openFrom(from: string | Element | Event | { top: number, left: number }): T;
closeTo(to: string | Element | { top: number, left: number }): T;
multiple(multiple: boolean): T;
}
// tslint:disable-next-line no-empty-interface
@@ -95,7 +98,7 @@ declare module 'angular' {
targetEvent?: MouseEvent;
openFrom?: any;
closeTo?: any;
scope?: angular.IScope; // default: new child scope
scope?: IScope; // default: new child scope
preserveScope?: boolean; // default: false
disableParentScroll?: boolean; // default: true
hasBackdrop?: boolean; // default: true
@@ -108,24 +111,24 @@ declare module 'angular' {
resolve?: ResolveObject;
controllerAs?: string;
parent?: string | Element | JQuery; // default: root node
onShowing?(scope: angular.IScope, element: JQuery): void;
onComplete?(scope: angular.IScope, element: JQuery): void;
onRemoving?(element: JQuery, removePromise: angular.IPromise<any>): void;
onShowing?(scope: IScope, element: JQuery): void;
onComplete?(scope: IScope, element: JQuery): void;
onRemoving?(element: JQuery, removePromise: IPromise<any>): void;
skipHide?: boolean;
multiple?: boolean;
fullscreen?: boolean; // default: false
}
interface IDialogService {
show(dialog: IDialogOptions | IAlertDialog | IConfirmDialog | IPromptDialog): angular.IPromise<any>;
show(dialog: IDialogOptions | IAlertDialog | IConfirmDialog | IPromptDialog): IPromise<any>;
confirm(): IConfirmDialog;
alert(): IAlertDialog;
prompt(): IPromptDialog;
hide(response?: any): angular.IPromise<any>;
hide(response?: any): IPromise<any>;
cancel(response?: any): void;
}
type IIcon = (id: string) => angular.IPromise<Element>; // id is a unique ID or URL
type IIcon = (id: string) => IPromise<Element>; // id is a unique ID or URL
interface IIconProvider {
icon(id: string, url: string, viewBoxSize?: number): IIconProvider; // viewBoxSize default: 24
@@ -138,16 +141,16 @@ declare module 'angular' {
type IMedia = (media: string) => boolean;
interface ISidenavObject {
toggle(): angular.IPromise<void>;
open(): angular.IPromise<void>;
close(): angular.IPromise<void>;
toggle(): IPromise<void>;
open(): IPromise<void>;
close(): IPromise<void>;
isOpen(): boolean;
isLockedOpen(): boolean;
onClose(onClose: () => void): void;
}
interface ISidenavService {
(component: string, enableWait: boolean): angular.IPromise<ISidenavObject>;
(component: string, enableWait: boolean): IPromise<ISidenavObject>;
(component: string): ISidenavObject;
}
@@ -172,7 +175,7 @@ declare module 'angular' {
templateUrl?: string;
template?: string;
autoWrap?: boolean;
scope?: angular.IScope; // default: new child scope
scope?: IScope; // default: new child scope
preserveScope?: boolean; // default: false
hideDelay?: number | false; // default (ms): 3000
position?: string; // any combination of 'bottom'/'left'/'top'/'right'/'fit'; default: 'bottom left'
@@ -186,8 +189,8 @@ declare module 'angular' {
}
interface IToastService {
show(optionsOrPreset: IToastOptions | IToastPreset<any>): angular.IPromise<any>;
showSimple(content: string): angular.IPromise<any>;
show(optionsOrPreset: IToastOptions | IToastPreset<any>): IPromise<any>;
showSimple(content: string): IPromise<any>;
simple(): ISimpleToastPreset;
build(): IToastPreset<any>;
updateContent(newContent: string): void;
@@ -303,7 +306,7 @@ declare module 'angular' {
}
interface IMenuService {
hide(response?: any, options?: any): angular.IPromise<any>;
hide(response?: any, options?: any): IPromise<any>;
}
interface IColorPalette {
@@ -363,19 +366,19 @@ declare module 'angular' {
isAttached: boolean;
panelContainer: JQuery;
panelEl: JQuery;
open(): angular.IPromise<any>;
close(): angular.IPromise<any>;
attach(): angular.IPromise<any>;
detach(): angular.IPromise<any>;
show(): angular.IPromise<any>;
hide(): angular.IPromise<any>;
open(): IPromise<any>;
close(): IPromise<any>;
attach(): IPromise<any>;
detach(): IPromise<any>;
show(): IPromise<any>;
hide(): IPromise<any>;
destroy(): void;
addClass(newClass: string): void;
removeClass(oldClass: string): void;
toggleClass(toggleClass: string): void;
updatePosition(position: IPanelPosition): void;
registerInterceptor(type: string, callback: () => angular.IPromise<any>): IPanelRef;
removeInterceptor(type: string, callback: () => angular.IPromise<any>): IPanelRef;
registerInterceptor(type: string, callback: () => IPromise<any>): IPanelRef;
removeInterceptor(type: string, callback: () => IPromise<any>): IPanelRef;
removeAllInterceptors(type?: string): IPanelRef;
}
@@ -404,7 +407,7 @@ declare module 'angular' {
interface IPanelService {
create(opt_config: IPanelConfig): IPanelRef;
open(opt_config: IPanelConfig): angular.IPromise<IPanelRef>;
open(opt_config: IPanelConfig): IPromise<IPanelRef>;
newPanelPosition(): IPanelPosition;
newPanelAnimation(): IPanelAnimation;
xPosition: {
types/angular-material/tslint.json
+3 -1
View File
@@ -1,7 +1,9 @@
{
"extends": "dtslint/dt.json",
"rules": {
// TODOs
"interface-name": false,
"max-line-length": false
"max-line-length": false,
"no-void-expression": false
}
}
types/angular-mocks/index.d.ts
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
// Type definitions for Angular JS (ngMock, ngMockE2E module) 1.5
// Project: http://angularjs.org
// Definitions by: Diego Vilar <http://github.com/diegovilar>, Tony Curtis <http://github.com/daltin>
// Definitions by: Diego Vilar <https://github.com/diegovilar>, Tony Curtis <https://github.com/daltin>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
types/angular-oauth2/index.d.ts
Vendored
+3 -3
View File
@@ -27,9 +27,9 @@ declare module 'angular' {
interface OAuth {
isAuthenticated(): boolean;
getAccessToken(data: Data, options?: any): angular.IPromise<string>;
getRefreshToken(data?: Data, options?: any): angular.IPromise<string>;
revokeToken(data?: Data, options?: any): angular.IPromise<string>;
getAccessToken(data: Data, options?: any): IPromise<string>;
getRefreshToken(data?: Data, options?: any): IPromise<string>;
revokeToken(data?: Data, options?: any): IPromise<string>;
}
interface OAuthTokenConfig {
types/angular-pdfjs-viewer/index.d.ts
Vendored
+1 -1
View File
@@ -8,7 +8,7 @@ import * as angular from 'angular';
declare module 'angular' {
namespace pdfjsViewer {
interface ConfigProvider extends angular.IServiceProvider {
interface ConfigProvider extends IServiceProvider {
setWorkerSrc(src: string): void;
setCmapDir(dir: string): void;
setImageDir(dir: string): void;
types/angular-promise-tracker/index.d.ts
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
// Type definitions for angular-promise-tracker 2.2.2
// Project: https://github.com/ajoslin/angular-promise-tracker
// Definitions by: Rufus Linke <https://github.com/rufusl/>
// Definitions by: Rufus Linke <https://github.com/rufusl>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
types/angular-resource/angular-resource-tests.ts
+5 -6
View File
@@ -32,7 +32,7 @@ interface IArticleResourceClass extends ng.resource.IResourceClass<IArticleResou
function MainController($resource: ng.resource.IResourceService): void {
// IntelliSense will provide IActionDescriptor interface and will validate
// your assignment against it
let publishDescriptor: ng.resource.IActionDescriptor = {
const publishDescriptor: ng.resource.IActionDescriptor = {
method: 'GET',
isArray: false
};
@@ -40,7 +40,7 @@ function MainController($resource: ng.resource.IResourceService): void {
// A call to the $resource service returns a IResourceClass. Since
// our own IArticleResourceClass defines 2 more actions, we cast the return
// value to make the compiler aware of that
let articleResource: IArticleResourceClass = $resource<IArticleResource, IArticleResourceClass>('/articles/:id', null, {
const articleResource: IArticleResourceClass = $resource<IArticleResource, IArticleResourceClass>('/articles/:id', null, {
publish : publishDescriptor,
unpublish : {
method: 'POST'
@@ -51,7 +51,7 @@ function MainController($resource: ng.resource.IResourceService): void {
articleResource.unpublish({ id: 1 });
// IResourceClass.get() will be automatically available here
let article: IArticleResource = articleResource.get({id: 1}, function success(): void {
const article: IArticleResource = articleResource.get({id: 1}, function success(): void {
// Again, default + custom action here...
article.title = 'New Title';
article.$save();
@@ -59,10 +59,9 @@ function MainController($resource: ng.resource.IResourceService): void {
});
}
import IHttpPromiseCallbackArg = angular.IHttpPromiseCallbackArg;
import IHttpResponse = angular.IHttpResponse;
interface IMyData {}
interface IMyHttpPromiseCallbackArg extends IHttpPromiseCallbackArg<IMyData> {}
interface IMyResource extends angular.resource.IResource<IMyResource> {}
interface IMyResourceClass extends angular.resource.IResourceClass<IMyResource> {}
@@ -87,7 +86,7 @@ angular.injector(['ng']).invoke(function ($cacheFactory: angular.ICacheFactorySe
actionDescriptor.withCredentials = true;
actionDescriptor.responseType = 'response type';
actionDescriptor.interceptor = {
response() { return {} as IMyHttpPromiseCallbackArg; },
response() { return {} as IHttpResponse<IMyData>; },
responseError() {}
};
actionDescriptor.cancellable = true;

Some files were not shown because too many files have changed in this diff Show More