mirror of
https://github.com/gosticks/DefinitelyTyped.git
synced 2026-08-12 13:00:19 +00:00
Merge remote-tracking branch 'source/master'
This commit is contained in:
Roberts Slisans
+3413
File diff suppressed because it is too large
Load Diff
@@ -178,6 +178,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).
|
||||
|
||||
@@ -265,6 +277,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.
|
||||
|
||||
|
||||
@@ -1,5 +1,11 @@
|
||||
{
|
||||
"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",
|
||||
@@ -18,6 +24,12 @@
|
||||
"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",
|
||||
@@ -270,12 +282,24 @@
|
||||
"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",
|
||||
"sourceRepoURL": "https://github.com/fpellet/jquery.ajaxFile",
|
||||
"asOfVersion": "0.2.29"
|
||||
},
|
||||
{
|
||||
"libraryName": "jquery.pjax.falsandtru",
|
||||
"typingsPackageName": "jquery.pjax.falsandtru",
|
||||
"sourceRepoURL": "https://github.com/falsandtru/pjax-api",
|
||||
"asOfVersion": "2.0.0"
|
||||
},
|
||||
{
|
||||
"libraryName": "JSNLog",
|
||||
"typingsPackageName": "jsnlog",
|
||||
@@ -468,6 +492,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",
|
||||
@@ -534,6 +564,24 @@
|
||||
"sourceRepoURL": "https://github.com/tildeio/route-recognizer",
|
||||
"asOfVersion": "0.3.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",
|
||||
@@ -618,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",
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
# Generator for material-ui
|
||||
|
||||
## Usage
|
||||
|
||||
```sh
|
||||
node scripts/material-ui/generate.js
|
||||
```
|
||||
|
||||
### GitHub API Limitation
|
||||
|
||||
The error `GitHub response: 401 Unauthorized` is due to [Rate Limiting | GitHub API v3 \| GitHub Developer Guide](https://developer.github.com/v3/#rate-limiting). In order to avoid this, it is necessary to publish [Personal access token](https://github.com/settings/tokens) and specify it as an environment variable.
|
||||
|
||||
```sh
|
||||
GITHUB_ACCESS_TOKEN=XXXXX node scripts/material-ui/generate.js
|
||||
```
|
||||
@@ -0,0 +1,147 @@
|
||||
const {get} = require('https')
|
||||
const {readdir, readFile, writeFile} = require('fs')
|
||||
const {join, extname, basename, dirname, relative} = require('path')
|
||||
|
||||
const token = process.env.GITHUB_ACCESS_TOKEN || ''
|
||||
|
||||
const toMixedCase = (name) => {
|
||||
let dist = name[0].toUpperCase()
|
||||
for (let i = 1; i < name.length; i++) {
|
||||
const c = name[i]
|
||||
if (c !== '-') {
|
||||
dist += c
|
||||
continue
|
||||
}
|
||||
i++
|
||||
dist += name[i].toUpperCase()
|
||||
}
|
||||
return dist
|
||||
}
|
||||
|
||||
const github = (path) => new Promise((resolve, reject) => {
|
||||
get({
|
||||
headers: {'user-agent': 'DefinitelyTyped/material-ui/generate'},
|
||||
host: 'api.github.com',
|
||||
path,
|
||||
}, (res) => {
|
||||
if ((res.statusCode / 100 >> 0) != 2) {
|
||||
reject(`GitHub response: ${res.statusCode} ${res.statusMessage}`)
|
||||
return
|
||||
}
|
||||
let data = '';
|
||||
res
|
||||
.on('data', (chunk) => data += chunk)
|
||||
.on('end', () => resolve(JSON.parse(data)))
|
||||
}).on('error', reject)
|
||||
})
|
||||
|
||||
const categories = () => github(`/repos/callemall/material-ui/contents/src/svg-icons?ref=master&access_token=${token}`)
|
||||
|
||||
const contents = (path) => github(`/repos/callemall/material-ui/contents/${path}?ref=master&access_token=${token}`)
|
||||
|
||||
const collator = new Intl.Collator()
|
||||
|
||||
const resolvePath = (filename) => join(__dirname, '../../types/material-ui', filename)
|
||||
|
||||
const readText = (filename) => new Promise((resolve, reject) => {
|
||||
readFile(resolvePath(filename), 'utf8', (err, data) => {
|
||||
if (err != null) {
|
||||
reject(err)
|
||||
return
|
||||
}
|
||||
resolve(data)
|
||||
})
|
||||
})
|
||||
|
||||
const writeText = (filename, text) => new Promise((resolve, reject) => {
|
||||
writeFile(resolvePath(filename), text, 'utf8', (err) => {
|
||||
if (err != null) {
|
||||
reject(err)
|
||||
return
|
||||
}
|
||||
resolve()
|
||||
})
|
||||
})
|
||||
|
||||
const inject = (content) => {
|
||||
content.category = this.name
|
||||
return content
|
||||
}
|
||||
|
||||
const rMark = /(\/{2} \{{3})[\s\S]*?(\/{2} \}{3})/g
|
||||
|
||||
categories()
|
||||
.then((cats) => Promise.all(Array.prototype.map.call(cats, (cat) => contents(cat.path)
|
||||
.then((cons) => Array.prototype.map.call(cons, (con) => {
|
||||
con.category = cat.name
|
||||
return con
|
||||
}))
|
||||
)))
|
||||
.then((contentsList) => Array.prototype.concat.apply([], contentsList)
|
||||
.map((content) => {
|
||||
const {path} = content
|
||||
const name = basename(path, extname(path))
|
||||
content.id = join(relative('src', dirname(path)), name)
|
||||
content.className = toMixedCase(content.category) + toMixedCase(name)
|
||||
return content
|
||||
})
|
||||
.sort((a, b) => collator.compare(a.id, b.id))
|
||||
.reduce((prev, content) => {
|
||||
const {dts, test} = prev
|
||||
dts.individuals.push(`declare module 'material-ui/${content.id}' {
|
||||
export import ${content.className} = __MaterialUI.SvgIcon;
|
||||
export default ${content.className};
|
||||
}`)
|
||||
dts.summarizeds.push(` export import ${content.className} = __MaterialUI.SvgIcon; // require('material-ui/${content.id}');`)
|
||||
|
||||
test.individuals.push(`import _${content.className} from 'material-ui/${content.id}';`)
|
||||
test.summarizeds.push(` ${content.className},`)
|
||||
return prev
|
||||
}, {
|
||||
dts: {individuals: [], summarizeds: []},
|
||||
test: {individuals: [], summarizeds: []},
|
||||
})
|
||||
)
|
||||
.then(({dts, test}) => {
|
||||
return Promise.all([
|
||||
(() => {
|
||||
const {individuals, summarizeds} = dts
|
||||
const file = 'index.d.ts'
|
||||
let index = 0
|
||||
return readText(file)
|
||||
.then((script) => writeText(file, script.replace(rMark, (_, p1, p2) => {
|
||||
let text = ''
|
||||
switch (index) {
|
||||
case 0:
|
||||
text = individuals.join('\n\n')
|
||||
break
|
||||
case 1:
|
||||
text = summarizeds.join('\n')
|
||||
break
|
||||
}
|
||||
index++
|
||||
return p1 + '\n' + text + '\n' + p2
|
||||
})))
|
||||
})(),
|
||||
(() => {
|
||||
const {individuals, summarizeds} = test
|
||||
const file = join('material-ui-tests.tsx')
|
||||
let index = 0
|
||||
return readText(file)
|
||||
.then((script) => writeText(file, script.replace(rMark, (_, p1, p2) => {
|
||||
let text = ''
|
||||
switch (index) {
|
||||
case 0:
|
||||
text = individuals.join('\n')
|
||||
break
|
||||
case 1:
|
||||
text = summarizeds.join('\n')
|
||||
break
|
||||
}
|
||||
index++
|
||||
return p1 + '\n' + text + '\n' + p2
|
||||
})))
|
||||
})(),
|
||||
])
|
||||
})
|
||||
.catch((err) => console.error(err))
|
||||
@@ -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();
|
||||
Vendored
-1383
File diff suppressed because it is too large
Load Diff
@@ -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();
|
||||
Vendored
+27
@@ -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};
|
||||
}
|
||||
}
|
||||
@@ -17,6 +17,6 @@
|
||||
},
|
||||
"files": [
|
||||
"index.d.ts",
|
||||
"raw-body-tests.ts"
|
||||
"abbrev-tests.ts"
|
||||
]
|
||||
}
|
||||
}
|
||||
Vendored
+3
-3
@@ -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 {
|
||||
|
||||
Vendored
+2
-2
@@ -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 {
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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);
|
||||
};
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
Vendored
+2
@@ -31,6 +31,8 @@ declare namespace adal {
|
||||
resource?: string;
|
||||
extraQueryParameter?: string;
|
||||
navigateToLoginRequestUrl?: boolean;
|
||||
logOutUri?: string;
|
||||
isAngular?: boolean;
|
||||
}
|
||||
|
||||
interface User {
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
// Actual tests inside ./test/
|
||||
|
||||
const a: string = adone.ok;
|
||||
Vendored
+85
@@ -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;
|
||||
Vendored
+1074
File diff suppressed because it is too large
Load Diff
Vendored
+465
@@ -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;
|
||||
}
|
||||
Vendored
+118
@@ -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;
|
||||
}
|
||||
}
|
||||
Vendored
+114
@@ -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 };
|
||||
}
|
||||
+79
@@ -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;
|
||||
Vendored
+1655
File diff suppressed because it is too large
Load Diff
Vendored
+65
@@ -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,
|
||||
};
|
||||
Vendored
+473
@@ -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;
|
||||
}
|
||||
}
|
||||
Vendored
+9
@@ -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;
|
||||
@@ -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({});
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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) => {});
|
||||
}
|
||||
}
|
||||
@@ -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("");
|
||||
}
|
||||
@@ -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);
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
import adone from "adone";
|
||||
|
||||
namespace AdoneRootImportTests {
|
||||
adone.falsely() === false;
|
||||
adone.std.fs.createReadStream(__filename).close();
|
||||
}
|
||||
@@ -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; }
|
||||
}
|
||||
@@ -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"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
{
|
||||
"extends": "dtslint/dt.json",
|
||||
"rules": {
|
||||
// TODOs
|
||||
"align": false,
|
||||
"no-namespace": false,
|
||||
"strict-export-declare-modifiers": false,
|
||||
"no-boolean-literal-compare": false,
|
||||
"no-mergeable-namespace": false,
|
||||
"no-single-declare-module": false,
|
||||
"no-unnecessary-qualifier": false,
|
||||
"unified-signatures": false,
|
||||
"space-before-function-paren": false
|
||||
}
|
||||
}
|
||||
@@ -3,7 +3,7 @@ import AggregateError = require('aggregate-error');
|
||||
const err = new AggregateError([new Error('foo'), 'bar']);
|
||||
|
||||
for (const el of Array.from(err)) {
|
||||
let err: Error = el;
|
||||
const err: Error = el;
|
||||
}
|
||||
|
||||
throw err;
|
||||
|
||||
Vendored
+1
-1
@@ -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;
|
||||
|
||||
@@ -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');
|
||||
},
|
||||
|
||||
Vendored
+1
-1
@@ -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;
|
||||
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -48,7 +48,7 @@ let _algoliaSecuredApiOptions: AlgoliaSecuredApiOptions = {
|
||||
|
||||
let _algoliaIndexSettings: AlgoliaIndexSettings = {
|
||||
attributesToIndex: [""],
|
||||
attributesforFaceting: [""],
|
||||
attributesForFaceting: [""],
|
||||
unretrievableAttributes: [""],
|
||||
attributesToRetrieve: [""],
|
||||
ranking: [""],
|
||||
|
||||
Vendored
+1
-1
@@ -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
|
||||
|
||||
Vendored
+1
-1
@@ -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
|
||||
|
||||
|
||||
|
||||
Vendored
+1
-1
@@ -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
|
||||
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
Vendored
+1
-1
@@ -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
|
||||
|
||||
|
||||
Vendored
+1
-1
@@ -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" />
|
||||
|
||||
Vendored
+1
@@ -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;
|
||||
|
||||
/**
|
||||
|
||||
@@ -1,6 +1,8 @@
|
||||
{
|
||||
"extends": "dtslint/dt.json",
|
||||
"rules": {
|
||||
"no-empty-interface": false
|
||||
// All are TODOs
|
||||
"no-empty-interface": false,
|
||||
"prefer-const": false
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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();
|
||||
});
|
||||
|
||||
Vendored
+1
-1
@@ -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
|
||||
|
||||
Vendored
+1
-1
@@ -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
|
||||
|
||||
|
||||
Vendored
+1
-1
@@ -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
|
||||
|
||||
|
||||
+1
-1
@@ -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
|
||||
|
||||
|
||||
Vendored
+1
-1
@@ -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' {
|
||||
|
||||
@@ -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'));
|
||||
});
|
||||
|
||||
+11
-6
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Vendored
+1
-1
@@ -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
|
||||
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
import * as ng from "angular";
|
||||
import * as angular from "angular";
|
||||
|
||||
import gridster from "angular-gridster";
|
||||
|
||||
Vendored
+6
-6
@@ -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;
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
Vendored
+1
-1
@@ -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" />
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
Vendored
+28
-28
@@ -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
|
||||
@@ -98,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
|
||||
@@ -111,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
|
||||
@@ -141,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;
|
||||
}
|
||||
|
||||
@@ -175,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'
|
||||
@@ -189,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;
|
||||
@@ -306,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 {
|
||||
@@ -366,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;
|
||||
}
|
||||
|
||||
@@ -407,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: {
|
||||
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
Vendored
+1
-1
@@ -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
|
||||
|
||||
|
||||
Vendored
+3
-3
@@ -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 {
|
||||
|
||||
+1
-1
@@ -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;
|
||||
|
||||
+1
-1
@@ -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
|
||||
|
||||
|
||||
@@ -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;
|
||||
|
||||
Vendored
+31
-31
@@ -1,6 +1,6 @@
|
||||
// Type definitions for Angular JS (ngResource module) 1.5
|
||||
// Project: http://angularjs.org
|
||||
// Definitions by: Diego Vilar <http://github.com/diegovilar>, Michael Jess <http://github.com/miffels>
|
||||
// Definitions by: Diego Vilar <https://github.com/diegovilar>, Michael Jess <https://github.com/miffels>
|
||||
// Definitions: https://github.com/daptiv/DefinitelyTyped
|
||||
// TypeScript Version: 2.3
|
||||
|
||||
@@ -74,10 +74,10 @@ declare module 'angular' {
|
||||
params?: any;
|
||||
url?: string;
|
||||
isArray?: boolean;
|
||||
transformRequest?: angular.IHttpRequestTransformer | angular.IHttpRequestTransformer[];
|
||||
transformResponse?: angular.IHttpResponseTransformer | angular.IHttpResponseTransformer[];
|
||||
transformRequest?: IHttpRequestTransformer | IHttpRequestTransformer[];
|
||||
transformResponse?: IHttpResponseTransformer | IHttpResponseTransformer[];
|
||||
headers?: any;
|
||||
cache?: boolean | angular.ICacheObject;
|
||||
cache?: boolean | ICacheObject;
|
||||
/**
|
||||
* Note: In contrast to $http.config, promises are not supported in $resource, because the same value
|
||||
* would be used for multiple requests. If you are looking for a way to cancel requests, you should
|
||||
@@ -118,15 +118,15 @@ declare module 'angular' {
|
||||
// it's gonna be considered data if the action method is POST, PUT or
|
||||
// PATCH (in other words, methods with body). Otherwise, it's going
|
||||
// to be considered as parameters to the request.
|
||||
// https://github.com/angular/angular.js/blob/v1.2.0/src/ngResource/resource.js#L461-L465
|
||||
// https://github.com/angular/js/blob/v1.2.0/src/ngResource/resource.js#L461-L465
|
||||
//
|
||||
// Only those methods with an HTTP body do have 'data' as first parameter:
|
||||
// https://github.com/angular/angular.js/blob/v1.2.0/src/ngResource/resource.js#L463
|
||||
// https://github.com/angular/js/blob/v1.2.0/src/ngResource/resource.js#L463
|
||||
// More specifically, those methods are POST, PUT and PATCH:
|
||||
// https://github.com/angular/angular.js/blob/v1.2.0/src/ngResource/resource.js#L432
|
||||
// https://github.com/angular/js/blob/v1.2.0/src/ngResource/resource.js#L432
|
||||
//
|
||||
// Also, static calls always return the IResource (or IResourceArray) retrieved
|
||||
// https://github.com/angular/angular.js/blob/v1.2.0/src/ngResource/resource.js#L538-L549
|
||||
// https://github.com/angular/js/blob/v1.2.0/src/ngResource/resource.js#L538-L549
|
||||
interface IResourceClass<T> {
|
||||
new(dataOrParams?: any): T & IResource<T>;
|
||||
get: IResourceMethod<T>;
|
||||
@@ -141,32 +141,32 @@ declare module 'angular' {
|
||||
}
|
||||
|
||||
// Instance calls always return the the promise of the request which retrieved the object
|
||||
// https://github.com/angular/angular.js/blob/v1.2.0/src/ngResource/resource.js#L538-L546
|
||||
// https://github.com/angular/js/blob/v1.2.0/src/ngResource/resource.js#L538-L546
|
||||
interface IResource<T> {
|
||||
$get(): angular.IPromise<T>;
|
||||
$get(params?: Object, success?: Function, error?: Function): angular.IPromise<T>;
|
||||
$get(success: Function, error?: Function): angular.IPromise<T>;
|
||||
$get(): IPromise<T>;
|
||||
$get(params?: Object, success?: Function, error?: Function): IPromise<T>;
|
||||
$get(success: Function, error?: Function): IPromise<T>;
|
||||
|
||||
$query(): angular.IPromise<IResourceArray<T>>;
|
||||
$query(params?: Object, success?: Function, error?: Function): angular.IPromise<IResourceArray<T>>;
|
||||
$query(success: Function, error?: Function): angular.IPromise<IResourceArray<T>>;
|
||||
$query(): IPromise<IResourceArray<T>>;
|
||||
$query(params?: Object, success?: Function, error?: Function): IPromise<IResourceArray<T>>;
|
||||
$query(success: Function, error?: Function): IPromise<IResourceArray<T>>;
|
||||
|
||||
$save(): angular.IPromise<T>;
|
||||
$save(params?: Object, success?: Function, error?: Function): angular.IPromise<T>;
|
||||
$save(success: Function, error?: Function): angular.IPromise<T>;
|
||||
$save(): IPromise<T>;
|
||||
$save(params?: Object, success?: Function, error?: Function): IPromise<T>;
|
||||
$save(success: Function, error?: Function): IPromise<T>;
|
||||
|
||||
$remove(): angular.IPromise<T>;
|
||||
$remove(params?: Object, success?: Function, error?: Function): angular.IPromise<T>;
|
||||
$remove(success: Function, error?: Function): angular.IPromise<T>;
|
||||
$remove(): IPromise<T>;
|
||||
$remove(params?: Object, success?: Function, error?: Function): IPromise<T>;
|
||||
$remove(success: Function, error?: Function): IPromise<T>;
|
||||
|
||||
$delete(): angular.IPromise<T>;
|
||||
$delete(params?: Object, success?: Function, error?: Function): angular.IPromise<T>;
|
||||
$delete(success: Function, error?: Function): angular.IPromise<T>;
|
||||
$delete(): IPromise<T>;
|
||||
$delete(params?: Object, success?: Function, error?: Function): IPromise<T>;
|
||||
$delete(success: Function, error?: Function): IPromise<T>;
|
||||
|
||||
$cancelRequest(): void;
|
||||
|
||||
/** The promise of the original server interaction that created this instance. */
|
||||
$promise: angular.IPromise<T>;
|
||||
$promise: IPromise<T>;
|
||||
$resolved: boolean;
|
||||
toJSON(): T;
|
||||
}
|
||||
@@ -178,18 +178,18 @@ declare module 'angular' {
|
||||
$cancelRequest(): void;
|
||||
|
||||
/** The promise of the original server interaction that created this collection. */
|
||||
$promise: angular.IPromise<IResourceArray<T>>;
|
||||
$promise: IPromise<IResourceArray<T>>;
|
||||
$resolved: boolean;
|
||||
}
|
||||
|
||||
/** when creating a resource factory via IModule.factory */
|
||||
interface IResourceServiceFactoryFunction<T> {
|
||||
($resource: angular.resource.IResourceService): IResourceClass<T>;
|
||||
<U extends IResourceClass<T>>($resource: angular.resource.IResourceService): U;
|
||||
($resource: IResourceService): IResourceClass<T>;
|
||||
<U extends IResourceClass<T>>($resource: IResourceService): U;
|
||||
}
|
||||
|
||||
// IResourceServiceProvider used to configure global settings
|
||||
interface IResourceServiceProvider extends angular.IServiceProvider {
|
||||
interface IResourceServiceProvider extends IServiceProvider {
|
||||
defaults: IResourceOptions;
|
||||
}
|
||||
}
|
||||
@@ -197,12 +197,12 @@ declare module 'angular' {
|
||||
/** extensions to base ng based on using angular-resource */
|
||||
interface IModule {
|
||||
/** creating a resource service factory */
|
||||
factory(name: string, resourceServiceFactoryFunction: angular.resource.IResourceServiceFactoryFunction<any>): IModule;
|
||||
factory(name: string, resourceServiceFactoryFunction: resource.IResourceServiceFactoryFunction<any>): IModule;
|
||||
}
|
||||
|
||||
namespace auto {
|
||||
interface IInjectorService {
|
||||
get(name: '$resource'): ng.resource.IResourceService;
|
||||
get(name: '$resource'): resource.IResourceService;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5,6 +5,7 @@
|
||||
"interface-name": false,
|
||||
"only-arrow-functions": false,
|
||||
"no-empty-interface": false,
|
||||
"no-object-literal-type-assertion": false,
|
||||
"ban-types": false,
|
||||
"space-before-function-paren": false,
|
||||
"unified-signatures": false
|
||||
|
||||
Vendored
+1
-1
@@ -1,6 +1,6 @@
|
||||
// Type definitions for Angular JS (ngSanitize module) 1.3
|
||||
// Project: http://angularjs.org
|
||||
// Definitions by: Diego Vilar <http://github.com/diegovilar>
|
||||
// Definitions by: Diego Vilar <https://github.com/diegovilar>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
// TypeScript Version: 2.3
|
||||
|
||||
|
||||
+2
-2
@@ -312,7 +312,7 @@ declare module 'angular' {
|
||||
openClass?: string;
|
||||
}
|
||||
|
||||
interface IModalProvider extends IServiceProvider {
|
||||
interface IModalProvider extends angular.IServiceProvider {
|
||||
/**
|
||||
* Default options all modals will use.
|
||||
*/
|
||||
@@ -876,7 +876,7 @@ declare module 'angular' {
|
||||
useContentExp?: boolean;
|
||||
}
|
||||
|
||||
interface ITooltipProvider extends IServiceProvider {
|
||||
interface ITooltipProvider extends angular.IServiceProvider {
|
||||
/**
|
||||
* Provide a set of defaults for certain tooltip and popover attributes.
|
||||
*/
|
||||
|
||||
@@ -1,28 +0,0 @@
|
||||
angular.module("test", [
|
||||
"ui.bootstrap",
|
||||
"ui.router",
|
||||
"ui.router.default"
|
||||
])
|
||||
.config(function($stateProvider: angular.ui.IStateProvider) {
|
||||
$stateProvider
|
||||
.state('contacts', {
|
||||
// no modal
|
||||
resolve: {
|
||||
a: function() {
|
||||
return "a";
|
||||
},
|
||||
b: function() {
|
||||
return ["a", "b"];
|
||||
}
|
||||
}
|
||||
})
|
||||
.state('contacts.contact', {
|
||||
// boolean modal
|
||||
modal: true
|
||||
})
|
||||
.state('contacts.contact.edit', {
|
||||
// string[] modal
|
||||
modal: ["a", "b"]
|
||||
})
|
||||
;
|
||||
});
|
||||
-15
@@ -1,15 +0,0 @@
|
||||
// Type definitions for angular-ui-uib-modal (ui.router module) 0.11
|
||||
// Project: https://github.com/nonplus/angular-ui-router-uib-modal
|
||||
// Definitions by: Stepan Riha <https://github.com/nonplus>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
// TypeScript Version: 2.3
|
||||
|
||||
import * as auir from "angular-ui-router";
|
||||
|
||||
declare module "angular" {
|
||||
namespace ui {
|
||||
interface IState {
|
||||
modal?: boolean | string[];
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -157,7 +157,7 @@ class UrlLocatorTestService implements IUrlLocatorTestService {
|
||||
|
||||
// Note that we do not concern ourselves with what to do if this request fails,
|
||||
// because if it fails, the web page will be redirected away to the login screen.
|
||||
this.$http({ url: "/api/me", method: "GET" }).then((response: ng.IHttpPromiseCallbackArg<any>) => {
|
||||
this.$http({ url: "/api/me", method: "GET" }).then((response: ng.IHttpResponse<any>) => {
|
||||
this.currentUser = response.data;
|
||||
|
||||
// sync the ui-state with the location in the browser, which effectively
|
||||
|
||||
+1
-1
@@ -1,7 +1,7 @@
|
||||
/* tslint:disable:dt-header variable-name */
|
||||
// Type definitions for Angular JS 1.5 component router
|
||||
// Project: http://angularjs.org
|
||||
// Definitions by: David Reher <http://github.com/davidreher>
|
||||
// Definitions by: David Reher <https://github.com/davidreher>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
|
||||
declare namespace angular {
|
||||
|
||||
@@ -61,31 +61,38 @@ angular.module('http-auth-interceptor', [])
|
||||
* $http interceptor.
|
||||
* On 401 response - it stores the request and broadcasts 'event:angular-auth-loginRequired'.
|
||||
*/
|
||||
.config(['$httpProvider', 'authServiceProvider', ($httpProvider: ng.IHttpProvider, authServiceProvider: any) => {
|
||||
$httpProvider.defaults.headers.common = {Authorization: 'Bearer token'};
|
||||
$httpProvider.defaults.headers.get['Authorization'] = 'Bearer token';
|
||||
$httpProvider.defaults.headers.post['Authorization'] = (config: ng.IRequestConfig) => 'Bearer token';
|
||||
.config([
|
||||
'$httpProvider', 'authServiceProvider',
|
||||
($httpProvider: ng.IHttpProvider, authServiceProvider: AuthService) => {
|
||||
$httpProvider.defaults.headers.common = { Authorization: 'Bearer token' };
|
||||
$httpProvider.defaults.headers.get.Authorization = 'Bearer token';
|
||||
$httpProvider.defaults.headers.post['Authorization'] = (config: ng.IRequestConfig) =>
|
||||
'Bearer token';
|
||||
|
||||
const interceptor = ['$rootScope', '$q', ($rootScope: ng.IScope, $q: ng.IQService) => {
|
||||
function success(response: ng.IHttpPromiseCallbackArg<any>) {
|
||||
return response;
|
||||
}
|
||||
|
||||
function error(response: ng.IHttpPromiseCallbackArg<any>) {
|
||||
if (response.status === 401) {
|
||||
const deferred = $q.defer<void>();
|
||||
authServiceProvider.pushToBuffer(response.config, deferred);
|
||||
$rootScope.$broadcast('event:auth-loginRequired');
|
||||
return deferred.promise;
|
||||
const interceptor = [
|
||||
'$rootScope', '$q',
|
||||
($rootScope: ng.IScope, $q: ng.IQService) => {
|
||||
return {
|
||||
request(config: ng.IRequestConfig) {
|
||||
if (!config.params) config.params = {};
|
||||
config.params.rnd = Math.random();
|
||||
return config;
|
||||
},
|
||||
responseError(rejection: any) {
|
||||
if (rejection.status === 401) {
|
||||
const deferred = $q.defer<ng.IHttpResponse<any>>();
|
||||
authServiceProvider.pushToBuffer(rejection.config, deferred);
|
||||
$rootScope.$broadcast('event:auth-loginRequired');
|
||||
return deferred.promise;
|
||||
}
|
||||
return $q.reject(rejection);
|
||||
}
|
||||
};
|
||||
}
|
||||
// otherwise
|
||||
return $q.reject(response);
|
||||
}
|
||||
|
||||
return (promise: ng.IHttpPromise<any>) => promise.then(success, error);
|
||||
}];
|
||||
$httpProvider.interceptors.push(interceptor);
|
||||
}]);
|
||||
];
|
||||
$httpProvider.interceptors.push(interceptor);
|
||||
}
|
||||
]);
|
||||
|
||||
namespace HttpAndRegularPromiseTests {
|
||||
interface Person {
|
||||
@@ -105,7 +112,7 @@ namespace HttpAndRegularPromiseTests {
|
||||
|
||||
function someController($scope: SomeControllerScope, $http: ng.IHttpService, $q: ng.IQService) {
|
||||
$http.get<ExpectedResponse>('http://somewhere/some/resource')
|
||||
.then((response: ng.IHttpPromiseCallbackArg<ExpectedResponse>) => {
|
||||
.then((response: ng.IHttpResponse<ExpectedResponse>) => {
|
||||
// typing lost, so something like
|
||||
// const i: number = response.data
|
||||
// would type check
|
||||
@@ -113,7 +120,7 @@ namespace HttpAndRegularPromiseTests {
|
||||
});
|
||||
|
||||
$http.get<ExpectedResponse>('http://somewhere/some/resource')
|
||||
.then((response: ng.IHttpPromiseCallbackArg<ExpectedResponse>) => {
|
||||
.then((response: ng.IHttpResponse<ExpectedResponse>) => {
|
||||
// typing lost, so something like
|
||||
// const i: number = response.data
|
||||
// would NOT type check
|
||||
@@ -339,12 +346,12 @@ namespace TestQ {
|
||||
result = $q.all<{a: number; b: string; }>({a: promiseAny, b: promiseAny});
|
||||
}
|
||||
{
|
||||
let result = $q.all({ num: $q.when(2), str: $q.when('test') });
|
||||
const result = $q.all({ num: $q.when(2), str: $q.when('test') });
|
||||
// TS should infer that num is a number and str is a string
|
||||
result.then(r => (r.num * 2) + r.str.indexOf('s'));
|
||||
}
|
||||
{
|
||||
let result = $q.all({ num: $q.when(2), str: 'test' });
|
||||
const result = $q.all({ num: $q.when(2), str: 'test' });
|
||||
// TS should infer that num is a number and str is a string
|
||||
result.then(r => (r.num * 2) + r.str.indexOf('s'));
|
||||
}
|
||||
@@ -378,7 +385,7 @@ namespace TestQ {
|
||||
let result: angular.IPromise<TResult>;
|
||||
result = $q.resolve<TResult>(tResult);
|
||||
result = $q.resolve<TResult>(promiseTResult);
|
||||
let result2: angular.IPromise<TResult | TOther> = $q.resolve<TResult | TOther>(Math.random() > 0.5 ? tResult : promiseTOther);
|
||||
const result2: angular.IPromise<TResult | TOther> = $q.resolve<TResult | TOther>(Math.random() > 0.5 ? tResult : promiseTOther);
|
||||
}
|
||||
|
||||
// $q.when
|
||||
@@ -388,7 +395,6 @@ namespace TestQ {
|
||||
}
|
||||
{
|
||||
let result: angular.IPromise<TResult>;
|
||||
let other: angular.IPromise<TOther>;
|
||||
let resultOther: angular.IPromise<TResult | TOther>;
|
||||
|
||||
result = $q.when<TResult>(tResult);
|
||||
@@ -427,7 +433,7 @@ httpFoo.then((x) => {
|
||||
x.toFixed();
|
||||
});
|
||||
|
||||
httpFoo.then((response: ng.IHttpPromiseCallbackArg<any>) => {
|
||||
httpFoo.then((response: ng.IHttpResponse<any>) => {
|
||||
const h = response.headers('test');
|
||||
h.charAt(0);
|
||||
const hs = response.headers();
|
||||
@@ -450,8 +456,8 @@ namespace TestDeferred {
|
||||
// deferred.resolve
|
||||
{
|
||||
let result: void;
|
||||
result = deferred.resolve() as void;
|
||||
result = deferred.resolve(tResult) as void;
|
||||
result = deferred.resolve();
|
||||
result = deferred.resolve(tResult);
|
||||
}
|
||||
|
||||
// deferred.reject
|
||||
@@ -488,7 +494,7 @@ namespace TestInjector {
|
||||
class Foobar {
|
||||
constructor($q) {}
|
||||
}
|
||||
let result: Foobar = $injector.instantiate(Foobar);
|
||||
const result: Foobar = $injector.instantiate(Foobar);
|
||||
}
|
||||
|
||||
// $injector.invoke
|
||||
@@ -496,14 +502,14 @@ namespace TestInjector {
|
||||
function foobar(v: boolean): number {
|
||||
return 7;
|
||||
}
|
||||
let result = $injector.invoke(foobar);
|
||||
const result = $injector.invoke(foobar);
|
||||
if (!(typeof result === 'number')) {
|
||||
// This fails to compile if 'result' is not exactly a number.
|
||||
let expectNever: never = result;
|
||||
const expectNever: never = result;
|
||||
}
|
||||
|
||||
let anyFunction: Function = foobar;
|
||||
let anyResult: string = $injector.invoke(anyFunction);
|
||||
const anyFunction: Function = foobar;
|
||||
const anyResult: string = $injector.invoke(anyFunction);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -566,7 +572,7 @@ namespace TestPromise {
|
||||
(reason) => anyOf3(reject, tresult, tresultPromise)
|
||||
));
|
||||
|
||||
assertPromiseType<ng.IHttpPromiseCallbackArg<TResult>>(promise.then((result) => tresultHttpPromise));
|
||||
assertPromiseType<ng.IHttpResponse<TResult>>(promise.then((result) => tresultHttpPromise));
|
||||
|
||||
assertPromiseType<TResult | TOther>(promise.then((result) => result, (any) => tother));
|
||||
assertPromiseType<TResult | angular.IPromise<TResult> | angular.IPromise<never> | TOther | angular.IPromise<TOther>>(promise.then(
|
||||
@@ -581,8 +587,8 @@ namespace TestPromise {
|
||||
assertPromiseType<TResult | TOther>(promise.then((result) => result, (any) => tother, (any) => any));
|
||||
assertPromiseType<TResult | TOther>(promise.then((result) => tresultPromise, (any) => totherPromise));
|
||||
assertPromiseType<TResult | TOther>(promise.then((result) => tresultPromise, (any) => totherPromise, (any) => any));
|
||||
assertPromiseType<ng.IHttpPromiseCallbackArg<TResult | TOther>>(promise.then((result) => tresultHttpPromise, (any) => totherHttpPromise));
|
||||
assertPromiseType<ng.IHttpPromiseCallbackArg<TResult | TOther>>(promise.then((result) => tresultHttpPromise, (any) => totherHttpPromise, (any) => any));
|
||||
assertPromiseType<ng.IHttpResponse<TResult | TOther>>(promise.then((result) => tresultHttpPromise, (any) => totherHttpPromise));
|
||||
assertPromiseType<ng.IHttpResponse<TResult | TOther>>(promise.then((result) => tresultHttpPromise, (any) => totherHttpPromise, (any) => any));
|
||||
|
||||
assertPromiseType<TOther>(promise.then((result) => tother));
|
||||
assertPromiseType<TOther>(promise.then((result) => tother, (any) => any));
|
||||
@@ -590,9 +596,9 @@ namespace TestPromise {
|
||||
assertPromiseType<TOther>(promise.then((result) => totherPromise));
|
||||
assertPromiseType<TOther>(promise.then((result) => totherPromise, (any) => any));
|
||||
assertPromiseType<TOther>(promise.then((result) => totherPromise, (any) => any, (any) => any));
|
||||
assertPromiseType<ng.IHttpPromiseCallbackArg<TOther>>(promise.then((result) => totherHttpPromise));
|
||||
assertPromiseType<ng.IHttpPromiseCallbackArg<TOther>>(promise.then((result) => totherHttpPromise, (any) => any));
|
||||
assertPromiseType<ng.IHttpPromiseCallbackArg<TOther>>(promise.then((result) => totherHttpPromise, (any) => any, (any) => any));
|
||||
assertPromiseType<ng.IHttpResponse<TOther>>(promise.then((result) => totherHttpPromise));
|
||||
assertPromiseType<ng.IHttpResponse<TOther>>(promise.then((result) => totherHttpPromise, (any) => any));
|
||||
assertPromiseType<ng.IHttpResponse<TOther>>(promise.then((result) => totherHttpPromise, (any) => any, (any) => any));
|
||||
|
||||
assertPromiseType<boolean>(promise.then((result) => tresult, (any) => tother).then(ambiguous => isTResult(ambiguous) ? ambiguous.c : ambiguous.f));
|
||||
|
||||
@@ -603,10 +609,10 @@ namespace TestPromise {
|
||||
assertPromiseType<TResult | angular.IPromise<never>>(promise.catch((err) => anyOf2(tresult, reject)));
|
||||
assertPromiseType<TResult>(promise.catch((err) => anyOf3(tresult, tresultPromise, reject)));
|
||||
assertPromiseType<TResult>(promise.catch((err) => tresultPromise));
|
||||
assertPromiseType<TResult | ng.IHttpPromiseCallbackArg<TResult>>(promise.catch((err) => tresultHttpPromise));
|
||||
assertPromiseType<TResult | ng.IHttpResponse<TResult>>(promise.catch((err) => tresultHttpPromise));
|
||||
assertPromiseType<TResult | TOther>(promise.catch((err) => tother));
|
||||
assertPromiseType<TResult | TOther>(promise.catch((err) => totherPromise));
|
||||
assertPromiseType<TResult | ng.IHttpPromiseCallbackArg<TOther>>(promise.catch((err) => totherHttpPromise));
|
||||
assertPromiseType<TResult | ng.IHttpResponse<TOther>>(promise.catch((err) => totherHttpPromise));
|
||||
|
||||
assertPromiseType<boolean>(promise.catch((err) => tother).then(ambiguous => isTResult(ambiguous) ? ambiguous.c : ambiguous.f));
|
||||
|
||||
@@ -621,7 +627,7 @@ function test_angular_forEach() {
|
||||
const log: string[] = [];
|
||||
angular.forEach(values, (value, key, obj) => {
|
||||
obj[key] = value;
|
||||
this.push(key + ': ' + value);
|
||||
this.push(`${key}: ${value}`);
|
||||
}, log);
|
||||
// expect(log).toEqual(['name: misko', 'gender: male']);
|
||||
}
|
||||
@@ -1160,11 +1166,7 @@ function NgModelControllerTyping() {
|
||||
ngModel.$asyncValidators['uniqueUsername'] = (modelValue, viewValue) => {
|
||||
const value = modelValue || viewValue;
|
||||
return $http.get('/api/users/' + value).
|
||||
then(function resolved() {
|
||||
return $q.reject('exists');
|
||||
}, function rejected() {
|
||||
return true;
|
||||
});
|
||||
then(() => $q.reject('exists'), () => true);
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
Vendored
+33
-26
@@ -1,7 +1,7 @@
|
||||
// Type definitions for Angular JS 1.6
|
||||
// Project: http://angularjs.org
|
||||
// Definitions by: Diego Vilar <http://github.com/diegovilar>
|
||||
// Georgii Dolzhykov <http://github.com/thorn0>
|
||||
// Definitions by: Diego Vilar <https://github.com/diegovilar>
|
||||
// Georgii Dolzhykov <https://github.com/thorn0>
|
||||
// Caleb St-Denis <https://github.com/calebstdenis>
|
||||
// Leonard Thieu <https://github.com/leonard-thieu>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
@@ -9,6 +9,9 @@
|
||||
|
||||
/// <reference path="jqlite.d.ts" />
|
||||
|
||||
// NOTE: @types/angular technically doesn't require TypeScript 2.3, only TypeScript 2.1.
|
||||
// It has a TypeScript 2.3 header so that merging tests with @types/jquery v3 will work.
|
||||
|
||||
declare var angular: angular.IAngularStatic;
|
||||
|
||||
// Support for painless dependency injection
|
||||
@@ -974,7 +977,7 @@ declare namespace angular {
|
||||
// DocumentService
|
||||
// see http://docs.angularjs.org/api/ng.$document
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
interface IDocumentService extends JQuery {
|
||||
interface IDocumentService extends JQLite {
|
||||
// Must return intersection type for index signature compatibility with JQuery
|
||||
[index: number]: HTMLElement & Document;
|
||||
}
|
||||
@@ -991,7 +994,7 @@ declare namespace angular {
|
||||
// RootElementService
|
||||
// see http://docs.angularjs.org/api/ng.$rootElement
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
interface IRootElementService extends JQuery {}
|
||||
interface IRootElementService extends JQLite {}
|
||||
|
||||
interface IQResolveReject<T> {
|
||||
(): void;
|
||||
@@ -1302,12 +1305,12 @@ declare namespace angular {
|
||||
|
||||
interface ICloneAttachFunction {
|
||||
// Let's hint but not force cloneAttachFn's signature
|
||||
(clonedElement?: JQuery, scope?: IScope): any;
|
||||
(clonedElement?: JQLite, scope?: IScope): any;
|
||||
}
|
||||
|
||||
// This corresponds to the "publicLinkFn" returned by $compile.
|
||||
interface ITemplateLinkingFunction {
|
||||
(scope: IScope, cloneAttachFn?: ICloneAttachFunction, options?: ITemplateLinkingFunctionOptions): JQuery;
|
||||
(scope: IScope, cloneAttachFn?: ICloneAttachFunction, options?: ITemplateLinkingFunctionOptions): JQLite;
|
||||
}
|
||||
|
||||
interface ITemplateLinkingFunctionOptions {
|
||||
@@ -1325,9 +1328,9 @@ declare namespace angular {
|
||||
*/
|
||||
interface ITranscludeFunction {
|
||||
// If the scope is provided, then the cloneAttachFn must be as well.
|
||||
(scope: IScope, cloneAttachFn: ICloneAttachFunction, futureParentElement?: JQuery, slotName?: string): JQuery;
|
||||
(scope: IScope, cloneAttachFn: ICloneAttachFunction, futureParentElement?: JQuery, slotName?: string): JQLite;
|
||||
// If one argument is provided, then it's assumed to be the cloneAttachFn.
|
||||
(cloneAttachFn?: ICloneAttachFunction, futureParentElement?: JQuery, slotName?: string): JQuery;
|
||||
(cloneAttachFn?: ICloneAttachFunction, futureParentElement?: JQuery, slotName?: string): JQLite;
|
||||
|
||||
/**
|
||||
* Returns true if the specified slot contains content (i.e. one or more DOM nodes)
|
||||
@@ -1520,23 +1523,27 @@ declare namespace angular {
|
||||
(data: T, status: number, headers: IHttpHeadersGetter, config: IRequestConfig): void;
|
||||
}
|
||||
|
||||
interface IHttpPromiseCallbackArg<T> {
|
||||
data?: T;
|
||||
status?: number;
|
||||
headers?: IHttpHeadersGetter;
|
||||
config?: IRequestConfig;
|
||||
statusText?: string;
|
||||
interface IHttpResponse<T> {
|
||||
data: T;
|
||||
status: number;
|
||||
headers: IHttpHeadersGetter;
|
||||
config: IRequestConfig;
|
||||
statusText: string;
|
||||
/** Added in AngularJS 1.6.6 */
|
||||
xhrStatus: 'complete' | 'error' | 'timeout' | 'abort';
|
||||
}
|
||||
|
||||
interface IHttpPromise<T> extends IPromise<IHttpPromiseCallbackArg<T>> {
|
||||
}
|
||||
/** @deprecated The old name of IHttpResponse. Kept for compatibility. */
|
||||
type IHttpPromiseCallbackArg<T> = IHttpResponse<T>;
|
||||
|
||||
type IHttpPromise<T> = IPromise<IHttpResponse<T>>;
|
||||
|
||||
// See the jsdoc for transformData() at https://github.com/angular/angular.js/blob/master/src/ng/http.js#L228
|
||||
interface IHttpRequestTransformer {
|
||||
(data: any, headersGetter: IHttpHeadersGetter): any;
|
||||
}
|
||||
|
||||
// The definition of fields are the same as IHttpPromiseCallbackArg
|
||||
// The definition of fields are the same as IHttpResponse
|
||||
interface IHttpResponseTransformer {
|
||||
(data: any, headersGetter: IHttpHeadersGetter, status: number): any;
|
||||
}
|
||||
@@ -1609,10 +1616,10 @@ declare namespace angular {
|
||||
}
|
||||
|
||||
interface IHttpInterceptor {
|
||||
request?(config: IRequestConfig): IRequestConfig|IPromise<IRequestConfig>;
|
||||
requestError?(rejection: any): any;
|
||||
response?<T>(response: IHttpPromiseCallbackArg<T>): IPromise<IHttpPromiseCallbackArg<T>>|IHttpPromiseCallbackArg<T>;
|
||||
responseError?(rejection: any): any;
|
||||
request?(config: IRequestConfig): IRequestConfig | IPromise<IRequestConfig>;
|
||||
requestError?(rejection: any): IRequestConfig | IPromise<IRequestConfig>;
|
||||
response?<T>(response: IHttpResponse<T>): IPromise<IHttpResponse<T>> | IHttpResponse<T>;
|
||||
responseError?<T>(rejection: any): IPromise<IHttpResponse<T>> | IHttpResponse<T>;
|
||||
}
|
||||
|
||||
interface IHttpInterceptorFactory {
|
||||
@@ -1962,7 +1969,7 @@ declare namespace angular {
|
||||
interface IDirectiveLinkFn {
|
||||
(
|
||||
scope: IScope,
|
||||
instanceElement: JQuery,
|
||||
instanceElement: JQLite,
|
||||
instanceAttributes: IAttributes,
|
||||
controller?: IController | IController[] | {[key: string]: IController},
|
||||
transclude?: ITranscludeFunction
|
||||
@@ -1976,7 +1983,7 @@ declare namespace angular {
|
||||
|
||||
interface IDirectiveCompileFn {
|
||||
(
|
||||
templateElement: JQuery,
|
||||
templateElement: JQLite,
|
||||
templateAttributes: IAttributes,
|
||||
/**
|
||||
* @deprecated
|
||||
@@ -2008,9 +2015,9 @@ declare namespace angular {
|
||||
require?: string | string[] | {[controller: string]: string};
|
||||
restrict?: string;
|
||||
scope?: boolean | {[boundProperty: string]: string};
|
||||
template?: string | ((tElement: JQuery, tAttrs: IAttributes) => string);
|
||||
template?: string | ((tElement: JQLite, tAttrs: IAttributes) => string);
|
||||
templateNamespace?: string;
|
||||
templateUrl?: string | ((tElement: JQuery, tAttrs: IAttributes) => string);
|
||||
templateUrl?: string | ((tElement: JQLite, tAttrs: IAttributes) => string);
|
||||
terminal?: boolean;
|
||||
transclude?: boolean | 'element' | {[slot: string]: string};
|
||||
}
|
||||
@@ -2023,7 +2030,7 @@ declare namespace angular {
|
||||
* See: http://docs.angularjs.org/api/angular.element
|
||||
*/
|
||||
interface IAugmentedJQueryStatic extends JQueryStatic {}
|
||||
interface IAugmentedJQuery extends JQuery {}
|
||||
interface IAugmentedJQuery extends JQLite {}
|
||||
|
||||
/**
|
||||
* Same as IController. Keeping it for compatibility with older versions of these type definitions.
|
||||
|
||||
Vendored
+77
-73
@@ -25,6 +25,10 @@
|
||||
|
||||
// Definitions copied from https://github.com/DefinitelyTyped/DefinitelyTyped/blob/0480c5ec87fab41aa23047a02b27f0ea71aaf975/types/jquery/v2/index.d.ts
|
||||
|
||||
interface JQLite extends JQuery {
|
||||
[index: number]: HTMLElement;
|
||||
}
|
||||
|
||||
interface JQuery {
|
||||
/**
|
||||
* Adds the specified class(es) to each of the set of matched elements.
|
||||
@@ -32,7 +36,7 @@ interface JQuery {
|
||||
* @param className One or more space-separated classes to be added to the class attribute of each matched element.
|
||||
* @see {@link https://api.jquery.com/addClass/#addClass-className}
|
||||
*/
|
||||
addClass(className: string): JQuery;
|
||||
addClass(className: string): this;
|
||||
|
||||
/**
|
||||
* Insert content, specified by the parameter, after each element in the set of matched elements.
|
||||
@@ -41,14 +45,14 @@ interface JQuery {
|
||||
* @param content2 One or more additional DOM elements, arrays of elements, HTML strings, or jQuery objects to insert after each element in the set of matched elements.
|
||||
* @see {@link https://api.jquery.com/after/#after-content-content}
|
||||
*/
|
||||
after(content1: JQuery | any[] | Element | DocumentFragment | Text | string, ...content2: any[]): JQuery;
|
||||
after(content1: JQuery | any[] | Element | DocumentFragment | Text | string, ...content2: any[]): this;
|
||||
/**
|
||||
* Insert content, specified by the parameter, after each element in the set of matched elements.
|
||||
*
|
||||
* @param func A function that returns an HTML string, DOM element(s), or jQuery object to insert after each element in the set of matched elements. Receives the index position of the element in the set as an argument. Within the function, this refers to the current element in the set.
|
||||
* @see {@link https://api.jquery.com/after/#after-function}
|
||||
*/
|
||||
after(func: (index: number, html: string) => string | Element | JQuery): JQuery;
|
||||
after(func: (index: number, html: string) => string | Element | JQuery): this;
|
||||
|
||||
/**
|
||||
* Insert content, specified by the parameter, to the end of each element in the set of matched elements.
|
||||
@@ -57,14 +61,14 @@ interface JQuery {
|
||||
* @param content2 One or more additional DOM elements, arrays of elements, HTML strings, or jQuery objects to insert at the end of each element in the set of matched elements.
|
||||
* @see {@link https://api.jquery.com/append/#append-content-content}
|
||||
*/
|
||||
append(content1: JQuery | any[] | Element | DocumentFragment | Text | string, ...content2: any[]): JQuery;
|
||||
append(content1: JQuery | any[] | Element | DocumentFragment | Text | string, ...content2: any[]): this;
|
||||
/**
|
||||
* Insert content, specified by the parameter, to the end of each element in the set of matched elements.
|
||||
*
|
||||
* @param func A function that returns an HTML string, DOM element(s), or jQuery object to insert at the end of each element in the set of matched elements. Receives the index position of the element in the set and the old HTML value of the element as arguments. Within the function, this refers to the current element in the set.
|
||||
* @see {@link https://api.jquery.com/append/#append-function}
|
||||
*/
|
||||
append(func: (index: number, html: string) => string | Element | JQuery): JQuery;
|
||||
append(func: (index: number, html: string) => string | Element | JQuery): this;
|
||||
|
||||
/**
|
||||
* Get the value of an attribute for the first element in the set of matched elements.
|
||||
@@ -80,14 +84,14 @@ interface JQuery {
|
||||
* @param value A value to set for the attribute. If this is `null`, the attribute will be deleted.
|
||||
* @see {@link https://api.jquery.com/attr/#attr-attributeName-value}
|
||||
*/
|
||||
attr(attributeName: string, value: string | number | null): JQuery;
|
||||
attr(attributeName: string, value: string | number | null): this;
|
||||
/**
|
||||
* Set one or more attributes for the set of matched elements.
|
||||
*
|
||||
* @param attributes An object of attribute-value pairs to set.
|
||||
* @see {@link https://api.jquery.com/attr/#attr-attributes}
|
||||
*/
|
||||
attr(attributes: Object): JQuery;
|
||||
attr(attributes: Object): this;
|
||||
|
||||
/**
|
||||
* Attach a handler to an event for the elements.
|
||||
@@ -96,7 +100,7 @@ interface JQuery {
|
||||
* @param handler A function to execute each time the event is triggered.
|
||||
* @see {@link https://api.jquery.com/bind/#bind-eventType-eventData-handler}
|
||||
*/
|
||||
bind(eventType: string, handler: (eventObject: JQueryEventObject) => any): JQuery;
|
||||
bind(eventType: string, handler: (eventObject: JQueryEventObject) => any): this;
|
||||
/**
|
||||
* Attach a handler to an event for the elements.
|
||||
*
|
||||
@@ -104,21 +108,21 @@ interface JQuery {
|
||||
* @param preventBubble Setting the third argument to false will attach a function that prevents the default action from occurring and stops the event from bubbling. The default is true.
|
||||
* @see {@link https://api.jquery.com/bind/#bind-eventType-eventData-preventBubble}
|
||||
*/
|
||||
bind(eventType: string, preventBubble: boolean): JQuery;
|
||||
bind(eventType: string, preventBubble: boolean): this;
|
||||
/**
|
||||
* Attach a handler to an event for the elements.
|
||||
*
|
||||
* @param events An object containing one or more DOM event types and functions to execute for them.
|
||||
* @see {@link https://api.jquery.com/bind/#bind-events}
|
||||
*/
|
||||
bind(events: any): JQuery;
|
||||
bind(events: any): this;
|
||||
|
||||
/**
|
||||
* Get the children of each element in the set of matched elements, optionally filtered by a selector.
|
||||
*
|
||||
* @see {@link https://api.jquery.com/children/}
|
||||
*/
|
||||
children(): JQuery;
|
||||
children(): this;
|
||||
|
||||
/**
|
||||
* Create a deep copy of the set of matched elements.
|
||||
@@ -127,13 +131,13 @@ interface JQuery {
|
||||
* @param deepWithDataAndEvents A Boolean indicating whether event handlers and data for all children of the cloned element should be copied. By default its value matches the first argument's value (which defaults to false).
|
||||
* @see {@link https://api.jquery.com/clone/}
|
||||
*/
|
||||
clone(withDataAndEvents?: boolean, deepWithDataAndEvents?: boolean): JQuery;
|
||||
clone(withDataAndEvents?: boolean, deepWithDataAndEvents?: boolean): this;
|
||||
|
||||
/**
|
||||
* Get the children of each element in the set of matched elements, including text and comment nodes.
|
||||
* @see {@link https://api.jquery.com/contents/}
|
||||
*/
|
||||
contents(): JQuery;
|
||||
contents(): this;
|
||||
|
||||
/**
|
||||
* Get the value of style properties for the first element in the set of matched elements.
|
||||
@@ -157,7 +161,7 @@ interface JQuery {
|
||||
* @param value A value to set for the property.
|
||||
* @see {@link https://api.jquery.com/css/#css-propertyName-value}
|
||||
*/
|
||||
css(propertyName: string, value: string | number): JQuery;
|
||||
css(propertyName: string, value: string | number): this;
|
||||
/**
|
||||
* Set one or more CSS properties for the set of matched elements.
|
||||
*
|
||||
@@ -165,14 +169,14 @@ interface JQuery {
|
||||
* @param value A function returning the value to set. this is the current element. Receives the index position of the element in the set and the old value as arguments.
|
||||
* @see {@link https://api.jquery.com/css/#css-propertyName-function}
|
||||
*/
|
||||
css(propertyName: string, value: (index: number, value: string) => string | number): JQuery;
|
||||
css(propertyName: string, value: (index: number, value: string) => string | number): this;
|
||||
/**
|
||||
* Set one or more CSS properties for the set of matched elements.
|
||||
*
|
||||
* @param properties An object of property-value pairs to set.
|
||||
* @see {@link https://api.jquery.com/css/#css-properties}
|
||||
*/
|
||||
css(properties: JQLiteCssProperties): JQuery;
|
||||
css(properties: JQLiteCssProperties): this;
|
||||
|
||||
/**
|
||||
* Store arbitrary data associated with the matched elements.
|
||||
@@ -181,7 +185,7 @@ interface JQuery {
|
||||
* @param value The new data value; it can be any JavaScript type including Array or Object.
|
||||
* @see {@link https://api.jquery.com/data/#data-key-value}
|
||||
*/
|
||||
data(key: string, value: any): JQuery;
|
||||
data(key: string, value: any): this;
|
||||
/**
|
||||
* Return the value at the named data store for the first element in the jQuery collection, as set by data(name, value) or by an HTML5 data-* attribute.
|
||||
*
|
||||
@@ -195,7 +199,7 @@ interface JQuery {
|
||||
* @param obj An object of key-value pairs of data to update.
|
||||
* @see {@link https://api.jquery.com/data/#data-obj}
|
||||
*/
|
||||
data(obj: { [key: string]: any; }): JQuery;
|
||||
data(obj: { [key: string]: any; }): this;
|
||||
/**
|
||||
* Return the value at the named data store for the first element in the jQuery collection, as set by data(name, value) or by an HTML5 data-* attribute.
|
||||
* @see {@link https://api.jquery.com/data/#data}
|
||||
@@ -208,13 +212,13 @@ interface JQuery {
|
||||
* @param selector A selector expression that filters the set of matched elements to be removed.
|
||||
* @see {@link https://api.jquery.com/detach/}
|
||||
*/
|
||||
detach(selector?: string): JQuery;
|
||||
detach(selector?: string): this;
|
||||
|
||||
/**
|
||||
* Remove all child nodes of the set of matched elements from the DOM.
|
||||
* @see {@link https://api.jquery.com/empty/}
|
||||
*/
|
||||
empty(): JQuery;
|
||||
empty(): this;
|
||||
|
||||
/**
|
||||
* Reduce the set of matched elements to the one at the specified index.
|
||||
@@ -222,7 +226,7 @@ interface JQuery {
|
||||
* @param index An integer indicating the 0-based position of the element. OR An integer indicating the position of the element, counting backwards from the last element in the set.
|
||||
* @see {@link https://api.jquery.com/eq/}
|
||||
*/
|
||||
eq(index: number): JQuery;
|
||||
eq(index: number): this;
|
||||
|
||||
/**
|
||||
* Get the descendants of each element in the current set of matched elements, filtered by a selector, jQuery object, or element.
|
||||
@@ -230,9 +234,9 @@ interface JQuery {
|
||||
* @param selector A string containing a selector expression to match elements against.
|
||||
* @see {@link https://api.jquery.com/find/#find-selector}
|
||||
*/
|
||||
find(selector: string): JQuery;
|
||||
find(element: any): JQuery;
|
||||
find(obj: JQuery): JQuery;
|
||||
find(selector: string): this;
|
||||
find(element: any): this;
|
||||
find(obj: JQuery): this;
|
||||
|
||||
/**
|
||||
* Determine whether any of the matched elements are assigned the given class.
|
||||
@@ -253,21 +257,21 @@ interface JQuery {
|
||||
* @param htmlString A string of HTML to set as the content of each matched element.
|
||||
* @see {@link https://api.jquery.com/html/#html-htmlString}
|
||||
*/
|
||||
html(htmlString: string): JQuery;
|
||||
html(htmlString: string): this;
|
||||
/**
|
||||
* Set the HTML contents of each element in the set of matched elements.
|
||||
*
|
||||
* @param func A function returning the HTML content to set. Receives the index position of the element in the set and the old HTML value as arguments. jQuery empties the element before calling the function; use the oldhtml argument to reference the previous content. Within the function, this refers to the current element in the set.
|
||||
* @see {@link https://api.jquery.com/html/#html-function}
|
||||
*/
|
||||
html(func: (index: number, oldhtml: string) => string): JQuery;
|
||||
html(func: (index: number, oldhtml: string) => string): this;
|
||||
|
||||
/**
|
||||
* Get the immediately following sibling of each element in the set of matched elements. If a selector is provided, it retrieves the next sibling only if it matches that selector.
|
||||
*
|
||||
* @see {@link https://api.jquery.com/next/}
|
||||
*/
|
||||
next(): JQuery;
|
||||
next(): this;
|
||||
|
||||
/**
|
||||
* Attach an event handler function for one or more events to the selected elements.
|
||||
@@ -276,7 +280,7 @@ interface JQuery {
|
||||
* @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand for a function that simply does return false. Rest parameter args is for optional parameters passed to jQuery.trigger(). Note that the actual parameters on the event handler function must be marked as optional (? syntax).
|
||||
* @see {@link https://api.jquery.com/on/#on-events-selector-data-handler}
|
||||
*/
|
||||
on(events: string, handler: (eventObject: JQueryEventObject, ...args: any[]) => any): JQuery;
|
||||
on(events: string, handler: (eventObject: JQueryEventObject, ...args: any[]) => any): this;
|
||||
/**
|
||||
* Attach an event handler function for one or more events to the selected elements.
|
||||
*
|
||||
@@ -285,7 +289,7 @@ interface JQuery {
|
||||
* @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand for a function that simply does return false.
|
||||
* @see {@link https://api.jquery.com/on/#on-events-selector-data-handler}
|
||||
*/
|
||||
on(events: string, data: any, handler: (eventObject: JQueryEventObject, ...args: any[]) => any): JQuery;
|
||||
on(events: string, data: any, handler: (eventObject: JQueryEventObject, ...args: any[]) => any): this;
|
||||
/**
|
||||
* Attach an event handler function for one or more events to the selected elements.
|
||||
*
|
||||
@@ -294,7 +298,7 @@ interface JQuery {
|
||||
* @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand for a function that simply does return false.
|
||||
* @see {@link https://api.jquery.com/on/#on-events-selector-data-handler}
|
||||
*/
|
||||
on(events: string, selector: string, handler: (eventObject: JQueryEventObject, ...eventData: any[]) => any): JQuery;
|
||||
on(events: string, selector: string, handler: (eventObject: JQueryEventObject, ...eventData: any[]) => any): this;
|
||||
/**
|
||||
* Attach an event handler function for one or more events to the selected elements.
|
||||
*
|
||||
@@ -304,7 +308,7 @@ interface JQuery {
|
||||
* @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand for a function that simply does return false.
|
||||
* @see {@link https://api.jquery.com/on/#on-events-selector-data-handler}
|
||||
*/
|
||||
on(events: string, selector: string, data: any, handler: (eventObject: JQueryEventObject, ...eventData: any[]) => any): JQuery;
|
||||
on(events: string, selector: string, data: any, handler: (eventObject: JQueryEventObject, ...eventData: any[]) => any): this;
|
||||
/**
|
||||
* Attach an event handler function for one or more events to the selected elements.
|
||||
*
|
||||
@@ -313,7 +317,7 @@ interface JQuery {
|
||||
* @param data Data to be passed to the handler in event.data when an event occurs.
|
||||
* @see {@link https://api.jquery.com/on/#on-events-selector-data}
|
||||
*/
|
||||
on(events: { [key: string]: (eventObject: JQueryEventObject, ...args: any[]) => any; }, selector?: string, data?: any): JQuery;
|
||||
on(events: { [key: string]: (eventObject: JQueryEventObject, ...args: any[]) => any; }, selector?: string, data?: any): this;
|
||||
/**
|
||||
* Attach an event handler function for one or more events to the selected elements.
|
||||
*
|
||||
@@ -321,13 +325,13 @@ interface JQuery {
|
||||
* @param data Data to be passed to the handler in event.data when an event occurs.
|
||||
* @see {@link https://api.jquery.com/on/#on-events-selector-data}
|
||||
*/
|
||||
on(events: { [key: string]: (eventObject: JQueryEventObject, ...args: any[]) => any; }, data?: any): JQuery;
|
||||
on(events: { [key: string]: (eventObject: JQueryEventObject, ...args: any[]) => any; }, data?: any): this;
|
||||
|
||||
/**
|
||||
* Remove an event handler.
|
||||
* @see {@link https://api.jquery.com/off/#off}
|
||||
*/
|
||||
off(): JQuery;
|
||||
off(): this;
|
||||
/**
|
||||
* Remove an event handler.
|
||||
*
|
||||
@@ -336,7 +340,7 @@ interface JQuery {
|
||||
* @param handler A handler function previously attached for the event(s), or the special value false.
|
||||
* @see {@link https://api.jquery.com/off/#off-events-selector-handler}
|
||||
*/
|
||||
off(events: string, selector?: string, handler?: (eventObject: JQueryEventObject) => any): JQuery;
|
||||
off(events: string, selector?: string, handler?: (eventObject: JQueryEventObject) => any): this;
|
||||
/**
|
||||
* Remove an event handler.
|
||||
*
|
||||
@@ -344,7 +348,7 @@ interface JQuery {
|
||||
* @param handler A handler function previously attached for the event(s), or the special value false. Takes handler with extra args that can be attached with on().
|
||||
* @see {@link https://api.jquery.com/off/#off-events-selector-handler}
|
||||
*/
|
||||
off(events: string, handler: (eventObject: JQueryEventObject, ...args: any[]) => any): JQuery;
|
||||
off(events: string, handler: (eventObject: JQueryEventObject, ...args: any[]) => any): this;
|
||||
/**
|
||||
* Remove an event handler.
|
||||
*
|
||||
@@ -352,7 +356,7 @@ interface JQuery {
|
||||
* @param handler A handler function previously attached for the event(s), or the special value false.
|
||||
* @see {@link https://api.jquery.com/off/#off-events-selector-handler}
|
||||
*/
|
||||
off(events: string, handler: (eventObject: JQueryEventObject) => any): JQuery;
|
||||
off(events: string, handler: (eventObject: JQueryEventObject) => any): this;
|
||||
/**
|
||||
* Remove an event handler.
|
||||
*
|
||||
@@ -360,7 +364,7 @@ interface JQuery {
|
||||
* @param selector A selector which should match the one originally passed to .on() when attaching event handlers.
|
||||
* @see {@link https://api.jquery.com/off/#off-events-selector}
|
||||
*/
|
||||
off(events: { [key: string]: any; }, selector?: string): JQuery;
|
||||
off(events: { [key: string]: any; }, selector?: string): this;
|
||||
|
||||
/**
|
||||
* Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
|
||||
@@ -369,7 +373,7 @@ interface JQuery {
|
||||
* @param handler A function to execute at the time the event is triggered.
|
||||
* @see {@link https://api.jquery.com/one/#one-events-data-handler}
|
||||
*/
|
||||
one(events: string, handler: (eventObject: JQueryEventObject) => any): JQuery;
|
||||
one(events: string, handler: (eventObject: JQueryEventObject) => any): this;
|
||||
/**
|
||||
* Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
|
||||
*
|
||||
@@ -378,7 +382,7 @@ interface JQuery {
|
||||
* @param handler A function to execute at the time the event is triggered.
|
||||
* @see {@link https://api.jquery.com/one/#one-events-data-handler}
|
||||
*/
|
||||
one(events: string, data: Object, handler: (eventObject: JQueryEventObject) => any): JQuery;
|
||||
one(events: string, data: Object, handler: (eventObject: JQueryEventObject) => any): this;
|
||||
/**
|
||||
* Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
|
||||
*
|
||||
@@ -387,7 +391,7 @@ interface JQuery {
|
||||
* @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand for a function that simply does return false.
|
||||
* @see {@link https://api.jquery.com/one/#one-events-selector-data-handler}
|
||||
*/
|
||||
one(events: string, selector: string, handler: (eventObject: JQueryEventObject) => any): JQuery;
|
||||
one(events: string, selector: string, handler: (eventObject: JQueryEventObject) => any): this;
|
||||
/**
|
||||
* Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
|
||||
*
|
||||
@@ -397,7 +401,7 @@ interface JQuery {
|
||||
* @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand for a function that simply does return false.
|
||||
* @see {@link https://api.jquery.com/one/#one-events-selector-data-handler}
|
||||
*/
|
||||
one(events: string, selector: string, data: any, handler: (eventObject: JQueryEventObject) => any): JQuery;
|
||||
one(events: string, selector: string, data: any, handler: (eventObject: JQueryEventObject) => any): this;
|
||||
/**
|
||||
* Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
|
||||
*
|
||||
@@ -406,7 +410,7 @@ interface JQuery {
|
||||
* @param data Data to be passed to the handler in event.data when an event occurs.
|
||||
* @see {@link https://api.jquery.com/one/#one-events-selector-data}
|
||||
*/
|
||||
one(events: { [key: string]: any; }, selector?: string, data?: any): JQuery;
|
||||
one(events: { [key: string]: any; }, selector?: string, data?: any): this;
|
||||
/**
|
||||
* Attach a handler to an event for the elements. The handler is executed at most once per element per event type.
|
||||
*
|
||||
@@ -414,14 +418,14 @@ interface JQuery {
|
||||
* @param data Data to be passed to the handler in event.data when an event occurs.
|
||||
* @see {@link https://api.jquery.com/one/#one-events-selector-data}
|
||||
*/
|
||||
one(events: { [key: string]: any; }, data?: any): JQuery;
|
||||
one(events: { [key: string]: any; }, data?: any): this;
|
||||
|
||||
/**
|
||||
* Get the parent of each element in the current set of matched elements, optionally filtered by a selector.
|
||||
*
|
||||
* @see {@link https://api.jquery.com/parent/}
|
||||
*/
|
||||
parent(): JQuery;
|
||||
parent(): this;
|
||||
|
||||
/**
|
||||
* Insert content, specified by the parameter, to the beginning of each element in the set of matched elements.
|
||||
@@ -430,14 +434,14 @@ interface JQuery {
|
||||
* @param content2 One or more additional DOM elements, arrays of elements, HTML strings, or jQuery objects to insert at the beginning of each element in the set of matched elements.
|
||||
* @see {@link https://api.jquery.com/prepend/#prepend-content-content}
|
||||
*/
|
||||
prepend(content1: JQuery | any[] | Element | DocumentFragment | Text | string, ...content2: any[]): JQuery;
|
||||
prepend(content1: JQuery | any[] | Element | DocumentFragment | Text | string, ...content2: any[]): this;
|
||||
/**
|
||||
* Insert content, specified by the parameter, to the beginning of each element in the set of matched elements.
|
||||
*
|
||||
* @param func A function that returns an HTML string, DOM element(s), or jQuery object to insert at the beginning of each element in the set of matched elements. Receives the index position of the element in the set and the old HTML value of the element as arguments. Within the function, this refers to the current element in the set.
|
||||
* @see {@link https://api.jquery.com/prepend/#prepend-function}
|
||||
*/
|
||||
prepend(func: (index: number, html: string) => string | Element | JQuery): JQuery;
|
||||
prepend(func: (index: number, html: string) => string | Element | JQuery): this;
|
||||
|
||||
/**
|
||||
* Get the value of a property for the first element in the set of matched elements.
|
||||
@@ -453,14 +457,14 @@ interface JQuery {
|
||||
* @param value A value to set for the property.
|
||||
* @see {@link https://api.jquery.com/prop/#prop-propertyName-value}
|
||||
*/
|
||||
prop(propertyName: string, value: string | number | boolean): JQuery;
|
||||
prop(propertyName: string, value: string | number | boolean): this;
|
||||
/**
|
||||
* Set one or more properties for the set of matched elements.
|
||||
*
|
||||
* @param properties An object of property-value pairs to set.
|
||||
* @see {@link https://api.jquery.com/prop/#prop-properties}
|
||||
*/
|
||||
prop(properties: Object): JQuery;
|
||||
prop(properties: Object): this;
|
||||
/**
|
||||
* Set one or more properties for the set of matched elements.
|
||||
*
|
||||
@@ -468,7 +472,7 @@ interface JQuery {
|
||||
* @param func A function returning the value to set. Receives the index position of the element in the set and the old property value as arguments. Within the function, the keyword this refers to the current element.
|
||||
* @see {@link https://api.jquery.com/prop/#prop-propertyName-function}
|
||||
*/
|
||||
prop(propertyName: string, func: (index: number, oldPropertyValue: any) => any): JQuery;
|
||||
prop(propertyName: string, func: (index: number, oldPropertyValue: any) => any): this;
|
||||
|
||||
/**
|
||||
* Specify a function to execute when the DOM is fully loaded.
|
||||
@@ -476,7 +480,7 @@ interface JQuery {
|
||||
* @param handler A function to execute after the DOM is ready.
|
||||
* @see {@link https://api.jquery.com/ready/}
|
||||
*/
|
||||
ready(handler: (jQueryAlias?: JQueryStatic) => any): JQuery;
|
||||
ready(handler: (jQueryAlias?: JQueryStatic) => any): this;
|
||||
|
||||
/**
|
||||
* Remove the set of matched elements from the DOM.
|
||||
@@ -484,7 +488,7 @@ interface JQuery {
|
||||
* @param selector A selector expression that filters the set of matched elements to be removed.
|
||||
* @see {@link https://api.jquery.com/remove/}
|
||||
*/
|
||||
remove(selector?: string): JQuery;
|
||||
remove(selector?: string): this;
|
||||
|
||||
/**
|
||||
* Remove an attribute from each element in the set of matched elements.
|
||||
@@ -492,7 +496,7 @@ interface JQuery {
|
||||
* @param attributeName An attribute to remove; as of version 1.7, it can be a space-separated list of attributes.
|
||||
* @see {@link https://api.jquery.com/removeAttr/}
|
||||
*/
|
||||
removeAttr(attributeName: string): JQuery;
|
||||
removeAttr(attributeName: string): this;
|
||||
|
||||
/**
|
||||
* Remove a single class, multiple classes, or all classes from each element in the set of matched elements.
|
||||
@@ -500,7 +504,7 @@ interface JQuery {
|
||||
* @param className One or more space-separated classes to be removed from the class attribute of each matched element.
|
||||
* @see {@link https://api.jquery.com/removeClass/#removeClass-className}
|
||||
*/
|
||||
removeClass(className?: string): JQuery;
|
||||
removeClass(className?: string): this;
|
||||
|
||||
/**
|
||||
* Remove a previously-stored piece of data.
|
||||
@@ -508,19 +512,19 @@ interface JQuery {
|
||||
* @param name A string naming the piece of data to delete or space-separated string naming the pieces of data to delete.
|
||||
* @see {@link https://api.jquery.com/removeData/#removeData-name}
|
||||
*/
|
||||
removeData(name: string): JQuery;
|
||||
removeData(name: string): this;
|
||||
/**
|
||||
* Remove a previously-stored piece of data.
|
||||
*
|
||||
* @param list An array of strings naming the pieces of data to delete.
|
||||
* @see {@link https://api.jquery.com/removeData/#removeData-list}
|
||||
*/
|
||||
removeData(list: string[]): JQuery;
|
||||
removeData(list: string[]): this;
|
||||
/**
|
||||
* Remove all previously-stored piece of data.
|
||||
* @see {@link https://api.jquery.com/removeData/}
|
||||
*/
|
||||
removeData(): JQuery;
|
||||
removeData(): this;
|
||||
|
||||
/**
|
||||
* Replace each element in the set of matched elements with the provided new content and return the set of elements that was removed.
|
||||
@@ -528,14 +532,14 @@ interface JQuery {
|
||||
* @param newContent The content to insert. May be an HTML string, DOM element, array of DOM elements, or jQuery object.
|
||||
* @see {@link https://api.jquery.com/replaceWith/#replaceWith-newContent}
|
||||
*/
|
||||
replaceWith(newContent: JQuery | any[] | Element | Text | string): JQuery;
|
||||
replaceWith(newContent: JQuery | any[] | Element | Text | string): this;
|
||||
/**
|
||||
* Replace each element in the set of matched elements with the provided new content and return the set of elements that was removed.
|
||||
*
|
||||
* @param func A function that returns content with which to replace the set of matched elements.
|
||||
* @see {@link https://api.jquery.com/replaceWith/#replaceWith-function}
|
||||
*/
|
||||
replaceWith(func: () => Element | JQuery): JQuery;
|
||||
replaceWith(func: () => Element | JQuery): this;
|
||||
|
||||
/**
|
||||
* Get the combined text contents of each element in the set of matched elements, including their descendants.
|
||||
@@ -548,14 +552,14 @@ interface JQuery {
|
||||
* @param text The text to set as the content of each matched element. When Number or Boolean is supplied, it will be converted to a String representation.
|
||||
* @see {@link https://api.jquery.com/text/#text-text}
|
||||
*/
|
||||
text(text: string | number | boolean): JQuery;
|
||||
text(text: string | number | boolean): this;
|
||||
/**
|
||||
* Set the content of each element in the set of matched elements to the specified text.
|
||||
*
|
||||
* @param func A function returning the text content to set. Receives the index position of the element in the set and the old text value as arguments.
|
||||
* @see {@link https://api.jquery.com/text/#text-function}
|
||||
*/
|
||||
text(func: (index: number, text: string) => string): JQuery;
|
||||
text(func: (index: number, text: string) => string): this;
|
||||
|
||||
/**
|
||||
* Add or remove one or more classes from each element in the set of matched elements, depending on either the class's presence or the value of the switch argument.
|
||||
@@ -564,14 +568,14 @@ interface JQuery {
|
||||
* @param swtch A Boolean (not just truthy/falsy) value to determine whether the class should be added or removed.
|
||||
* @see {@link https://api.jquery.com/toggleClass/#toggleClass-className}
|
||||
*/
|
||||
toggleClass(className: string, swtch?: boolean): JQuery;
|
||||
toggleClass(className: string, swtch?: boolean): this;
|
||||
/**
|
||||
* Add or remove one or more classes from each element in the set of matched elements, depending on either the class's presence or the value of the switch argument.
|
||||
*
|
||||
* @param swtch A boolean value to determine whether the class should be added or removed.
|
||||
* @see {@link https://api.jquery.com/toggleClass/#toggleClass-state}
|
||||
*/
|
||||
toggleClass(swtch?: boolean): JQuery;
|
||||
toggleClass(swtch?: boolean): this;
|
||||
|
||||
/**
|
||||
* Execute all handlers attached to an element for an event.
|
||||
@@ -597,7 +601,7 @@ interface JQuery {
|
||||
* @param handler The function that is to be no longer executed.
|
||||
* @see {@link https://api.jquery.com/unbind/#unbind-eventType-handler}
|
||||
*/
|
||||
unbind(eventType?: string, handler?: (eventObject: JQueryEventObject) => any): JQuery;
|
||||
unbind(eventType?: string, handler?: (eventObject: JQueryEventObject) => any): this;
|
||||
/**
|
||||
* Remove a previously-attached event handler from the elements.
|
||||
*
|
||||
@@ -605,14 +609,14 @@ interface JQuery {
|
||||
* @param fls Unbinds the corresponding 'return false' function that was bound using .bind( eventType, false ).
|
||||
* @see {@link https://api.jquery.com/unbind/#unbind-eventType-false}
|
||||
*/
|
||||
unbind(eventType: string, fls: boolean): JQuery;
|
||||
unbind(eventType: string, fls: boolean): this;
|
||||
/**
|
||||
* Remove a previously-attached event handler from the elements.
|
||||
*
|
||||
* @param evt A JavaScript event object as passed to an event handler.
|
||||
* @see {@link https://api.jquery.com/unbind/#unbind-event}
|
||||
*/
|
||||
unbind(evt: any): JQuery;
|
||||
unbind(evt: any): this;
|
||||
|
||||
/**
|
||||
* Get the current value of the first element in the set of matched elements.
|
||||
@@ -625,14 +629,14 @@ interface JQuery {
|
||||
* @param value A string of text, an array of strings or number corresponding to the value of each matched element to set as selected/checked.
|
||||
* @see {@link https://api.jquery.com/val/#val-value}
|
||||
*/
|
||||
val(value: string | string[] | number): JQuery;
|
||||
val(value: string | string[] | number): this;
|
||||
/**
|
||||
* Set the value of each element in the set of matched elements.
|
||||
*
|
||||
* @param func A function returning the value to set. this is the current element. Receives the index position of the element in the set and the old value as arguments.
|
||||
* @see {@link https://api.jquery.com/val/#val-function}
|
||||
*/
|
||||
val(func: (index: number, value: string) => string): JQuery;
|
||||
val(func: (index: number, value: string) => string): this;
|
||||
|
||||
/**
|
||||
* Wrap an HTML structure around each element in the set of matched elements.
|
||||
@@ -640,14 +644,14 @@ interface JQuery {
|
||||
* @param wrappingElement A selector, element, HTML string, or jQuery object specifying the structure to wrap around the matched elements.
|
||||
* @see {@link https://api.jquery.com/wrap/#wrap-wrappingElement}
|
||||
*/
|
||||
wrap(wrappingElement: JQuery | Element | string): JQuery;
|
||||
wrap(wrappingElement: JQuery | Element | string): this;
|
||||
/**
|
||||
* Wrap an HTML structure around each element in the set of matched elements.
|
||||
*
|
||||
* @param func A callback function returning the HTML content or jQuery object to wrap around the matched elements. Receives the index position of the element in the set as an argument. Within the function, this refers to the current element in the set.
|
||||
* @see {@link https://api.jquery.com/wrap/#wrap-function}
|
||||
*/
|
||||
wrap(func: (index: number) => string | JQuery): JQuery;
|
||||
wrap(func: (index: number) => string | JQuery): this;
|
||||
|
||||
// Undocumented
|
||||
length: number;
|
||||
@@ -661,13 +665,13 @@ interface JQuery {
|
||||
scope<T extends ng.IScope>(): T;
|
||||
isolateScope<T extends ng.IScope>(): T;
|
||||
|
||||
inheritedData(key: string, value: any): JQuery;
|
||||
inheritedData(obj: { [key: string]: any; }): JQuery;
|
||||
inheritedData(key: string, value: any): this;
|
||||
inheritedData(obj: { [key: string]: any; }): this;
|
||||
inheritedData(key?: string): any;
|
||||
}
|
||||
|
||||
interface JQueryStatic {
|
||||
(element: string | Element | Document | JQuery | ArrayLike<Element>): JQuery;
|
||||
(element: string | Element | Document | JQuery | ArrayLike<Element>): JQLite;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
import * as angular from 'angular';
|
||||
|
||||
function JQLite() {
|
||||
function indexSignature() {
|
||||
angular.element('p')[0]; // $ExpectType HTMLElement
|
||||
}
|
||||
}
|
||||
@@ -2,6 +2,10 @@ import $ = require('jquery');
|
||||
import * as angular from 'angular';
|
||||
|
||||
function JQuery() {
|
||||
function indexSignature() {
|
||||
$('p')[0]; // $ExpectType HTMLElement
|
||||
}
|
||||
|
||||
function addClass() {
|
||||
// $ExpectType JQuery<HTMLElement>
|
||||
$('p').addClass('className');
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
"index.d.ts",
|
||||
"jqlite.d.ts",
|
||||
"angular-tests.ts",
|
||||
"test/jqlite-tests.ts",
|
||||
"test/jquery3-merging-tests.ts"
|
||||
],
|
||||
"compilerOptions": {
|
||||
|
||||
@@ -14,6 +14,8 @@
|
||||
"max-line-length": false,
|
||||
"no-empty-interface": false,
|
||||
"no-namespace": false,
|
||||
"no-unnecessary-qualifier": false,
|
||||
"no-void-expression": false,
|
||||
"unified-signatures": false,
|
||||
"void-return": false
|
||||
}
|
||||
|
||||
Vendored
+1
-1
@@ -1,6 +1,6 @@
|
||||
// Type definitions for AngularFire 0.8.2
|
||||
// Project: http://angularfire.com
|
||||
// Definitions by: Dénes Harmath <http://github.com/thSoft>
|
||||
// Definitions by: Dénes Harmath <https://github.com/thSoft>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
// TypeScript Version: 2.3
|
||||
|
||||
|
||||
Vendored
+1
-1
@@ -1,6 +1,6 @@
|
||||
// Type definitions for AngularLocalStorage 0.1.7
|
||||
// Project: https://github.com/agrublev/angularLocalStorage
|
||||
// Definitions by: Horiuchi_H <https://github.com/horiuchi/>
|
||||
// Definitions by: Horiuchi_H <https://github.com/horiuchi>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
// TypeScript Version: 2.3
|
||||
|
||||
|
||||
@@ -0,0 +1,71 @@
|
||||
import * as anime from 'animejs';
|
||||
|
||||
const test1 = anime({
|
||||
targets: 'div',
|
||||
duration: 40,
|
||||
color: "#FFFFFF"
|
||||
});
|
||||
|
||||
const callback = (anim: any) => {
|
||||
console.log(anim.completed);
|
||||
};
|
||||
|
||||
const test2 = anime({
|
||||
targets: 'div',
|
||||
translateX: (el: HTMLElement, i: number, index: number) => {
|
||||
return 0;
|
||||
},
|
||||
translateY: '40px',
|
||||
color: [
|
||||
{value: '#FF0000', duration: 2000},
|
||||
{value: '#00FF00', duration: 2000},
|
||||
{value: '#0000FF', duration: 2000},
|
||||
],
|
||||
duration: () => {
|
||||
return 1000000000000;
|
||||
},
|
||||
update: callback,
|
||||
complete: callback
|
||||
});
|
||||
|
||||
const someNodes = document.querySelector('button');
|
||||
|
||||
const test3 = anime({
|
||||
targets: someNodes,
|
||||
top: "-5000000em"
|
||||
});
|
||||
|
||||
const tl = anime.timeline({
|
||||
loop: false,
|
||||
direction: 'normal'
|
||||
});
|
||||
|
||||
tl.add({
|
||||
targets: ".tiny-divvy-div",
|
||||
scale: 10000000
|
||||
});
|
||||
|
||||
const path = anime.path('#motionPath path');
|
||||
|
||||
test1.play();
|
||||
test2.reverse();
|
||||
test3.pause();
|
||||
tl.seek(4000);
|
||||
|
||||
tl.finished.then(() => {
|
||||
console.log("I wonder if anyone will ever actually read this.");
|
||||
});
|
||||
|
||||
const usesEnums = anime({
|
||||
targets: ".usingEnumsIsAReallyHandyThing",
|
||||
direction: "reverse",
|
||||
easing: "inoutexpo",
|
||||
someProperty: "+=4000"
|
||||
});
|
||||
|
||||
const bezier = anime.bezier(0, 0, 100, 100);
|
||||
// anime.speed = 100000000;
|
||||
(anime as any).speed = 4000;
|
||||
anime.easings['hello'] = anime.bezier(0, 0, 1900, 3020);
|
||||
const runningAnims = anime.running;
|
||||
anime.remove(".tiny-divvy-div");
|
||||
Vendored
+137
@@ -0,0 +1,137 @@
|
||||
// Type definitions for animejs 2.0
|
||||
// Project: http://animejs.com
|
||||
// Definitions by: Andrew Babin <https://github.com/A-Babin>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
// TypeScript Version: 2.4
|
||||
|
||||
type FunctionBasedParamter = (element: HTMLElement, index: number, length: number) => number;
|
||||
type AnimeCallbackFunction = (anim: anime.AnimeInstance) => void;
|
||||
// Allowing null is necessary because DOM queries may not return anything.
|
||||
type AnimeTarget = string | object | HTMLElement | SVGElement | NodeList | null;
|
||||
|
||||
declare namespace anime {
|
||||
type EasingOptions =
|
||||
| "linear"
|
||||
| "easeInQuad"
|
||||
| "easeInCubic"
|
||||
| "easeInQuart"
|
||||
| "easeInQuint"
|
||||
| "easeInSine"
|
||||
| "easeInExpo"
|
||||
| "easeInCirc"
|
||||
| "easeInBack"
|
||||
| "easeInElastic"
|
||||
| "easeOutQuad"
|
||||
| "easeOutCubic"
|
||||
| "easeOutQuart"
|
||||
| "easeOutQuint"
|
||||
| "easeOutSine"
|
||||
| "easeOutExpo"
|
||||
| "easeOutCirc"
|
||||
| "easeOutBack"
|
||||
| "easeOutElastic"
|
||||
| "easeInOutQuad"
|
||||
| "easeInOutCubic"
|
||||
| "easeInOutQuart"
|
||||
| "easeInOutQuint"
|
||||
| "easeInOutSine"
|
||||
| "easeInOutExpo"
|
||||
| "easeInOutCirc"
|
||||
| "easeInOutBack"
|
||||
| "easeInOutElastic";
|
||||
type DirectionOptions = "reverse" | "alternate" | "normal";
|
||||
|
||||
interface AnimeInstanceParams {
|
||||
loop?: number | boolean;
|
||||
autoplay?: boolean;
|
||||
direction?: DirectionOptions | string;
|
||||
|
||||
begin?: AnimeCallbackFunction;
|
||||
run?: AnimeCallbackFunction;
|
||||
update?: AnimeCallbackFunction;
|
||||
complete?: AnimeCallbackFunction;
|
||||
}
|
||||
|
||||
interface AnimeAnimParams {
|
||||
targets: AnimeTarget | ReadonlyArray<AnimeTarget>;
|
||||
|
||||
duration?: number | FunctionBasedParamter;
|
||||
delay?: number | FunctionBasedParamter;
|
||||
elasticity?: number | FunctionBasedParamter;
|
||||
round?: number | boolean | FunctionBasedParamter;
|
||||
|
||||
easing?: EasingOptions | string | ReadonlyArray<number>;
|
||||
|
||||
begin?: AnimeCallbackFunction;
|
||||
run?: AnimeCallbackFunction;
|
||||
update?: AnimeCallbackFunction;
|
||||
complete?: AnimeCallbackFunction;
|
||||
[AnyAnimatedProperty: string]: any;
|
||||
}
|
||||
|
||||
interface AnimeParams extends AnimeInstanceParams, AnimeAnimParams {
|
||||
// Just need this to merge both Params interfaces.
|
||||
}
|
||||
|
||||
interface AnimeInstance {
|
||||
play(): void;
|
||||
pause(): void;
|
||||
restart(): void;
|
||||
reverse(): void;
|
||||
seek(time: number): void;
|
||||
|
||||
began: boolean;
|
||||
paused: boolean;
|
||||
completed: boolean;
|
||||
finished: Promise<void>;
|
||||
|
||||
begin: AnimeCallbackFunction;
|
||||
run: AnimeCallbackFunction;
|
||||
update: AnimeCallbackFunction;
|
||||
complete: AnimeCallbackFunction;
|
||||
|
||||
autoplay: boolean;
|
||||
currentTime: number;
|
||||
delay: number;
|
||||
direction: string;
|
||||
duration: number;
|
||||
loop: number | boolean;
|
||||
offset: number;
|
||||
progress: number;
|
||||
remaining: number;
|
||||
reversed: boolean;
|
||||
|
||||
animatables: ReadonlyArray<object>;
|
||||
animations: ReadonlyArray<object>;
|
||||
}
|
||||
|
||||
interface AnimeTimelineAnimParams extends AnimeAnimParams {
|
||||
offset: number | string | FunctionBasedParamter;
|
||||
}
|
||||
|
||||
interface AnimeTimelineInstance extends AnimeInstance {
|
||||
add(params: AnimeAnimParams): AnimeTimelineInstance;
|
||||
}
|
||||
|
||||
// Helpers
|
||||
const speed: number;
|
||||
const running: AnimeInstance[];
|
||||
const easings: { [EasingFunction: string]: (t: number) => any };
|
||||
function remove(targets: AnimeTarget | ReadonlyArray<AnimeTarget>): void;
|
||||
function getValue(targets: AnimeTarget, prop: string): string | number;
|
||||
function path(path: string | HTMLElement | SVGElement | null, percent?: number): (prop: string) => {
|
||||
el: HTMLElement | SVGElement,
|
||||
property: string,
|
||||
totalLength: number
|
||||
};
|
||||
function setDashoffset(el: HTMLElement | SVGElement | null): number;
|
||||
function bezier(x1: number, y1: number, x2: number, y2: number): (t: number) => number;
|
||||
// Timeline
|
||||
function timeline(params?: AnimeInstanceParams | ReadonlyArray<AnimeInstance>): AnimeTimelineInstance;
|
||||
function random(min: number, max: number): number;
|
||||
}
|
||||
|
||||
declare function anime(params: anime.AnimeParams): anime.AnimeInstance;
|
||||
|
||||
export = anime;
|
||||
export as namespace anime;
|
||||
@@ -18,6 +18,6 @@
|
||||
},
|
||||
"files": [
|
||||
"index.d.ts",
|
||||
"angular-ui-router-uib-modal-tests.ts"
|
||||
"animejs-tests.ts"
|
||||
]
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
{ "extends": "dtslint/dt.json" }
|
||||
@@ -0,0 +1,71 @@
|
||||
import { Annyang, CommandOption } from 'annyang';
|
||||
|
||||
declare const annyang: Annyang;
|
||||
declare const console: any;
|
||||
|
||||
// Tests based on API documentation at https://github.com/TalAter/annyang/blob/master/docs/README.md
|
||||
|
||||
function testStartListening() {
|
||||
annyang.start({ autoRestart: false }); // $ExpectType void
|
||||
annyang.start({ autoRestart: false, continuous: false }); // $ExpectType void
|
||||
}
|
||||
|
||||
function testAddComments() {
|
||||
const helloFunction = (): string => {
|
||||
return 'hello';
|
||||
};
|
||||
|
||||
const commands: CommandOption = {'hello :name': helloFunction, howdy: helloFunction};
|
||||
const commands2: CommandOption = {hi: helloFunction};
|
||||
|
||||
annyang.addCommands(commands); // $ExpectType void
|
||||
annyang.addCommands(commands2); // $ExpectType void
|
||||
annyang.removeCommands(); // $ExpectType void
|
||||
annyang.addCommands(commands); // $ExpectType void
|
||||
annyang.removeCommands('hello'); // $ExpectType void
|
||||
annyang.removeCommands(['howdy', 'hi']); // $ExpectType void
|
||||
}
|
||||
|
||||
const notConnected = () => { console.error('network connection error'); };
|
||||
|
||||
function testAddCallback() {
|
||||
annyang.addCallback('error', () => console.error('There was an error!')); // $ExpectType void
|
||||
|
||||
// $ExpectType void
|
||||
annyang.addCallback('resultMatch', (userSaid, commandText, phrases) => {
|
||||
console.log(userSaid);
|
||||
console.log(commandText);
|
||||
console.log(phrases);
|
||||
});
|
||||
|
||||
annyang.addCallback('errorNetwork', notConnected, annyang); // $ExpectType void
|
||||
}
|
||||
|
||||
function testRemoveCallback() {
|
||||
const start = () => { console.log('start'); };
|
||||
const end = () => { console.log('end'); };
|
||||
|
||||
annyang.addCallback('start', start); // $ExpectType void
|
||||
annyang.addCallback('end', end); // $ExpectType void
|
||||
|
||||
annyang.removeCallback(); // $ExpectType void
|
||||
|
||||
annyang.removeCallback('end'); // $ExpectType void
|
||||
|
||||
annyang.removeCallback('start', start); // $ExpectType void
|
||||
|
||||
annyang.removeCallback(undefined, start); // $ExpectType void
|
||||
}
|
||||
|
||||
function testTrigger() {
|
||||
annyang.trigger('Time for some thrilling heroics');
|
||||
|
||||
// $ExpectType void
|
||||
annyang.trigger(
|
||||
['Time for some thrilling heroics', 'Time for some thrilling aerobics']
|
||||
);
|
||||
}
|
||||
|
||||
function testIsListening() {
|
||||
annyang.isListening(); // $ExpectType boolean
|
||||
}
|
||||
Vendored
+230
@@ -0,0 +1,230 @@
|
||||
// Type definitions for annyang 2.6
|
||||
// Project: https://www.talater.com/annyang/
|
||||
// Definitions by: Hisham Al-Shurafa <https://github.com/hisham>
|
||||
// Lukas Klinzing <https://github.com/theluk>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
|
||||
/**
|
||||
* Options for function `start`
|
||||
*
|
||||
* @export
|
||||
* @interface StartOptions
|
||||
*/
|
||||
export interface StartOptions {
|
||||
/**
|
||||
* Should annyang restart itself if it is closed indirectly, because of silence or window conflicts?
|
||||
*
|
||||
* @type {boolean}
|
||||
*/
|
||||
autoRestart?: boolean;
|
||||
/**
|
||||
* Allow forcing continuous mode on or off. Annyang is pretty smart about this, so only set this if you know what you're doing.
|
||||
*
|
||||
* @type {boolean}
|
||||
*/
|
||||
continuous?: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
* A command option that supports custom regular expressions
|
||||
*
|
||||
* @export
|
||||
* @interface CommandOptionRegex
|
||||
*/
|
||||
export interface CommandOptionRegex {
|
||||
/**
|
||||
* @type {RegExp}
|
||||
*/
|
||||
regexp: RegExp;
|
||||
/**
|
||||
* @type {() => any}
|
||||
*/
|
||||
callback(): void;
|
||||
}
|
||||
|
||||
/**
|
||||
* Commands that annyang should listen to
|
||||
*
|
||||
* #### Examples:
|
||||
* ````javascript
|
||||
* {'hello :name': helloFunction, 'howdy': helloFunction};
|
||||
* {'hi': helloFunction};
|
||||
* ````
|
||||
* @export
|
||||
* @interface CommandOption
|
||||
*/
|
||||
export interface CommandOption {
|
||||
[command: string]: CommandOptionRegex | (() => void);
|
||||
}
|
||||
|
||||
/**
|
||||
* Supported Events that will be triggered to listeners, you attach using `annyang.addCallback()`
|
||||
*
|
||||
* `start` - Fired as soon as the browser's Speech Recognition engine starts listening
|
||||
* `error` - Fired when the browser's Speech Recogntion engine returns an error, this generic error callback will be followed by more accurate error callbacks (both will fire if both are defined)
|
||||
* `errorNetwork` - Fired when Speech Recognition fails because of a network error
|
||||
* `errorPermissionBlocked` - Fired when the browser blocks the permission request to use Speech Recognition.
|
||||
* `errorPermissionDenied` - Fired when the user blocks the permission request to use Speech Recognition.
|
||||
* `end` - Fired when the browser's Speech Recognition engine stops
|
||||
* `result` - Fired as soon as some speech was identified. This generic callback will be followed by either the `resultMatch` or `resultNoMatch` callbacks.
|
||||
* Callback functions registered to this event will include an array of possible phrases the user said as the first argument
|
||||
* `resultMatch` - Fired when annyang was able to match between what the user said and a registered command
|
||||
* Callback functions registered to this event will include three arguments in the following order:
|
||||
* * The phrase the user said that matched a command
|
||||
* * The command that was matched
|
||||
* * An array of possible alternative phrases the user might've said
|
||||
* `resultNoMatch` - Fired when what the user said didn't match any of the registered commands.
|
||||
* Callback functions registered to this event will include an array of possible phrases the user might've said as the first argument
|
||||
*/
|
||||
export type Events =
|
||||
'start' |
|
||||
'soundstart' |
|
||||
'error' |
|
||||
'end' |
|
||||
'result' |
|
||||
'resultMatch' |
|
||||
'resultNoMatch' |
|
||||
'errorNetwork' |
|
||||
'errorPermissionBlocked' |
|
||||
'errorPermissionDenied';
|
||||
|
||||
export interface Annyang {
|
||||
/**
|
||||
* Start listening.
|
||||
* It's a good idea to call this after adding some commands first, but not mandatory.
|
||||
*
|
||||
* @param {StartOptions} options
|
||||
*/
|
||||
start(options?: StartOptions): void;
|
||||
|
||||
/**
|
||||
* Stop listening, and turn off mic.
|
||||
*
|
||||
*/
|
||||
abort(): void;
|
||||
|
||||
/**
|
||||
* Pause listening. annyang will stop responding to commands (until the resume or start methods are called), without turning off the browser's SpeechRecognition engine or the mic.
|
||||
*
|
||||
*/
|
||||
pause(): void;
|
||||
|
||||
/**
|
||||
* Resumes listening and restores command callback execution when a result matches.
|
||||
* If SpeechRecognition was aborted (stopped), start it.
|
||||
*
|
||||
*/
|
||||
resume(): void;
|
||||
|
||||
/**
|
||||
* Turn on output of debug messages to the console. Ugly, but super-handy!
|
||||
*
|
||||
* @export
|
||||
* @param {boolean} [newState=true] Turn on/off debug messages
|
||||
*/
|
||||
debug(newState?: boolean): void;
|
||||
|
||||
/**
|
||||
* Set the language the user will speak in. If this method is not called, defaults to 'en-US'.
|
||||
*
|
||||
* @param {string} lang
|
||||
* @see [Languages](https://github.com/TalAter/annyang/blob/master/docs/FAQ.md#what-languages-are-supported)
|
||||
*/
|
||||
setLanguage(lang: string): void;
|
||||
|
||||
/**
|
||||
* Add commands that annyang will respond to. Similar in syntax to init(), but doesn't remove existing commands.
|
||||
*
|
||||
* #### Examples:
|
||||
* ````javascript
|
||||
* var commands = {'hello :name': helloFunction, 'howdy': helloFunction};
|
||||
* var commands2 = {'hi': helloFunction};
|
||||
*
|
||||
* annyang.addCommands(commands);
|
||||
* annyang.addCommands(commands2);
|
||||
* // annyang will now listen to all three commands
|
||||
* ````
|
||||
*
|
||||
* @param {CommandOption} commands
|
||||
*/
|
||||
addCommands(commands: CommandOption): void;
|
||||
|
||||
/**
|
||||
* Removes all existing commands or a specific command
|
||||
* #### Examples:
|
||||
* ````javascript
|
||||
* var commands : annyang.CommandOption = {'hello': helloFunction, 'howdy': helloFunction, 'hi': helloFunction};
|
||||
*
|
||||
* // Don't respond to hello
|
||||
* annyang.removeCommands('hello');
|
||||
*
|
||||
* // Remove all existing commands
|
||||
* annyang.removeCommands();
|
||||
* ````
|
||||
* @param {string} command
|
||||
*/
|
||||
removeCommands(command?: string): void;
|
||||
|
||||
/**
|
||||
* Removes a list of commands
|
||||
* #### Examples:
|
||||
* ````javascript
|
||||
* var commands : annyang.CommandOption = {'hello': helloFunction, 'howdy': helloFunction, 'hi': helloFunction};
|
||||
* // Add some commands
|
||||
* annyang.addCommands(commands);
|
||||
* // Don't respond to howdy or hi
|
||||
* annyang.removeCommands(['howdy', 'hi']);
|
||||
* ````
|
||||
*
|
||||
* @param {string[]} command
|
||||
*/
|
||||
removeCommands(command: string[]): void;
|
||||
|
||||
/**
|
||||
* @param {Events} event
|
||||
* @param {(userSaid : string, commandText : string, results : string[]) => void} callback
|
||||
* @param {*} [context]
|
||||
*/
|
||||
addCallback(event: Events, callback: (userSaid?: string, commandText?: string, results?: string[]) => void, context?: any): void;
|
||||
|
||||
/**
|
||||
* @param {Events} [event]
|
||||
* @param {Function} [callback]
|
||||
*/
|
||||
removeCallback(event?: Events, callback?: (userSaid: string, commandText: string, results: string[]) => void): void;
|
||||
|
||||
/**
|
||||
* Returns true if speech recognition is currently on.
|
||||
* Returns false if speech recognition is off or annyang is paused.
|
||||
*
|
||||
* @returns {boolean}
|
||||
*/
|
||||
isListening(): boolean;
|
||||
|
||||
/**
|
||||
* Returns the instance of the browser's SpeechRecognition object used by annyang.
|
||||
* Useful in case you want direct access to the browser's Speech Recognition engine.
|
||||
*
|
||||
* @returns {*}
|
||||
*/
|
||||
getSpeechRecognizer(): any;
|
||||
|
||||
/**
|
||||
* Simulate speech being recognized. This will trigger the same events and behavior as when the Speech Recognition
|
||||
* detects speech.
|
||||
*
|
||||
* Can accept either a string containing a single sentence, or an array containing multiple sentences to be checked
|
||||
* in order until one of them matches a command (similar to the way Speech Recognition Alternatives are parsed)
|
||||
*
|
||||
* #### Examples:
|
||||
* ````javascript
|
||||
* annyang.trigger('Time for some thrilling heroics');
|
||||
* annyang.trigger(
|
||||
* ['Time for some thrilling heroics', 'Time for some thrilling aerobics']
|
||||
* );
|
||||
* ````
|
||||
*
|
||||
* @param {string} command
|
||||
*/
|
||||
trigger(command: string | string[]): void;
|
||||
}
|
||||
@@ -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",
|
||||
"annyang-tests.ts"
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
{ "extends": "dtslint/dt.json" }
|
||||
@@ -0,0 +1,43 @@
|
||||
import anymatch = require('anymatch');
|
||||
|
||||
const matchers = [
|
||||
'path/to/file.js',
|
||||
'path/anyjs/**/*.js',
|
||||
/foo\.js$/,
|
||||
(str: string) => str.indexOf('bar') !== -1 && str.length > 10
|
||||
];
|
||||
|
||||
// $ExpectType boolean
|
||||
anymatch(matchers, 'path/to/file.js');
|
||||
// $ExpectType boolean
|
||||
anymatch(matchers, 'path/to/file.js', false);
|
||||
// $ExpectType boolean
|
||||
anymatch(matchers, 'path/to/file.js', false, 1);
|
||||
// $ExpectType boolean
|
||||
anymatch(matchers, 'path/to/file.js', false, 1, 2);
|
||||
|
||||
// $ExpectType number
|
||||
anymatch(matchers, 'foo.js', true);
|
||||
// $ExpectType number
|
||||
anymatch(matchers, 'path/anyjs/foo.js', true, 2);
|
||||
// $ExpectType number
|
||||
anymatch(matchers, 'path/anyjs/foo.js', true, 2, 3);
|
||||
|
||||
const matcher = anymatch(matchers);
|
||||
// $ExpectType boolean
|
||||
matcher('path/to/file.js');
|
||||
// $ExpectType boolean
|
||||
matcher('path/to/file.js', false);
|
||||
// $ExpectType boolean
|
||||
matcher('path/to/file.js', false, 1);
|
||||
// $ExpectType boolean
|
||||
matcher('path/to/file.js', false, 1, 2);
|
||||
// $ExpectType number
|
||||
matcher('path/anyjs/baz.js', true);
|
||||
// $ExpectType number
|
||||
matcher('path/anyjs/baz.js', true, 2);
|
||||
// $ExpectType number
|
||||
matcher('path/anyjs/baz.js', true, 2, 3);
|
||||
|
||||
// tslint:disable-next-line no-unnecessary-callback-wrapper
|
||||
['foo.js', 'bar.js'].filter(str => matcher(str));
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user