Merge remote-tracking branch 'upstream/master'

This commit is contained in:
Derek Finlinson
2019-02-07 15:54:35 -07:00
9086 changed files with 1008961 additions and 140321 deletions
+1 -1
View File
@@ -5,5 +5,5 @@ indent_size = 4
trim_trailing_whitespace = true
insert_final_newline = true
[{*.json,*.yml}]
[{*.json,*.yml,*.ts,*.tsx,*.md}]
indent_style = space
+5761 -4669
View File
File diff suppressed because it is too large Load Diff
+1
View File
@@ -46,6 +46,7 @@ npm-debug.log
.settings/launch.json
.vs
.vscode
.history
# yarn
yarn.lock
+1
View File
@@ -0,0 +1 @@
package-lock=false
+19 -19
View File
@@ -22,15 +22,15 @@ Este es el método preferido. Solo está disponible para usuarios TypeScript 2.0
npm install --save-dev @types/node
```
Los types deberían ser incluidos automaticamente por el compilador.
Los types deberían ser incluidos automáticamente por el compilador.
Vea más en el [manual](http://www.typescriptlang.org/docs/handbook/declaration-files/consumption.html).
Para un paquete NPM "foo", Estos `typings` estarán en "@types/foo".
Para un paquete NPM "foo", estos `typings` estarán en "@types/foo".
Si no puedes encontrar tu paquete, búscalo en [TypeSearch](https://microsoft.github.io/TypeSearch/).
Si aún no puedes encontrarlo, comprueba si el paquete ya [incluye](http://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html) los typings.
Esto es provisto usualmente en el campo `"types"` o `"typings"` en el `package.json`,
o solo busca por cualquier archivo ".d.ts" en el paquete e incluyelo manualmente con un `/// <reference path="" />`.
o solo busca por cualquier archivo ".d.ts" en el paquete e inclúyelo manualmente con un `/// <reference path="" />`.
### Otros métodos
@@ -39,7 +39,7 @@ Estos pueden ser utilizados por TypeScript 1.0.
* [Typings](https://github.com/typings/typings)
* ~~[NuGet](http://nuget.org/packages?q=DefinitelyTyped)~~ (use las alternativas preferidas, la publicación DT type de nuget ha sido desactivada)
* Descarguelo manualmente desde la `master` branch de este repositorio
* Descárguelo manualmente desde la `master` branch de este repositorio
Tal vez debas añadir manualmente las [referencias](http://www.typescriptlang.org/docs/handbook/triple-slash-directives.html).
@@ -88,7 +88,7 @@ Primero, haz un [fork](https://guides.github.com/activities/forking/) en este re
* `cd types/my-package-to-edit`
* Haz cambios. Recuerda editar las pruebas.
Si realiza cambios importantes, no olvide [actualizar una versión principal](#quiero-actualizar-un-paquete-a-una-nueva-versión-principal).
* También puede que quieras añadirte la sección "Definitions by" en el encabezado del paquete.
* También puede que quieras añadirle la sección "Definitions by" en el encabezado del paquete.
- Esto hará que seas notificado (a través de tu nombre de usuario en GitHub) cada vez que alguien haga un pull request o issue sobre el paquete.
- Haz esto añadiendo tu nombre al final de la línea, así como en `// Definitions by: Alice <https://github.com/alice>, Bob <https://github.com/bob>`.
- O si hay más personas, puede ser multiline
@@ -109,7 +109,7 @@ Si no lo hace, puedes hacerlo en el comentario asociado con el PR.
Si eres el autor de la librería, o puedes hacer un pull request a la biblioteca, [bundle types](http://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html) en vez de publicarlo en DefinitelyTyped.
Si estás agregando typings para un paquete NPM, crea un directorio con el mismo nombre.
Si el paquete al que le estás agregando typings no es para NPM, asegurate de que el nombre que escojas no genere problemas con el nombre del paquete en NPM.
Si el paquete al que le estás agregando typings no es para NPM, asegúrate de que el nombre que escojas no genere problemas con el nombre del paquete en NPM.
(Puedes usar `npm info foo` para verificar la existencia del paquete `foo`.)
Tu paquete debería tener esta estructura:
@@ -126,7 +126,7 @@ Ve todas las opciones en [dts-gen](https://github.com/Microsoft/dts-gen).
También puedes configurar el `tsconfig.json` para añadir nuevos archivos, para agregar un `"target": "es6"` (necesitado por las funciones asíncronas), para agregar a la `"lib"`, o para agregar la opción de compilación `"jsx"`.
Los miembros de DefinitelyTyped frecuentemente monitorean nuevos PRs, pero ten en mente que la cantidad de PRs podrian ralentizar el proceso.
Los miembros de DefinitelyTyped frecuentemente monitorean nuevos PRs, pero ten en mente que la cantidad de PRs podrían ralentizar el proceso.
Para un buen paquete de ejemplo, vea [base64-js](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/base64-js).
@@ -135,7 +135,7 @@ Para un buen paquete de ejemplo, vea [base64-js](https://github.com/DefinitelyTy
* Primero, sigue el consejo del [manual](http://www.typescriptlang.org/docs/handbook/declaration-files/do-s-and-don-ts.html).
* Formatear: Ya sea utilizar todo en tabs, o siempre utiliza 4 espacios.
* `function sum(nums: number[]): number`: Utiliza `ReadonlyArray` si una funcion no escribe a sus parámetros.
* `function sum(nums: number[]): number`: Utiliza `ReadonlyArray` si una función no escribe a sus parámetros.
* `interface Foo { new(): Foo; }`:
Este define el tipo de objeto que esten nuevos. Probablemente quieras `declare class Foo { constructor(); }`.
* `const Class: { new(): IClass; }`:
@@ -146,7 +146,7 @@ Para un buen paquete de ejemplo, vea [base64-js](https://github.com/DefinitelyTy
Un ejemplo donde un tipo de parámetro es aceptable: `function id<T>(value: T): T;`.
Un ejemplo donde no es aceptable: `function parseJson<T>(json: string): T;`.
Una excepción: `new Map<string, number>()` está bien.
* Utilizando los tipos `Function` y `Object` casi nunca es una buena idea. En 99% de los casos es posible especificar un tipo más especifico. Los ejemplos son `(x: number) => number` para [funciones](http://www.typescriptlang.org/docs/handbook/functions.html#function-types) y `{ x: number, y: number }` para objetos. Si no hay certeza en lo absoluto del tipo, [`any`](http://www.typescriptlang.org/docs/handbook/basic-types.html#any) es la opción correcta, no `Object`. Si el único hecho conocido sobre el tipo es que es un objecto, usa el tipo [`object`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#object-type), no `Object` o `{ [key: string]: any }`.
* Utilizando los tipos `Function` y `Object` casi nunca es una buena idea. En 99% de los casos es posible especificar un tipo más específico. Los ejemplos son `(x: number) => number` para [funciones](http://www.typescriptlang.org/docs/handbook/functions.html#function-types) y `{ x: number, y: number }` para objetos. Si no hay certeza en lo absoluto del tipo, [`any`](http://www.typescriptlang.org/docs/handbook/basic-types.html#any) es la opción correcta, no `Object`. Si el único hecho conocido sobre el tipo es que es un objecto, usa el tipo [`object`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#object-type), no `Object` o `{ [key: string]: any }`.
* `var foo: string | any`:
Cuando es usado `any` en un tipo de unión, el tipo resultante todavía es `any`. Así que mientras la porción `string` de este tipo de anotación puede _verse_ útil, de hecho, no ofrece ningún typechecking adicional más que un simple `any`.
Dependiendo de la intención, una alternativa aceptable puede ser `any`, `string`, o `string | object`.
@@ -204,11 +204,11 @@ Este script utiliza [dtslint](https://github.com/Microsoft/dtslint).
#### ¿Cuál es exactamente la relación entre este repositorio y los paquetes de `@types` en NPM?
La `master` branch es automaticamente publicada en el alcance de los `@types` en NPM gracias a los [types-publisher](https://github.com/Microsoft/types-publisher).
La `master` branch es automáticamente publicada en el alcance de los `@types` en NPM gracias a los [types-publisher](https://github.com/Microsoft/types-publisher).
#### He enviado un pull request. ¿Cuánto tardará en ser merged?
Esto depende, pero la mayoría de los pull requests serán merged en alrededor de una semana. PRs que hayan sido aprovados por un autor listado en el encabezado de las definiciones usualmente son merged más rápidamente; PRs para nuevas definiciones tomarán más tiempo ya que requieren más revisiones de los mantenedores. Cada PR es revisado por un miembro de TypeScript o DefinitelyTyped antes de ser merged, por favor se paciente debido a que factores humanos pueden causar retrasos. Revisa el [PR Burndown Board](https://github.com/DefinitelyTyped/DefinitelyTyped/projects/3?card_filter_query=is%3Aopen) para ver el progreso mientras los mantenedores trabajan on los PRs abiertos.
Esto depende, pero la mayoría de los pull requests serán merged en alrededor de una semana. PRs que hayan sido aprobados por un autor listado en el encabezado de las definiciones usualmente son merged más rápidamente; PRs para nuevas definiciones tomarán más tiempo ya que requieren más revisiones de los mantenedores. Cada PR es revisado por un miembro de TypeScript o DefinitelyTyped antes de ser merged, por favor sé paciente debido a que factores humanos pueden causar retrasos. Revisa el [PR Burndown Board](https://github.com/DefinitelyTyped/DefinitelyTyped/projects/3?card_filter_query=is%3Aopen) para ver el progreso mientras los mantenedores trabajan en los PRs abiertos.
#### Mi PR ha sido merged; ¿cuándo será actualizado el paquete de `@types` NPM?
@@ -216,12 +216,12 @@ Los paquetes NPM deberán ser actualizados en unas cuantas horas. Si ha pasado m
#### Estoy escribiendo una definición que depende de otra definición. Debería utilizar `<reference types="" />` o una import?
Si el modulo al cual te estás refiriendo es un módulo externo (utiliza `export`), utilice una import.
Si el módulo al cual te estás refiriendo es un módulo externo (utiliza `export`), utilice una import.
Si el módulo al cual te refieres es un módulo ambiente (utiliza `declare module`, o simplemente declara las globales), utilice `<reference types="" />`.
#### He notado que algunos paquetes aquí tienen `package.json`.
Normalmente no lo necesitaras. Cuando publicas un paquete normalmente nosotros automáticamente crearemos un `package.json` para eso.
Normalmente no lo necesitarás. Cuando publicas un paquete normalmente nosotros automáticamente crearemos un `package.json` para eso.
Un `package.json` puede ser incluido por el bien de especificar dependencias. Aquí tienen un [ejemplo](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/pikaday/package.json).
No aceptamos otros campos, tales como `"description"`, para que sean definidos manualmente.
Además, si necesitas referencia a una versión anterior de typings, debes hacerlo añadiendo `"dependencies": { "@types/foo": "x.y.z" }` al package.json.
@@ -260,7 +260,7 @@ Cuando ya no sea un borrador, lo podremos eliminar desde DefinitelyType y hacer
Si planeas continuar actualizando la versión anterior del paquete, puedes crear una subcarpeta con la versión actual p.ej. `v2`, y copia los archivos existentes. Si es así, necesitarás:
1. Actualiza las rutas relativas en `tsconfig.json` al igual que `tslint.json`.
2. Añadir reglas de mapeo de rutas para asegurart de que la prueba se está ejecutando contra la versión prevista.
2. Añadir reglas de mapeo de rutas para asegurarte de que la prueba se está ejecutando contra la versión prevista.
Por ejemplo [history v2 `tsconfig.json`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/history/v2/tsconfig.json) se ve así:
@@ -280,24 +280,24 @@ Por ejemplo [history v2 `tsconfig.json`](https://github.com/DefinitelyTyped/Defi
}
```
Si hay otros paquetes en DefinitelyTyped que son incompatibles con la nueva versión, necesitaras mapear las rutas a la versión anterior. También deberá hacer esto para los paquetes que dependen de paquetes que dependen de una version anterior.
Si hay otros paquetes en DefinitelyTyped que son incompatibles con la nueva versión, necesitarás mapear las rutas a la versión anterior. También deberá hacer esto para los paquetes que dependen de paquetes que dependen de una version anterior.
Por ejemplo, `react-router` depende de `history@2`, así que [react-router `tsconfig.json`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react-router/tsconfig.json) tiene una ruta mapeada a "history": `[ "history/v2" ]`;
transitivo así mismo, `react-router-bootstrap` (que depende de `react-router`) también añade una ruta mapeada en su [tsconfig.json](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react-router-bootstrap/tsconfig.json).
Además, `/// <reference types=".." />` no trabajara con rutas mapeadas, así que las dependencias deberán utilizar `import`.
Además, `/// <reference types=".." />` no trabajará con rutas mapeadas, así que las dependencias deberán utilizar `import`.
#### ¿Cómo escribo definitions para paquetes que pueden ser usados globalmente y como un módulo?
El manual de TypeScript contiene excelente [información general para escribir definiciones](https://www.typescriptlang.org/docs/handbook/declaration-files/introduction.html), ademas [este archivo de definiciones de ejemplo](https://www.typescriptlang.org/docs/handbook/declaration-files/templates/global-modifying-module-d-ts.html) el cual muestra como crear una definición utilizando la sintaxis de módulo en ES6, asi como también especificando objetos que son disponibles en el alcance global. Esta técnica es demostrada practicamente en la [definición para big.js](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/big.js/index.d.ts), el cual es una librería que puede ser cargada globalmente a travéz de una etiqueta script en una página web, o importada via require o imports estilo ES6.
El manual de TypeScript contiene excelente [información general para escribir definiciones](https://www.typescriptlang.org/docs/handbook/declaration-files/introduction.html), además [este archivo de definiciones de ejemplo](https://www.typescriptlang.org/docs/handbook/declaration-files/templates/global-modifying-module-d-ts.html) el cual muestra como crear una definición utilizando la sintaxis de módulo en ES6, asi como también especificando objetos que son disponibles en el alcance global. Esta técnica es demostrada prácticamente en la [definición para big.js](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/big.js/index.d.ts), el cual es una librería que puede ser cargada globalmente a través de una etiqueta script en una página web, o importada vía require o imports estilo ES6.
Para probar como puede ser usada tu definición cuando se refieren globalmente o como un módulo importado, crea una carpeta `test`, y coloca dos archivos de prueba en él. nombra uno `YourLibraryName-global.test.ts` y el otro `YourLibraryName-module.test.ts`. El archivo de prueba _global_ debe ejercer la definición de acuerdo como va a ser usado en un script cargado en una página web donde la librería estará disponible en el alcance global - en este escenario no debes de especificar la sentencia de import. El archivo _módulo_ de prueba debe de ejercer la definición de acuerdo a como va a ser utilizado cuando sea importado (incluyendo las sentencias `import`). Si especificas un propiedad `files` en tu archivo tsconfig.json, asegurate de incluir ambos archivos de prueba. Un [ejemplo práctico de esto](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/big.js/test) es también disponible en la definición de big.js.
Para probar como puede ser usada tu definición cuando se refieren globalmente o como un módulo importado, crea una carpeta `test`, y coloca dos archivos de prueba en él. nombra uno `YourLibraryName-global.test.ts` y el otro `YourLibraryName-module.test.ts`. El archivo de prueba _global_ debe ejercer la definición de acuerdo como va a ser usado en un script cargado en una página web donde la librería estará disponible en el alcance global - en este escenario no debes de especificar la sentencia de import. El archivo _módulo_ de prueba debe de ejercer la definición de acuerdo a como va a ser utilizado cuando sea importado (incluyendo las sentencias `import`). Si especificas una propiedad `files` en tu archivo tsconfig.json, asegurate de incluir ambos archivos de prueba. Un [ejemplo práctico de esto](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/big.js/test) es también disponible en la definición de big.js.
Por favor tenga en cuenta que no es necesario para ejercer plenamente la definición en cada archivo de prueba - Es suficiente con probar solo los elementos globalmente accesibles en la prueba de archivos globales y ejercer la definición en el módulo del archivo de prueba, o viceversa.
#### ¿Qué pasa con paquetes scoped?
Types para un paquete scoped `@foo/bar` deberán ir en `types/foo__bar`. tenga en cuenta el doble guion bajo.
Types para un paquete scoped `@foo/bar` deberán ir en `types/foo__bar`. tenga en cuenta el doble guión bajo.
Cuando `dts-gen` es utilizado como scaffold en un paquete scoped, las propiedades `paths` deberán ser adaptadas manualmente en el paquete generado
`tsconfig.json` para referenciar correctamente el paquete scoped:
+338
View File
@@ -0,0 +1,338 @@
# DefinitelyTyped [![Build Status](https://travis-ci.org/DefinitelyTyped/DefinitelyTyped.svg?branch=master)](https://travis-ci.org/DefinitelyTyped/DefinitelyTyped)
[![깃터(https://gitter.im/borisyankov/DefinitelyTyped)에서 대화에 참여해보세요](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/borisyankov/DefinitelyTyped?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
> 이 저장소는 고품질의 타입스크립트(TypeScript) 자료형 정의(Type definition)를 위한 저장소입니다.
이 문서가 가장 최신 내용을 담고있긴 하지만, [공식 사이트(definitelytyped.org)](http://definitelytyped.org)도 확인해보시면 좋습니다.
## 선언 파일(Declaration file)이 뭔가요?
[타입스크립트 안내서(TypeScript handbook)](http://www.typescriptlang.org/docs/handbook/declaration-files/introduction.html)를 읽어보세요.
## 선언 파일(Declaration file)을 어떻게 받을 수 있나요??
### npm 사용하기
아래 방법은 타입스크립트(TypeScript) 2.0+ 이상의 버전을 사용하는 사람들만 사용할 수 있는 방법이기는 합니다만, 이 방법을 사용하기를 장려합니다.
```sh
npm install --save-dev @types/node
```
`node` 를 위한 자료형(Typing)이 컴파일 과정에 자동으로 포함될 겁니다.
더 자세한 내용은 [안내서(Handbook)](http://www.typescriptlang.org/docs/handbook/declaration-files/consumption.html)에서 확인해보실 수 있습니다.
NPM 의 "foo" 패키지에 대응되는 자료형 패키지는 "@types/foo" 입니다.
원하시는 패키지를 찾을 수 없는 경우, [타입서치(TypeSearch)](https://microsoft.github.io/TypeSearch/) 사이트에서 한 번 찾아보세요.
타입서치(TypeSearch)에서도 찾을 수 없는 경우, 찾고 있는 패키지가 자료형(Typing)을
[함께 제공](http://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html)하고 있지는 않은지 확인해보세요.
패키지에 포함된 자료형(Typing)은 주로 `package.json` 파일의 `"types"` 나 `"typings"` 필드(Field)를 통해 제공되지만,
`/// <reference path="" />` 같은 주석을 사용하여 패키지 안의 ".d.ts" 파일들을 직접 가져와야 할 수도 있습니다.
### 그 외의 방법들
타입스크립트(TypeScript) 1.0 버전에서 사용할 수 있는 방법은 다음과 같습니다.
* [Typings](https://github.com/typings/typings) 을 사용하기
* ~~[NuGet](http://nuget.org/packages?q=DefinitelyTyped) 을 사용하기~~ (다른 방법을 사용해주세요. NuGet 은 더 이상 DT 자료형(Typing)을 제공하지 않습니다.)
* 이 저장소의 `master` 브랜치를 직접 내려받기
위 방법을 사용할 경우 수동으로 [참조(Reference)](http://www.typescriptlang.org/docs/handbook/triple-slash-directives.html)를 추가해주어야 할 수 있습니다.
## 어떻게 이곳에 기여할 수 있나요?
여러분과 같은 많은 기여자들의 도움 덕분에 이 저장소가 돌아가고 있습니다. 감사합니다.
### 테스트
여러분이 만든 자료형 선언(Type declation)을 세상에 공유하기에 앞서, 여러분이 스스로 여러분의 자료형 선언(Type declation)을 사용하고 확인해주세요.
#### 이미 존재하는 자료형 패키지를 임시로 수정하기
이미 존재하는 패키지의 자료형 선언(Type declaration)에 새로운 기능을 추가하려면 [모듈 증강(module augmentation)](http://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation)를 사용할 수 있습니다.
물론 `node_modules/@types/foo/index.d.ts` 를 직접 수정하실 수도 있으며, 이 파일을 복사한 다음 아래의 과정을 따라하실 수도 있습니다.
#### 새 자료형 패키지를 임시로 추가하기
사용하고 계신 `tsconfig.json` 에 다음 내용을 추가해주세요.
```json
"baseUrl": "types",
"typeRoots": ["types"],
```
(`types` 대신 `src/types` 을 사용하실 수도 있습니다.)
그리고 "foo" 모듈(Module)에 대한 선언(Declaration)을 포함하는 `types/foo/index.d.ts` 파일을 만들어주세요.
이제 코드 안에서 여러분의 새 자료형 선언(Type declaration)을 사용하는 `"foo"` 모듈(Module)을 임포트(Import)하실 수 있을 겁니다.
코드를 컴파일하고 실행시켜서 여러분의 자료형(Typing)이 실행 중에 실제로 벌어지는 일과 잘 맞아떨어지는지 확인해주세요.
실제 코드를 통한 확인이 끝나면, [풀 리퀘스트(Pull request)](#풀-리퀘스트pull-request-만들기)를 만들어주세요.
[이미 존재하는 패키지를 수정](#이미-존재하는-패키지를-수정하기)하거나 [새 패키지를 만들기](#새-패키지-만들기)위한 과정들을 따라하시면 됩니다.
### 풀 리퀘스트(Pull request) 만들기
여러분의 자료형 선언이 잘 작동하는지 확인하셨다면, DefinitelyTyped 에 공유해주세요.
우선, 이 저장소를 [포크(fork)](https://guides.github.com/activities/forking/)해 주시고, [node](https://nodejs.org/) 를 설치하신 뒤, `npm install` 명령을 실행해주세요.
#### 이미 존재하는 패키지를 수정하기
* `cd types/my-package-to-edit` 명령을 실행합니다.
* 자료형(Typing) 파일들을 수정합니다. 테스트를 추가하는 것도 잊지마세요!
만약 브레이킹 체인지(Breaking change)를 만드셨다면, [메이저 버전(major version)](#i-want-to-update-a-package-to-a-new-major-version)을 꼭 올려주세요.
* 패키지 머릿주석의 "Definitions by" 부분에 여러분의 이름을 추가하실 수도 있습니다.
- 이름을 추가하시면 다른 사람들이 그 패키지에 대한 풀 리퀘스트(Pull request)나 이슈(Issue)를 만들 때 여러분에게 알람이 갑니다.
- `// Definitions by: Alice <https://github.com/alice>, Bob <https://github.com/bob>` 와 같이 여러분의 이름을 줄의 맨 마지막에 추가할 수 있습니다.
- 사람이 너무 많을 경우엔, 다음과 같이 여러 줄로 쓰실 수도 있습니다.
```typescript
// Definitions by: Alice <https://github.com/alice>
// Bob <https://github.com/bob>
// Steve <https://github.com/steve>
// John <https://github.com/john>
```
* `tslint.json` 파일이 있는 경우에는, `npm run lint package-name` 명령을 실행시키고 결과를 확인해주세요. 그렇지 않은 경우에는, 해당 패키지가 있는 디렉토리 안에서 `tsc` 명령을 실행시키고 결과를 확인해주세요.
이미 존재하는 패키지에 대한 풀 리퀘스트(Pull request)를 만들었을 경우에는, `dt-bot` 이 이전 저자들을 자동으로 호출하는지 확인해주세요.
그렇지 않은 경우에는, 여러분이 직접 풀 리퀘스트(Pull request)와 관계있는 사람들을 호출할 수도 있습니다.
#### 새 패키지를 만들기
만약 라이브러리를 만드는 중이고 라이브러리가 타입스크립트(TypeScript)로 쓰여있다면, DefinitelyTyped 에 선언(Declaration)을 올리는 대신 패키지에 [자동생성된 선언(Declaration) 파일을 포함](http://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html)시킬 수 있습니다.
NPM 패키지를 위한 자료형(Typing) 패키지를 만드시려면, 패키지의 이름과 같은 이름의 디렉토리를 만들어주세요.
NPM 에 올라가 있지 않은 패키지를 위한 자료형(Typing) 패키지를 만드시려면, 그 패키지가 NPM 에 올라와 있는 패키지와 이름이 겹치지 않는지 확인해주세요.
(`npm info foo` 명령어를 사용하여 `foo` 패키지가 NPM 에 있는지 확인할 수 있습니다.)
새 자료형 패키지는 다음과 같은 구조로 구성되어있어야만 합니다.
| 파일 이름 | 용도 |
| --- | --- |
| index.d.ts | 패키지를 위한 자료형(Typing)을 포함하는 파일입니다. |
| foo-tests.ts | 자료형(Typing)의 테스트를 위한 파일입니다. 이 파일의 코드는 실행되지는 않지만, 자료형 검사(Type checking)를 통과해야 합니다. |
| tsconfig.json | `tsc` 명령을 돌릴 수 있게 해주는 파일입니다. |
| tslint.json | 린터(Linter)를 사용할 수 있게 해주는 파일입니다. |
이 파일들은, npm ≥ 5.2.0 에서는 `npx dts-gen --dt --name my-package-name --template module` 명령으로,
그 이하 경우에는 `npm install -g dts-gen` 와 `dts-gen --dt --name my-package-name --template module` 명령으로 만들 수 있습니다.
`dts-gen` 의 모든 옵션(Option)을 보고싶으시면 [dts-gen](https://github.com/Microsoft/dts-gen) 저장소를 확인해주세요.
자료형(Typing) 패키지에 새 파일을 추가하거나, `async` 키워드를 사용하기 위해 `"target"` 을 `"es6"` 로 설정하거나, `"lib"` 를 추가하거나, `jsx` 지원을 추가하기 위해서 `tsconfig.json` 파일을 변경해야 할 수도 있습니다.
DefinitelyTyped 의 관리자들이 주기적으로 새로운 풀 리퀘스트(Pull request)들을 확인하기는 하지만,
다른 풀 리퀘스트(Pull request)가 많을 경우 확인이 느려질 수 있다는 걸 알아주세요.
[base64-js](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/base64-js) 패키지는 좋은 예시 중 하나입니다.
#### 많이 저지르는 실수들
* 우선, [안내서(Handbook)](http://www.typescriptlang.org/docs/handbook/declaration-files/do-s-and-don-ts.html)에 나와있는 내용들을 따라주세요.
* 코드에서는 모든 곳에서 탭(Tab)을 사용하거나, 항상 4 개의 띄어쓰기를 사용해주세요.
* `function sum(nums: number[]): number`의 경우, 만약 함수가 인자를 변경하지 않는다면 `ReadonlyArray` 를 사용해주세요.
* `interface Foo { new(): Foo; }`의 경우,
이런 선언은 이 형(Type)을 가진 객체(Object)에 `new` 를 사용할 수 있도록 만듭니다. 많은 경우 여러분은 `declare class Foo { constructor(); }` 를 사용하려는 것일 겁니다.
* `const Class: { new(): IClass; }`의 경우,
`new` 를 사용할 수 있는 상수를 만드는 대신, `class Class { constructor(); }` 와 같이 클래스 선언(Class declaration)을 사용하는 게 더 좋습니다.
* `getMeAT<T>(): T`의 경우,
만일 자료형 매개변수(Type parameter)가 함수의 매개변수에 등장하지 않는다면, 그런 제너릭(Generic) 함수를 사용할 필요가 없습니다.
그 제너릭(Generic) 함수는 단순히 자료형 단언(Type assertion)을 위장시킨 것뿐입니다. 이 경우 `getMeAT() as number` 와 같이 진짜 자료형 단언(Type assertion) 을 사용하는 게 더 좋습니다.
다음은 괜찮은 제너릭(Generic)의 예시입니다. `function id<T>(value: T): T;`.
다음은 문제가 있는 제너릭(Generic)의 예시입니다. `function parseJson<T>(json: string): T;`.
예외적으로, `new Map<string, number>()` 와 같은 경우는 괜찮습니다.
* `Function` 이나 `Object` 와 같은 형(Type)을 사용하는 것은 대부분의 경우 문제를 일으킵니다. 99% 의 경우 더 구체적인 형(Type)을 사용하는게 가능합니다. [함수(Function)](http://www.typescriptlang.org/docs/handbook/functions.html#function-types) 를 위해서는 `(x: number) => number` 와 같은, 객체를 위해서는 `{ x: number, y: number }` 와 같은 형(Type)들을 사용할 수 있습니다. 형(Type)에 대한 정보가 전혀 없을 경우에는, `Object` 형(Type)이 아니라 [`any`](http://www.typescriptlang.org/docs/handbook/basic-types.html#any) 형(Type)을 사용해야 합니다. 만일 어떤 형(Type)이 객체라는 사실만 알고 있는 경우, `Object` 나 `{ [key: string]: any }` 가 아니라 [`object`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#object-type) 를 사용해주세요.
* `var foo: string | any`의 경우,
`any` 가 합 자료형(Union type)의 안에서 사용될 경우, 결과 형(Type)은 언제나 `any` 가 됩니다. 따라서 형(Type)의 `string` 부분이 유용해 보인다 하더라도, 사실은 자료형 검사(Type checking)의 측면에서 `any` 와 다른 것이 없습니다.
대신, `any`, `string`, 나 `string | object` 중 하나를 필요에 맞게 골라서 사용해주세요.
#### 패키지 삭제하기
패키지가 스스로의 형(Type)을 [포함](http://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html)하게 되면, DefinitelyTyped 에 있는 자료형(Typing) 패키지를 삭제하는 것이 좋습니다.
`npm run not-needed -- typingsPackageName asOfVersion sourceRepoURL [libraryName]` 명령어를 사용하여 자료형(Typing) 패키지를 삭제할 수 있습니다.
- `typingsPackageName` 는 삭제할 디렉토리의 이름입니다.
- `asOfVersion` 는 새 스텁(Stub) 용 `@types/foo` 를 퍼블리시(Publish)할 버전입니다. 이 버전은 현재 NPM 에 올라간 버전보다 더 높은 버전이어야 합니다.
- `sourceRepoURL` 는 자료형(Typing)을 포함하게 된 저장소의 주소입니다.
- `libraryName` 는 패키지의 이름을 읽기 쉽게 쓴 것입니다. 즉, "angular2" 대신에 "Angular 2" 와 같이 쓰는 것이 좋습니다. (생략했을 경우에는 "typingsPackageName" 와 같은 것으로 취급됩니다.)
DefinitelyTyped 의 다른 패키지들이 삭제된 자료형(Typing) 패키지를 사용하고 있을 경우, 형(Type)을 포함하기 시작한 원래 패키지를 사용하도록 수정해야합니다. 삭제된 자료형(Typing) 패키지를 사용하는 각 DefinitelyTyped 패키지들의 `package.json` 파일에 `"dependencies": { "foo": "x.y.z" }` 를 추가해주시면 됩니다.
DefinitelyTyped 에 한 번도 올라온 적 없는 패키지가 형(Type)을 포함하게 되었다면, `notNeededPackages.json` 파일에 추가할 필요도 없습니다.
#### 린트(Lint)하기
자료형(Typing) 패키지를 린트(Lint)하려면, 패키지 디렉토리에 `{ "extends": "dtslint/dt.json" }` 를 포함하고 있는 `tslint.json` 파일을 추가해주시면 됩니다. 모든 새 패키지는 해당 파일을 가지고 있어야 합니다.
고쳐야 하지만 아직 고쳐지지 않은 린트(Lint) 결과가 있을 때에만 `tslint.json` 에서 린트 규칙(Lint rule)을 사용하지 않도록 설정할 수 있습니다. 예를 들어,
```js
{
"extends": "dtslint/dt.json",
"rules": {
// 이 패키지는 Function 형을 사용하고 있으며, 고치는 게 쉽지 않다.
"ban-types": false
}
}
```
(린트 규칙(Lint rule)이 절대로 적용되서는 안되는 경우에는, `// tslint:disable rule-name` 나 `//tslint:disable-next-line rule-name` 를 사용하는 것이 좋습니다. 후자가 더 나은 방식입니다.)
어떤 표현식(Expression)이 특정한 형(Type)을 가진다고 단언(Assert)하고 싶을 때에는 `$ExpectType` 를 사용하시면 됩니다. 어떤 표현식(Expression)이 컴파일에 실패해야하는 경우에는 `$ExpectError` 를 하시면 됩니다.
```js
// $ExpectType void
f(1);
// $ExpectError
f("one");
```
[dtslint](https://github.com/Microsoft/dtslint#write-tests) 저장소의 README 파일에서 더 자세한 내용을 확인하실 수 있습니다.
이런 테스트들은 `npm run lint package-name` 명령으로 실행해볼 수 있습니다. 이 때, `package-name` 은 테스트하고 싶은 패키지의 이름입니다.
테스트 스크립트는 [dtslint](https://github.com/Microsoft/dtslint) 를 사용하고 있습니다.
## 자주 하는 질문들
#### 이 저장소와 `@types` 패키지들이 대체 무슨 관계가 있는 건가요?
`master` 브랜치(Branch)의 내용들이 [types-publisher](https://github.com/Microsoft/types-publisher) 를 사용해 자동으로 `@types` 퍼블리시(Publish)됩니다.
#### 풀 리퀘스트(Pull request)를 제출했습니다. 이게 합쳐질 때까지 얼마나 걸리나요?
상황에 따라 다르지만, 대부분의 풀 리퀘스트(Pull request)들은 일주일 안에 합쳐집니다. 머릿주석에 있는 저자 중 한명에 의해 승인된 풀 리퀘스트(Pull request)는 보통 더 빨리 합쳐집니다. 새로운 패키지에 대한 풀 리퀘스트(Pull request)는 관리자의 세세한 코드 리뷰를 필요로 하기 때문에 더 오래 걸리는 경우가 많습니다. 각 PR 들은 합쳐지기 전에 TypeScript or DefinitelyTyped 팀 구성원의 코드 리뷰를 받아야 하며, 이는 사람이 하는 일이기 때문에 느려질 수도 있으니 양해를 바랍니다. [풀 리퀘스트 번다운 보드(PR Burndown Board)](https://github.com/DefinitelyTyped/DefinitelyTyped/projects/3?card_filter_query=is%3Aopen)에서 열린 풀 리퀘스트에 대한 관리자들의 진행도를 확인하실 수 있습니다.
#### 내 풀 리퀘스트(Pull request)는 합쳐졌습니다. 언제 NPM 에 `@types` 패키지가 갱신되나요?
NPM 의 패키지들은 수시간 안에 갱신될 겁니다. 만약 24 시간이 지나도 갱신되지 않으면, 문제를 파악하기 위해 @RyanCavanaugh 나 @andy-ms 를 풀 리퀘스트(Pull request)에서 호출해주세요.
#### 다른 자료형 정의(Type definition)에 의존하는 자료형 정의(Type definition)을 만들고 있습니다. `<reference types="" />` 와 임포트(import) 중 무엇을 사용해야하나요?
외부 모듈(`export` 를 사용하는 모듈)을 사용할 경우, 임포트(import)를 사용해주세요.
환경과 관련된 모듈(ambient module)(`declare module` 를 쓰거나 전역 변수들을 선언한 모듈)을 사용할 경우, `<reference types="" />` 를 사용해주세요.
#### `package.json` 파일이 가끔 보이던데?
일반적으로는 `package.json` 파일을 사용할 필요가 없습니다. 패키지가 퍼블리시(Publish)될 때 패키지를 위한 `package.json` 파일은 자동으로 생성됩니다.
가끔 보이는 `package.json` 파일은 의존하는 것들을 표시하기 위해 사용됩니다. [예시](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/pikaday/package.json)를 한 번 보세요.
의존성을 제외한 다른 필드(Field)들, 그러니까 `"description"` 같은 것들은 사용해서는 안됩니다.
옛날 `@types` 패키지를 사용하고 싶으실 경우에도 `"dependencies": { "@types/foo": "x.y.z" }` 와 같은 내용을 `package.json` 파일에 넣으셔야 합니다.
#### 어떤 패키지들에 `tslint.json` 이 없거나, `tsconfig.json` 에 `"noImplicitAny": true`, `"noImplicitThis": true`, 나 `"strictNullChecks": true` 가 없어요.
그럼 그 패키지들이 잘못된 겁니다. 고쳐서 풀 리퀘스트(Pull request)를 제출해주시면 고맙겠습니다.
#### 자료형 정의(Type definition)을 요청할 수 있나요?
이미 요청된 자료형 정의(Type definition)들을 [여기서](https://github.com/DefinitelyTyped/DefinitelyTyped/labels/Definition%3ARequest) 보실 수 있습니다.
#### DOM 을 위한 자료형 정의(Type definitions)는요?
웹 표준(Web standard)과 관련이 있는 자료형(Typing)들은 [TSJS-lib-generator](https://github.com/Microsoft/TSJS-lib-generator) 저장소에 기여해서 고치실 수 있습니다. 고쳐진 자료형(Typing)은 `lib.dom.d.ts` 파일에 포함될 겁니다.
#### 어떤 패키지가 `export =` 를 쓰고 있는데, 저는 디폴트 임포트(Default import)가 더 좋습니다. `export =` 를 `export default` 로 바꿔도 되나요?
타입스크립트(TypeScript) 2.7 이상을 사용하고 계시면 프로젝트 안에서 `--esModuleInterop` 를 사용해주세요.
그 이하의 경우, 디폴트 임포트(Default import)가 동작하는 환경(Webpack, SystemJS, esm)에서 작업 중이시면 [`--allowSyntheticDefaultImports`](http://www.typescriptlang.org/docs/handbook/compiler-options.html) 를 사용하는 걸 고려해보세요.
자료형 정의(Type definition)가 맞는 경우에는 자료형 정의(Type definition)을 수정하지 마세요.
NPM 패키지의 경우, `node -p 'require("foo")'` 가 원하는 값이라면 `export =` 이 맞고, `node -p 'require("foo").default'` 이 원하는 값이라면 `export default` 이 맞습니다.
#### 자료형 선언(Type declaration)에서 타입스크립트(TypeScript) 2.1 이상의 기능을 사용하고 싶습니다.
정의(Definition) 머릿주석(`// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped`) 뒤에 `// TypeScript Version: 2.1` 를 추가해주시면 됩니다.
#### 타입스크립트(TypeScript)에 기본으로 포함되지 않은 DOM API 를 추가하고 싶어요.
[TSJS-Lib-Generator](https://github.com/Microsoft/TSJS-lib-generator#readme) 저장소가 관련되어있을 가능성이 있습니다. 해당 저장소의 안내를 따라주세요.
해당 표준이 아직 초안인 상태라면, 이 저장소와 관련된 일입니다.
`dom-` 으로 시작하는 패키지를 만드신 뒤, "Project" 머릿주석 부분에 해당 표준의 링크를 써 주세요.
다만 표준이 초안을 벗어나면 DefinitelyTyped 에서 삭제되고 `@types` 패키지가 지원이 중단된(Deprecated) 것으로 표시될 수도 있습니다.
#### 패키지를 새 메이저 버전(major version)에 맞게 갱신하고 싶어요.
옛날 버전도 계속해서 수정할 예정이라면, 이전 버전에 해당하는 새 디렉토리(예를 들어 `2.` 버전을 위해서는 `v2`)를 만들고 현재 파일들을 그 디렉토리로 옮겨야 합니다. 새 디렉토리로 옮긴 뒤에는
1. `tsconfig.json` 와 `tslint.json` 에 포함된 상대경로들을 수정해주어야 합니다.
2. 경로 대응 규칙(Path mapping rule)을 추가하여 테스트가 올바른 버전을 검사하도록 해야합니다.
예를 들어, [history 패키지의 2 버전의 `tsconfig.json`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/history/v2/tsconfig.json) 파일은 다음과 같이 생겼습니다.
```json
{
"compilerOptions": {
"baseUrl": "../../",
"typeRoots": ["../../"],
"paths": {
"history": [ "history/v2" ]
},
},
"files": [
"index.d.ts",
"history-tests.ts"
]
}
```
수정 중인 패키지에 의존하는 DefinitelyTyped 의 다른 패키지들이 새 버전과 호환되지 않을 경우, 그 패키지들에도 옛날 버전으로의 경로 대응 규칙(Path mapping rule)을 추가해주어야 합니다. 수정 중인 패키지에 의존하는 패키지에 의존하는 패키지들에도 똑같은 작업을 해 주셔야 합니다.
예를 들어, `react-router` 패키지는 `history@2` 패키지에 의존하고 있기 때문에, [react-router 패키지의 `tsconfig.json`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react-router/tsconfig.json) 파일이 `"history": [ "history/v2" ]` 와 같은 경로 대응 규칙(Path mapping rule)을 가지고 있는 걸 볼 수 있습니다.
이어서 (`react-router` 패키지에 의존하는 패키지인) `react-router-bootstrap` 또한 [tsconfig.json](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react-router-bootstrap/tsconfig.json) 파일 안에 경로 대응 규칙(Path mapping rule)을 가지고 있는 것을 보실 수 있습니다.
`/// <reference types=".." />` 에서는 경로 대응 규칙(Path mapping rule)이 동작하지 않기 때문에, DefinitelyTyped 패키지로에 의존할 때에는 임포트(import) 를 사용해야 합니다.
#### 전역적으로도 모듈로도 사용될 수 있는 패키지의 자료형 선언(Type declaration)은 어떻게 쓰나요?
타입스크립트 안내서(TypeScript Handbook)은 [선언(Declaration)을 쓰는 방법에 대한 전반적인 정보](https://www.typescriptlang.org/docs/handbook/declaration-files/introduction.html)와 [예시들](https://www.typescriptlang.org/docs/handbook/declaration-files/templates/global-modifying-module-d-ts.html)을 포함하고 있습니다. 이 내용에는 ES6 식의 모듈 문법을 사용할 수 있는 자료형 선언(Type declaration)을 만드는 방법과 객체를 전역에서 사용할 수 있도록 하는 방법이 포함되어 있습니다. [big.js 패키지의 자료형 선언(Type declaration)](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/big.js/index.d.ts)이 실례입니다. 이 패키지는 웹 페이지의 스크립트 태그를 사용해 불러올 수 있으며, 또한 ES6 식의 임포트(Import) 구문을 사용해서 불러올 수도 있습니다.
여러분의 패키지가 임포트(Import) 구문을 사용했을 때와 전역적으로 불렀을 때를 테스트 해보고 싶다면, `test` 디렉토리를 추가하고 `YourLibraryName-global.test.ts` 그리고 `YourLibraryName-module.test.ts` 라는 이름으로 테스트 파일 두 개를 추가해주세요. **전역(Global)** 테스트 파일은 웹 페이지에서 전역적으로 사용될 때를 테스트하는 파일입니다. 이 파일에서는 임포트(Import) 구문을 사용하지 않아야 합니다. **모듈(Module)** 테스트 파일은 임포트(Import) 구문을 사용할 때를 테스트 하는 파일입니다. 만약 여러분의 `tsconfig.json` 파일이 `files` 필드(Field)를 가지고 있다면, 이 필드(Field)는 반드시 두 테스트 파일을 모두 포함해야 합니다. [이 방식을 사용하는 실례](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/big.js/test) 또한 big.js 패키지의 자료형 선언(Type declaration)에서 확인해보실 수 있습니다.
각각의 테스트 파일에 모든 상황을 테스트할 필요는 없다는 걸 잊지마세요. 전역 테스트 파일에서는 전역적으로 사용될 때만 테스트하고, 모듈 테스트 파일에서 나머지 상황들을 모두 테스트 할 수 있으며, 그 반대의 경우도 괜찮습니다.
#### 지역 패키지(Scoped package)의 경우는 어떻게 하죠?
`@foo/bar` 패키지와 같은 지역 패키지(Scoped package)를 위한 자료형 패키지(Type package)는 `types/foo__bar` 디렉토리에 추가하면 됩니다. 밑줄 문자가 두 번 있는 것에 주의하세요.
지역 패키지(Scoped package)를 위한 자료형 패키지(Type package)를 생성하기 위해 `dts-gen` 를 사용한 경우에는,
다음과 같이 생성된 `tsconfig.json` 안에 지역 패키지(Scoped package)를 위한 적절한 경로 대응 규칙(Path mapping rule)을 추가해주어야 합니다.
```json
{
"paths":{
"@foo/bar": ["foo__bar"]
}
}
```
#### 깃헙(GitHub)이 보여주는 파일 히스토리(History)가 불완전해요.
깃헙은 이름이 바뀐 파일의 히스토리(History)를 [지원하지 않습니다](http://stackoverflow.com/questions/5646174/how-to-make-github-follow-directory-history-after-renames). 대신 [`git log --follow`](https://www.git-scm.com/docs/git-log) 명령을 사용하세요.
#### ES6 에서 사용하는 임포트(Import)를 사용하기 위해 모듈을 익스포트(Export)하지 않는 패키지들에 빈 이름공간을 추가해야 하나요?
[chai-http](https://github.com/chaijs/chai-http) 패키지와 같은 몇몇 패키지들은 함수를 익스포트(Export)합니다.
이런 패키지들을 `import * as foo from "foo";` 와 같이 임포트(Import)하면 다음과 같은 오류가 발생합니다.
> error TS2497: Module 'foo' resolves to a non-module entity and cannot be imported using this construct
이 오류는 함수의 이름과 똑같은 빈 이름공간(Namespace)을 정의해서 없앨 수 있으나, 좋은 방법은 아닙니다.
[스택오버플로(Stack Overflow)의 이 질문의 답변](https://stackoverflow.com/questions/39415661/what-does-resolves-to-a-non-module-entity-and-cannot-be-imported-using-this)이 이 문제와 관련되어 자주 언급됩니다.
`import foo = require("foo");` 를 사용하여 모듈을 임포트(Import)하거나, 환경에서 ES6 모듈 변환(Module interop)을 지원한다면 `--allowSyntheticDefaultImports` 와 함께 `import foo from "foo";` 같은 디폴트 임포트(Default import)를 사용하는 것이 더 나은 방법입니다.
## 라이센스
이 프로젝트는 MIT license 가 적용되어 있습니다.
각 자료형 정의(Type definition) 파일들의 저작권은 각 기여자들에게 있으며, 기여자들은 해당 자료형 정의(Type definition) 파일들의 맨 위에 나열되어 있습니다.
[![Analytics](https://ga-beacon.appspot.com/UA-47495295-4/borisyankov/DefinitelyTyped)](https://github.com/igrigorik/ga-beacon)
+134 -29
View File
@@ -1,12 +1,23 @@
# DefinitelyTyped [![Build Status](https://travis-ci.org/DefinitelyTyped/DefinitelyTyped.svg?branch=master)](https://travis-ci.org/DefinitelyTyped/DefinitelyTyped)
[![Join the chat at https://gitter.im/borisyankov/DefinitelyTyped](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/borisyankov/DefinitelyTyped?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
# DefinitelyTyped
> The repository for *high quality* TypeScript type definitions.
Also see the [definitelytyped.org](http://definitelytyped.org) website, although information in this README is more up-to-date.
*[You can also read this README in Spanish!](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/README.es.md)*
*You can also read this README in [Spanish](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/README.es.md), [Korean](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/README.ko.md), and [Russian](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/README.ru.md)!*
## Current status
This section tracks the health of the repository and publishing process.
It may be helpful for contributors experiencing any issues with their PRs and packages.
* All packages are [type-checking/linting](https://github.com/Microsoft/dtslint) cleanly: [![Build Status](https://travis-ci.org/DefinitelyTyped/DefinitelyTyped.svg?branch=master)](https://travis-ci.org/DefinitelyTyped/DefinitelyTyped)
* All packages are being [published to npm](https://github.com/Microsoft/types-publisher) in under an hour: [![Publish Status](https://typescript.visualstudio.com/TypeScript/_apis/build/status/sandersn.types-publisher-watchdog)](https://typescript.visualstudio.com/TypeScript/_build/latest?definitionId=13)
* [typescript-bot](https://github.com/typescript-bot) has been active on DefinitelyTyped [![Activity Status](https://typescript.visualstudio.com/TypeScript/_apis/build/status/sandersn.typescript-bot-watchdog)](https://typescript.visualstudio.com/TypeScript/_build/latest?definitionId=14)
If anything here seems wrong, or any of the above are failing, please raise an issue in [the DefinitelyTyped Gitter channel](https://gitter.im/DefinitelyTyped/DefinitelyTyped).
[![Join the chat at https://gitter.im/DefinitelyTyped/DefinitelyTyped](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/DefinitelyTyped/DefinitelyTyped?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
## What are declaration files?
@@ -169,8 +180,14 @@ If a package was never on DefinitelyTyped, it does not need to be added to `notN
#### Lint
To lint a package, just add a `tslint.json` to that package containing `{ "extends": "dtslint/dt.json" }`. All new packages must be linted.
If a `tslint.json` turns rules off, this is because that hasn't been fixed yet. For example:
All new packages must be linted. To lint a package, add a `tslint.json` to that package containing
```js
{
"extends": "dtslint/dt.json"
}
```
This should be the only content in a finished project's `tslint.json` file. If a `tslint.json` turns rules off, this is because that hasn't been fixed yet. For example:
```js
{
@@ -212,7 +229,7 @@ It depends, but most pull requests will be merged within a week. PRs that have b
#### My PR is merged; when will the `@types` NPM package be updated?
NPM packages should update within a few hours. If it's been more than 24 hours, ping @RyanCavanaugh and @andy-ms on the PR to investigate.
NPM packages should update within a few minutes. If it's been more than an hour, mention the PR number on [the DefinitelyTyped Gitter channel](https://gitter.im/DefinitelyTyped/DefinitelyTyped) and the current maintainer will get the correct team member to investigate.
#### I'm writing a definition that depends on another definition. Should I use `<reference types="" />` or an import?
@@ -238,17 +255,71 @@ Here are the [currently requested definitions](https://github.com/DefinitelyType
If types are part of a web standard, they should be contributed to [TSJS-lib-generator](https://github.com/Microsoft/TSJS-lib-generator) so that they can become part of the default `lib.dom.d.ts`.
#### Should I add an empty namespace to a package that doesn't export a module to use ES6 style imports?
Some packages, like [chai-http](https://github.com/chaijs/chai-http), export a function.
Importing this module with an ES6 style import in the form `import * as foo from "foo";` leads to the error:
> error TS2497: Module 'foo' resolves to a non-module entity and cannot be imported using this construct
This error can be suppressed by merging the function declaration with an empty namespace of the same name, but this practice is discouraged.
This is a commonly cited [Stack Overflow answer](https://stackoverflow.com/questions/39415661/what-does-resolves-to-a-non-module-entity-and-cannot-be-imported-using-this) regarding this matter.
It is more appropriate to import the module using the `import foo = require("foo");` syntax.
Nevertheless, if you want to use a default import like `import foo from "foo";` you have two options:
- you can use the [`--allowSyntheticDefaultImports` compiler option](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-1-8.html#support-for-default-import-interop-with-systemjs) if your module runtime supports an interop scheme for non-ECMAScript modules, i.e. if default imports work in your environment (e.g. Webpack, SystemJS, esm).
- you can use the [`--esModuleInterop` compiler option](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-7.html#support-for-import-d-from-cjs-form-commonjs-modules-with---esmoduleinterop) if you want TypeScript to take care of non-ECMAScript interop (since Typescript 2.7).
#### A package uses `export =`, but I prefer to use default imports. Can I change `export =` to `export default`?
If you are using TypeScript 2.7 or later, use `--esModuleInterop` in your project.
Otherwise, if default imports work in your environment (e.g. Webpack, SystemJS, esm), consider turning on the [`--allowSyntheticDefaultImports`](http://www.typescriptlang.org/docs/handbook/compiler-options.html) compiler option.
Like in the previous question, refer to using either the [`--allowSyntheticDefaultImports`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-1-8.html#support-for-default-import-interop-with-systemjs)
or [`--esModuleInterop`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-7.html#support-for-import-d-from-cjs-form-commonjs-modules-with---esmoduleinterop)
compiler options.
Do not change the type definition if it is accurate.
For an NPM package, `export =` is accurate if `node -p 'require("foo")'` is the export, and `export default` is accurate if `node -p 'require("foo").default'` is the export.
For an NPM package, `export =` is accurate if `node -p 'require("foo")'` works to import a module, and `export default` is accurate if `node -p 'require("foo").default'` works to import a module.
#### I want to use features from TypeScript 2.1 or above.
Then you will have to add a comment to the last line of your definition header (after `// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped`): `// TypeScript Version: 2.1`.
#### I want to use features from TypeScript 3.1 or above.
You can use the same `// TypeScript Version: 3.1` comment as above.
However, if your project needs to maintain types that are compatible with 3.1 and above *at the same time as* types that are compatible with 3.0 or below, you will need to use the `typesVersions` feature, which is available in TypeScript 3.1 and above.
You can find a detailed explanation of this feature in the [official TypeScript documentation](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-1.html#version-selection-with-typesversions).
Here's a short explanation to get you started:
1. You'll have to add a `package.json` file to your package definition, with the following contents:
```json
{
"private": true,
"types": "index",
"typesVersions": {
">=3.1.0-0": { "*": ["ts3.1/*"] }
}
}
```
2. Create the sub-directory mentioned in the `typesVersions` field inside your types directory (`ts3.1/` in this example)
and add the types and tests specific for the new TypeScript version. You don't need the typical definition header
in any of the files from the `ts3.1/` directory.
3. Set the `baseUrl` and `typeRoots` options in `ts3.1/tsconfig.json` to the correct paths, they should look something like this:
```json
{
"compilerOptions": {
"baseUrl": "../../",
"typeRoots": ["../../"]
}
}
```
You can look [here](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/debounce-promise) and [here](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/create-html-element) for examples.
#### I want to add a DOM API not present in TypeScript by default.
This may belong in [TSJS-Lib-Generator](https://github.com/Microsoft/TSJS-lib-generator#readme). See the guidelines there.
@@ -256,14 +327,60 @@ If the standard is still a draft, it belongs here.
Use a name beginning with `dom-` and include a link to the standard as the "Project" link in the header.
When it graduates draft mode, we may remove it from DefinitelyTyped and deprecate the associated `@types` package.
#### I want to update a package to a new major version
#### How do DefinitelyTyped package versions relate to versions of the corresponding library?
If you intend to continue updating the older version of the package, you may create a new subfolder with the current version e.g. `v2`, and copy existing files to it. If so, you will need to:
_NOTE: The discussion in this section assumes familiarity with [Semantic versioning](https://semver.org/)_
Each DefinitelyTyped package is versioned when published to NPM.
The [types-publisher](https://github.com/Microsoft/types-publisher) (the tool that publishes `@types` packages to npm) will set the declaration package's version by using the `major.minor` version number listed in the first line of its `index.d.ts` file.
For example, here are the first few lines of [Node's type declarations](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/1253faabf5e0d2c5470db6ea87795d7f96fef7e2/types/node/index.d.ts) for version `10.12.x` at the time of writing:
```js
// Type definitions for Node.js 10.12
// Project: http://nodejs.org/
// Definitions by: Microsoft TypeScript <https://github.com/Microsoft>
// DefinitelyTyped <https://github.com/DefinitelyTyped>
// Alberto Schiabel <https://github.com/jkomyno>
```
Because `10.12` is at the end the first line, the npm version of the `@types/node` package will also be `10.12.x`.
Note that the first-line comment in the `index.d.ts` file should only contain the `major.minor` version (e.g. `10.12`) and should not contain a patch version (e.g. `10.12.4`).
This is because only the major and minor release numbers are aligned between library packages and type declaration packages.
The patch release number of the type declaration package (e.g. `.0` in `10.12.0`) is initialized to zero by DefinitelyTyped and is incremented each time a new `@types/node` package is published to NPM for the same major/minor version of the corresponding library.
Sometimes type declaration package versions and library package versions can get out of sync.
Below are a few common reasons why, in order of how much they inconvenience users of a library.
Only the last case is typically problematic.
* As noted above, the patch version of the type declaration package is unrelated to the library patch version.
This allows DefinitelyTyped to safely update type declarations for the same major/minor version of a library.
* If updating a package for new functionality, don't forget to update the version number to line up with that version of the library.
If users make sure versions correspond between JavaScript packages and their respective `@types` packages, then `npm update` should typically just work.
* It's common for type declaration package updates to lag behind library updates because it's often library users, not maintainers, who update DefinitelyTyped when new library features are released.
So there may be a lag of days, weeks, or even months before a helpful community member sends a PR to update the type declaration package for a new library release.
If you're impacted by this, you can be the change you want to see in the world and you can be that helpful community member!
:exclamation: If you're updating type declarations for a library, always set the `major.minor` version in the first line of `index.d.ts` to match the library version that you're documenting! :exclamation:
#### If a library is updated to a new major version with breaking changes, how should I update its type declaration package?
[Semantic versioning](https://semver.org/) requires that versions with breaking changes must increment the major version number.
For example, a library that removes a publicly exported function after its `3.5.8` release must bump its version to `4.0.0` in its next release.
Furthermore, when the library's `4.0.0` release is out, its DefinitelyTyped type declaration package should also be updated to `4.0.0`, including any breaking changes to the library's API.
Many libraries have a large installed base of developers (including maintainers of other packages using that library as a dependency) who won't move right away to a new version that has breaking changes, because it might be months until a maintainer has time to rewrite code to adapt to the new version.
In the meantime, users of old library versions still may want to update type declarations for older versions.
If you intend to continue updating the older version of a library's type declarations, you may create a new subfolder (e.g. `/v2/`) named for the current (soon to be "old") version, and copy existing files from the current version to it.
Because the root folder should always contain the type declarations for the latest ("new") version, you'll need to make a few changes to the files in your old-version subdirectory to ensure that relative path references point to the subdirectory, not the root.
1. Update the relative paths in `tsconfig.json` as well as `tslint.json`.
2. Add path mapping rules to ensure that tests are running against the intended version.
For example [history v2 `tsconfig.json`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/history/v2/tsconfig.json) looks like:
For example, the [`history`](https://github.com/ReactTraining/history/) library introduced breaking changes between version `2.x` and `3.x`.
Because many users still consumed the older `2.x` version, a maintainer who wanted to update the type declarations for this library to `3.x` added a `v2` folder inside the history repository that contains type declarations for the older version.
At the time of writing, the [history v2 `tsconfig.json`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/1253faabf5e0d2c5470db6ea87795d7f96fef7e2/types/history/v2/tsconfig.json) looks roughly like:
```json
{
@@ -281,10 +398,11 @@ For example [history v2 `tsconfig.json`](https://github.com/DefinitelyTyped/Defi
}
```
If there are other packages on DefinitelyTyped that are incompatible with the new version, you will need to add path mappings to the old version. You will also need to do this for packages depending on packages depending on the old version.
If there are other packages in DefinitelyTyped that are incompatible with the new version, you will need to add path mappings to the old version.
You will also need to do this recursively for packages depending on packages depending on the old version.
For example, `react-router` depends on `history@2`, so [react-router `tsconfig.json`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react-router/tsconfig.json) has a path mapping to `"history": [ "history/v2" ]`;
transitively `react-router-bootstrap` (which depends on `react-router`) also adds a path mapping in its [tsconfig.json](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react-router-bootstrap/tsconfig.json).
For example, `react-router` depends on `history@2`, so [react-router `tsconfig.json`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react-router/v2/tsconfig.json) has a path mapping to `"history": [ "history/v2" ]`.
Transitively, `react-router-bootstrap` (which depends on `react-router`) also needed to add the same path mapping (`"history": [ "history/v2" ]`) in its `tsconfig.json` until its `react-router` dependency was updated to the latest version.
Also, `/// <reference types=".." />` will not work with path mapping, so dependencies must use `import`.
@@ -316,19 +434,6 @@ When `dts-gen` is used to scaffold a scoped package, the `paths` property has to
GitHub doesn't [support](http://stackoverflow.com/questions/5646174/how-to-make-github-follow-directory-history-after-renames) file history for renamed files. Use [`git log --follow`](https://www.git-scm.com/docs/git-log) instead.
#### Should I add an empty namespace to a package that doesn't export a module to use ES6 style imports?
Some packages, like [chai-http](https://github.com/chaijs/chai-http), export a function.
Importing this module with an ES6 style import in the form `import * as foo from "foo";` leads to the error:
> error TS2497: Module 'foo' resolves to a non-module entity and cannot be imported using this construct
This error can be suppressed by merging the function declaration with an empty namespace of the same name, but this practice is discouraged.
This is a commonly cited [Stack Overflow answer](https://stackoverflow.com/questions/39415661/what-does-resolves-to-a-non-module-entity-and-cannot-be-imported-using-this) regarding this matter.
It is more appropriate to import the module using the `import foo = require("foo");` syntax, or to use a default import like `import foo from "foo";` if using the `--allowSyntheticDefaultImports` flag if your module runtime supports an interop scheme for non-ECMAScript modules as such.
## License
This project is licensed under the MIT license.
+353
View File
@@ -0,0 +1,353 @@
<!-- markdownlint-disable MD001 MD012 MD026 -->
# DefinitelyTyped [![Build Status](https://travis-ci.org/DefinitelyTyped/DefinitelyTyped.svg?branch=master)](https://travis-ci.org/DefinitelyTyped/DefinitelyTyped)
[![Join the chat at https://gitter.im/borisyankov/DefinitelyTyped](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/borisyankov/DefinitelyTyped?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
> Репозиторий для *высококачественных* определений типов TypeScript.
Также посетите веб-сайт [definitelytyped.org](http://definitelytyped.org), хотя информация в этом README более свежая.
*Вы также можете прочитать этот README на [английском](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/README.md), [испанском](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/README.es.md) и [корейском](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/README.ko.md).*
## Что такое файлы декларации (файлы описания/объявления типов)?
Смотрите [руководство по TypeScript](http://www.typescriptlang.org/docs/handbook/declaration-files/introduction.html).
## Как их получить?
### npm
Это предпочтительный метод. Это доступно только для пользователей TypeScript 2.0+. Например:
```sh
npm install --save-dev @types/node
```
Затем типы должны автоматически включаться компилятором.
Подробнее смотрите в [справочнике](http://www.typescriptlang.org/docs/handbook/declaration-files/consumption.html).
Для пакета NPM "foo", описания будут находиться в "@types/foo".
Если вы не можете найти свой пакет, ищите его в [TypeSearch](https://microsoft.github.io/TypeSearch/).
Если вы все еще не можете найти его, проверьте [включает](http://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html) ли пакет собственную типизацию.
Обычно это отражается в поле `"types"` или `"typings"` файла `package.json`, или просто ищите любые файлы ".d.ts" в пакете и вручную включайте их в `/// <reference path="" />`.
### Другие методы
Эти методы могут быть использованы TypeScript 1.0.
* [Typings](https://github.com/typings/typings)
* ~~[NuGet](http://nuget.org/packages?q=DefinitelyTyped)~~ (используйте предпочтительные альтернативы, публикация типа nuget DT отключена)
* Вручную загрузите из ветки `master` этого репозитория
Возможно, вам придется добавить ручные [ссылки](http://www.typescriptlang.org/docs/handbook/triple-slash-directives.html).
## Как я могу внести свой вклад?
DefinitelyTyped работает только благодаря вкладу таких пользователей, как вы!
### Тестирование
Прежде чем поделиться своим улучшением с миром, используйте его сами.
#### Тестирование редактирования существующего пакета
Для добавления новых функций вы можете использовать [разрешение модулей](http://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation).
Вы также можете напрямую редактировать типы в `node_modules/@types/foo/index.d.ts`, или скопировать их оттуда и выполнить следующие шаги.
#### Тестирование ногово пакета
Добавьте к вашему `tsconfig.json`:
```json
"baseUrl": "types",
"typeRoots": ["types"],
```
(Вы также можете использовать `src/types`.)
Создайте `types/foo/index.d.ts` содержащие объявления для модуля "foo".
Теперь вы сможете импортировать из `"foo"` в свой код, и он будет направлен к новому определению типа.
Затем запустите сборку (build) *и* запустите код, чтобы убедиться, что ваше определение типа действительно соответствует тому, что происходит во время выполнения.
После того как вы проверили свои определения с реальным кодом, создайте [Запрос на принятие изменений (PR)](#make-a-pull-request)
и следуйте инструкциям [чтобы отредактировать существующий](#edit-an-existing-package) или
[создать новый пакет](#create-a-new-package).
### Запрос на принятие изменений (PR)
После того, как вы проверили ваш пакет, вы можете поделиться им с DefinitelyTyped.
Во-первых, [разветвите](https://guides.github.com/activities/forking/) этот репозиторий, установите [node](https://nodejs.org/), и запустите `npm install`.
#### Изменение существующего пакета
* `cd types/my-package-to-edit`
* Внесите изменения. Не забудьте отредактировать тесты.
Если вы вносите критические изменения, не забудьте [обновить основную версию](#i-want-to-update-a-package-to-a-new-major-version).
* Вы также можете добавить себя в раздел "Definitions by" заголовка пакета.
* Это приведет к тому, что вы будете уведомлены (через ваше имя пользователя GitHub) о том, что кто-то делает запрос на принятие изменений (PR) или проблему с пакетом.
* Сделайте это, добавив свое имя в конец строки, например `// Definitions by: Alice <https://github.com/alice>, Bob <https://github.com/bob>`.
* Или, если есть больше людей, это может быть многострочным
```typescript
// Definitions by: Alice <https://github.com/alice>
// Bob <https://github.com/bob>
// Steve <https://github.com/steve>
// John <https://github.com/john>
```
* Если есть `tslint.json`, запустите `npm run lint package-name`. В противном случае запустите `tsc` в директории пакета.
Когда вы создаете PR для редактирования существующего пакета, `dt-bot` должен @-уведомить
предыдущих авторов. Если этого не произойдет, вы можете сделать это самостоятельно в комментарии, связанном с PR.
#### Созданое нового пакета
Если вы являетесь автором библиотеки и ваш пакет написан на TypeScript, [свяжите автоматически сгенерированные файлы объявлений](http://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html) в вашем пакете, а не публикуйте в DefinitelyTyped.
Если вы добавляете типизацию для пакета NPM, создайте директорию с тем же именем.
Если пакет, для которого вы добавляете типизацию, отсутствует в NPM, убедитесь, что выбранное вами имя не конфликтует с именем пакета в NPM.
(Вы можете использовать `npm info foo` чтобы проверить наличие пакета `foo`.)
Ваш пакет должен иметь такую ​​структуру:
| Файл | Назначение |
| ------------- | ---------------------------------------------------------------------------------------------------- |
| index.d.ts | Содержит типизацию для пакета. |
| foo-tests.ts | Содержит пример кода, который проверяет типизацию. Этот код *не* запускается, но он проверен на тип. |
| tsconfig.json | Позволяет вам запускать `tsc` внутри пакета. |
| tslint.json | Включает linting. |
Создайте их, запустив `npx dts-gen --dt --name my-package-name --template module` если у вас npm ≥ 5.2.0, `npm install -g dts-gen` и `dts-gen --dt --name my-package-name --template module` в противном случае.
Посмотреть все варианты на [dts-gen](https://github.com/Microsoft/dts-gen).
Вы можете отредактировать `tsconfig.json` чтобы добавить новые файлы, добавить `"target": "es6"` (необходимо для асинхронных функций), добавить в `"lib"`, или добавить опцию компилятора `"jsx"`.
Члены группы DefinitelyTyped регулярно следят за новыми PR, но имейте в виду, что количество других PR может замедлить ход событий.
Хороший пример пакета смотрите [base64-js](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/base64-js).
#### Распространенные ошибки
* Сначала следуйте советам из справочника [handbook](http://www.typescriptlang.org/docs/handbook/declaration-files/do-s-and-don-ts.html).
* Форматирование: либо используйте все табы, либо всегда используйте 4 пробела.
* `function sum(nums: number[]): number`: используйте `ReadonlyArray` если функция не записывает свои параметры.
* `interface Foo { new(): Foo; }`:
Это определяет тип объектов, с методом `new`. Вы, вероятно, хотите объявить `declare class Foo { constructor(); }`.
* `const Class: { new(): IClass; }`:
Предпочитайте использовать объявление класса `class Class { constructor(); }` вместо `new`.
* `getMeAT<T>(): T`:
Если параметр типа не отображается в типах каких-либо параметров, у вас нет универсальной функции, а просто замаскированное утверждение типа.
Предпочитайте использовать утверждение реального типа, например, `getMeAT() as number`.
Пример, где допустим параметр типа: `function id<T>(value: T): T;`.
Пример, где это недопустимо: `function parseJson<T>(json: string): T;`.
Исключение: `new Map<string, number>()` все ОК.
* Использование типов `Function` and `Object` почти никогда не является хорошей идеей. В 99% случаев можно указать более конкретный тип. Примеры: `(x: number) => number` для [функций](http://www.typescriptlang.org/docs/handbook/functions.html#function-types) and `{ x: number, y: number }` для объектов. Если нет никакой уверенности в типе, [`any`](http://www.typescriptlang.org/docs/handbook/basic-types.html#any) является правильным выбором, а не `Object`. Если единственным известным фактом о типе является то, что это какой-то объект, используйте тип [`object`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#object-type), а не `Object` или `{ [key: string]: any }`.
* `var foo: string | any`:
когда `any` используется в типе объединения, результирующий тип все еще `any`. Таким образом, хотя `string` часть аннотации этого типа может _выглядеть_ полезной, на самом деле она не предлагает никакой дополнительной проверки типов по сравнению с простым использованием `any`.
В зависимости от намерения, приемлемыми альтернативами могут быть `any`, `string`, или `string | object`.
#### Удаление пакета
Когда пакет [объединяет](http://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html) свои собственные типы, типы должны быть удалены из DefinitelyTyped чтобы избежать путаницы.
Вы можете удалить его, запустив `npm run not-needed -- typingsPackageName asOfVersion sourceRepoURL [libraryName]`.
* `typingsPackageName`: название директории, который нужно удалить.
* `asOfVersion`: заглушка будет опубликована в `@types/foo` с этой версией. Должна быть выше, чем любая опубликованная на данный момент версия
* `sourceRepoURL`: Это должно указывать на репозиторий, который содержит типизации.
* `libraryName`: описательное имя библиотеки, например, "Angular 2" вместо "angular2". (Если опущено, будет идентично "typingsPackageName".)
Любые другие пакеты в DefinitelyTyped которые ссылаются на удаленный пакет, должны быть обновлены для ссылки на связанные типы. Для этого добавьте в `package.json` ссыклу `"dependencies": { "foo": "x.y.z" }`.
Если пакет никогда не был в DefinitelyTyped, его не нужно добавлять в `notNeededPackages.json`.
#### Lint
Все новые пакеты должны быть проанализированы lint. Для этого добавьте `tslint.json` в этот пакет, содержащий
```js
{
"extends": "dtslint/dt.json"
}
```
Это должно быть единственным содержимым в файле `tslint.json` готового проекта. Если `tslint.json` отключает правила, это потому, что это еще не исправлено. Например:
```js
{
"extends": "dtslint/dt.json",
"rules": {
// This package uses the Function type, and it will take effort to fix.
"ban-types": false
}
}
```
(Чтобы указать, что правило lint действительно не применяется, используйте `// tslint:disable rule-name` или лучше, `//tslint:disable-next-line rule-name`.)
Чтобы проверить, что выражение имеет заданный тип, используйте `$ExpectType`. Чтобы проверить, что выражение вызывает ошибку компиляции, используйте `$ExpectError`.
```js
// $ExpectType void
f(1);
// $ExpectError
f("one");
```
Для получения дополнительной информации см. [dtslint](https://github.com/Microsoft/dtslint#write-tests) readme.
Протестируйте, запустив `npm run lint package-name` где `package-name` - это имя вашего пакета.
Этот скрипт использует [dtslint](https://github.com/Microsoft/dtslint).
## Часто задаваемые вопросы
#### Какая связь между этим репозиторием и пакетами `@types` в NPM?
Ветвь `master` автоматически публикуется в область `@types` на NPM благодаря [types-publisher](https://github.com/Microsoft/types-publisher).
#### Я отправил PR. Когда он сольется?
Это зависит, но большинство запросов на получение данных будут объединены в течение недели. PR, утвержденные автором, указанным в заголовке определения, обычно объединяются быстрее; PR для новых определений займет больше времени, так как они требуют большего количества проверок от сопровождающих. Каждый PR проверяется членом команды TypeScript или DefinitelyTyped перед объединением, поэтому будьте терпеливы, так как человеческий фактор может вызвать задержки. Посмотрите на [PR Burndown Board](https://github.com/DefinitelyTyped/DefinitelyTyped/projects/3?card_filter_query=is%3Aopen) чтобы увидеть, как сопровождающие работают через открытые PR.
#### Мой PR слит; когда будет обновлен пакет `@types` NPM?
Пакеты NPM должны обновиться в течение нескольких часов. Если прошло более 24 часов, пингуйте @RyanCavanaugh и @andy-ms в PR, чтобы расследовать.
#### Я пишу определение, которое зависит от другого определения. Должен ли я использовать `<reference types="" />` или import?
Если модуль, на который вы ссылаетесь, является внешним модулем (использует `export`), используйте import.
Если модуль, на который вы ссылаетесь, является окружающим модулем (использует `declare module`, или просто объявляет глобальные переменные), используйте `<reference types="" />`.
#### Я заметил, что у некоторых пакетов есть `package.json`.
Обычно вам это не нужно. При публикации пакета мы обычно автоматически создаем `package.json`.
`package.json` может быть включен для определения зависимостей. Вот [пример](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/pikaday/package.json).
Мы не разрешаем определять другие поля, такие как "description", вручную.
Кроме того, если вам нужно сослаться на более старую версию типизаций, вы должны сделать это, добавив в `package.json` строки `"dependencies": { "@types/foo": "x.y.z" }`.
#### В некоторых пакетах отсутствует `tslint.json`, а в некоторых `tsconfig.json` отсутствует `"noImplicitAny": true`, `"noImplicitThis": true`, или `"strictNullChecks": true`.
Тогда они не правы. Вы можете помочь, отправив PR, чтобы исправить их.
#### Могу ли я запросить определение?
Вот [текущие запрошенные определения](https://github.com/DefinitelyTyped/DefinitelyTyped/labels/Definition%3ARequest).
#### Как насчет определений типов для DOM?
Если типы являются частью веб-стандарта, они должны быть добавлены в [TSJS-lib-generator](https://github.com/Microsoft/TSJS-lib-generator) чтобы они могли стать частью `lib.dom.d.ts` по умолчанию.
#### Пакет использует export `export =`, но я предпочитаю использовать импорт по умолчанию. Могу ли я изменить `export =` на `export default`?
Если вы используете TypeScript 2.7 или более позднюю версию, используйте `--esModuleInterop` в вашем проекте.
В противном случае, если импорт по умолчанию работает в вашей среде (например, Webpack, SystemJS, esm), рассмотрите возможность включения опции компилятора [`--allowSyntheticDefaultImports`](http://www.typescriptlang.org/docs/handbook/compiler-options.html).
Не меняйте определение типа, если оно точное.
Для пакета NPM, `export =` является точным, если `node -p 'require("foo")'` является экспортом, а `export default` является точным, если `node -p 'require("foo").default'` является экспортом.
#### Я хочу использовать функции из TypeScript 2.1 или выше.
В таком случае вам нужно будет добавить комментарий к последней строке заголовка вашего определения (после `// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped`): `// TypeScript Version: 2.1`.
#### Я хочу добавить DOM API, отсутствующий в TypeScript по умолчанию.
Это может принадлежать [TSJS-Lib-Generator](https://github.com/Microsoft/TSJS-lib-generator#readme). Смотрите инструкции там.
Если стандарт все еще является черновиком, добавляйте сюда.
Используйте имя, начинающееся с `dom-` и включите ссылку на стандарт в качестве ссылки "Project" в заголовке.
Когда он завершает черновой режим, мы можем удалить его из DefinitelyTyped и объявить устаревшим связанный пакет `@types`.
#### Я хочу обновить пакет новой старшей версии
Если вы намерены продолжить обновление старой версии пакета, вы можете создать новую подпапку с текущей версией, например, `v2` и скопируйте в него существующие файлы. Если это так, вам необходимо:
1. Обновите относительные пути в `tsconfig.json` а также в `tslint.json`.
2. Добавьте правила сопоставления путей, чтобы убедиться, что тесты выполняются для предполагаемой версии.
Например [history v2 `tsconfig.json`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/history/v2/tsconfig.json) looks like:
```json
{
"compilerOptions": {
"baseUrl": "../../",
"typeRoots": ["../../"],
"paths": {
"history": [ "history/v2" ]
}
},
"files": [
"index.d.ts",
"history-tests.ts"
]
}
```
Если в DefinitelyTyped есть другие пакеты, несовместимые с новой версией, вам нужно будет добавить сопоставления путей к старой версии. Вам также нужно будет сделать это для пакетов в зависимости от пакетов в зависимости от старой версии.
Например, `react-router` зависит от `history@2`, поэтому [react-router `tsconfig.json`](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react-router/tsconfig.json) есть сопоставление пути с `"history": [ "history/v2" ]`;
транзитивно `react-router-bootstrap` (который зависит от `react-router`) также добавляет отображение пути в свой [tsconfig.json](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react-router-bootstrap/tsconfig.json).
Также, `/// <reference types=".." />` не будет работать с отображением пути, поэтому зависимости должны использовать `import`.
#### Как мне написать определения для пакетов, которые могут использоваться и глобально и в качестве модуля?
Руководство TypeScript содержит отличную [общую информацию о написании определений](https://www.typescriptlang.org/docs/handbook/declaration-files/introduction.html), а также [этот пример файла определения](https://www.typescriptlang.org/docs/handbook/declaration-files/templates/global-modifying-module-d-ts.html) , в котором показано, как создать определение с использованием синтаксиса модуля в стиле ES6, а также указаны объекты, доступные для глобальной области. Этот метод демонстрируется практически в определении для [definition for big.js](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/big.js/index.d.ts), библиотекой, которую можно загружать глобально с помощью тега скрипта на веб-странице или импортировать с помощью импорта по требованию или в стиле ES6.
Чтобы проверить, как ваше определение может использоваться как при глобальных ссылках, так и в качестве импортированного модуля, создайте тестовую папку `test`, и поместите туда два тестовых файла. Назовите один `YourLibraryName-global.test.ts` а другой `YourLibraryName-module.test.ts`. *Глобальный* тестовый файл должен использовать определение в соответствии с тем, как он будет использоваться в скрипте, загруженном на веб-страницу, где библиотека доступна в глобальной области видимости - в этом сценарии не следует указывать оператор импорта. Тестовый файл *модуля* должен использовать определение в соответствии с тем, как оно будет использоваться при импорте (включая оператор(ы) `import`). Если вы указали свойство `files` в файле `tsconfig.json`, обязательно включите оба тестовых файла. [Практический пример этого](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/big.js/test) также доступен в определении big.js.
Обратите внимание, что не требуется полностью использовать определение в каждом тестовом файле - достаточно протестировать только глобально доступные элементы в глобальном тестовом файле и полностью выполнить определение в тестовом файле модуля, или наоборот.
#### А как насчет областных пакетов?
Типы для пакета с областью `@foo/bar` должны указываться в `types/foo__bar`. Обратите внимание на двойное подчеркивание.
Когда `dts-gen` используется для компоновки пакета с областью действия, свойство `paths` должно быть вручную адаптировано в сгенерированном файле
`tsconfig.json` для правильной ссылки на пакет с областью действия:
```json
{
"paths":{
"@foo/bar": ["foo__bar"]
}
}
```
#### История файлов в GitHub выглядит неполной.
GitHub не [поддерживает](http://stackoverflow.com/questions/5646174/how-to-make-github-follow-directory-history-after-renames) историю файлов для переименованных файлов. Вместо этого используйте [`git log --follow`](https://www.git-scm.com/docs/git-log).
#### Должен ли я добавить пустой namespace в пакет, который не экспортирует модуль для использования импорта в стиле ES6?
Некоторые пакеты, такие как [chai-http](https://github.com/chaijs/chai-http), экспортируют функцию.
Импорт этого модуля с импортом в стиле ES6 в форме `import * as foo from "foo";` приводит к ошибке:
> error TS2497: Module 'foo' resolves to a non-module entity and cannot be imported using this construct
Эту ошибку можно устранить, объединив объявление функции с пустым namespace'ом с тем же именем, но это не рекомендуется.
Это часто цитируемый [ответ с Stack Overflow](https://stackoverflow.com/questions/39415661/what-does-resolves-to-a-non-module-entity-and-cannot-be-imported-using-this) по этому вопросу.
Более целесообразно импортировать модуль, используя `import foo = require("foo");` синтаксис или использовать импорт по умолчанию, такой как `import foo from "foo";` при использовании флага `--allowSyntheticDefaultImports`, если среда выполнения вашего модуля поддерживает схему взаимодействия для модулей не-ECMAScript как таковых.
## Лицензия
Этот проект лицензирован по лицензии MIT.
Авторские права на файлы определений принадлежат каждому участнику, указанному в начале каждого файла определения.
[![Analytics](https://ga-beacon.appspot.com/UA-47495295-4/borisyankov/DefinitelyTyped)](https://github.com/igrigorik/ga-beacon)
[![Build Status](https://typescript.visualstudio.com/TypeScript/_apis/build/status/sandersn.types-publisher-watchdog)](https://typescript.visualstudio.com/TypeScript/_build/latest?definitionId=13) В среднем пакеты публикуются на npm менее чем за 10000 секунд?
[![Build Status](https://typescript.visualstudio.com/TypeScript/_apis/build/status/sandersn.typescript-bot-watchdog)](https://typescript.visualstudio.com/TypeScript/_build/latest?definitionId=14) Был ли typescript-bot активным на DefinitelyTyped в последние два часа?
+156 -6
View File
@@ -144,6 +144,12 @@
"sourceRepoURL": "https://github.com/Azure/azure-mobile-apps-node/",
"asOfVersion": "3.0.0"
},
{
"libraryName": "@babel/parser",
"typingsPackageName": "babel__parser",
"sourceRepoURL": "https://github.com/babel/babel",
"asOfVersion": "7.1.0"
},
{
"libraryName": "BabylonJS",
"typingsPackageName": "babylonjs",
@@ -156,12 +162,6 @@
"sourceRepoURL": "https://github.com/brianloveswords/base64url",
"asOfVersion": "2.0.0"
},
{
"libraryName": "better-scroll",
"typingsPackageName": "better-scroll",
"sourceRepoURL": "https://github.com/ustbhuangyi/better-scroll",
"asOfVersion": "1.5.0"
},
{
"libraryName": "BigInteger.js",
"typingsPackageName": "big-integer",
@@ -180,6 +180,12 @@
"sourceRepoURL": "https://github.com/Microsoft/Bing-Maps-V8-TypeScript-Definitions",
"asOfVersion": "2.0.15"
},
{
"libraryName": "bitwise",
"typingsPackageName": "bitwise",
"sourceRepoURL": "https://github.com/dodekeract/bitwise",
"asOfVersion": "2.0.0"
},
{
"libraryName": "botvs",
"typingsPackageName": "botvs",
@@ -396,6 +402,18 @@
"sourceRepoURL": "https://github.com/MikeMcl/decimal.js",
"asOfVersion": "7.4.0"
},
{
"libraryName": "deepmerge",
"typingsPackageName": "deepmerge",
"sourceRepoURL": "git@github.com:KyleAMathews/deepmerge.git",
"asOfVersion": "2.2.0"
},
{
"libraryName": "delay",
"typingsPackageName": "delay",
"sourceRepoURL": "https://github.com/sindresorhus/delay",
"asOfVersion": "3.1.0"
},
{
"libraryName": "DevExtreme",
"typingsPackageName": "devextreme",
@@ -528,6 +546,12 @@
"sourceRepoURL": "https://github.com/code-chris/extended-listbox",
"asOfVersion": "4.0.1"
},
{
"libraryName": "fast-diff",
"typingsPackageName": "fast-diff",
"sourceRepoURL": "https://github.com/jhchen/fast-diff",
"asOfVersion": "1.2.0"
},
{
"libraryName": "JSON-Patch",
"typingsPackageName": "fast-json-patch",
@@ -540,6 +564,18 @@
"sourceRepoURL": "https://www.npmjs.com/package/fast-simplex-noise",
"asOfVersion": "3.0.0"
},
{
"libraryName": "Fastify-JWT",
"typingsPackageName": "fastify-jwt",
"sourceRepoURL": "https://github.com/fastify/fastify-jwt",
"asOfVersion": "0.8.1"
},
{
"libraryName": "fastify-static",
"typingsPackageName": "fastify-static",
"sourceRepoURL": "https://github.com/fastify/fastify-static",
"asOfVersion": "2.2.0"
},
{
"libraryName": "fecha",
"typingsPackageName": "fecha",
@@ -570,6 +606,12 @@
"sourceRepoURL": "https://github.com/acdlite/flux-standard-action",
"asOfVersion": "1.1.0"
},
{
"libraryName": "fork-ts-checker-webpack-plugin",
"typingsPackageName": "fork-ts-checker-webpack-plugin",
"sourceRepoURL": "https://github.com/Realytics/fork-ts-checker-webpack-plugin",
"asOfVersion": "0.4.5"
},
{
"libraryName": "Foundation Sites",
"typingsPackageName": "foundation-sites",
@@ -606,6 +648,18 @@
"sourceRepoURL": "https://github.com/mikedeboer/node-github",
"asOfVersion": "7.1.0"
},
{
"libraryName": "gitlab",
"typingsPackageName": "gitlab",
"sourceRepoURL": "https://github.com/jdalrymple/node-gitlab",
"asOfVersion": "2.0.0"
},
{
"libraryName": "Google Cloud Storage",
"typingsPackageName": "google-cloud__storage",
"sourceRepoURL": "https://github.com/googleapis/nodejs-storage",
"asOfVersion": "2.3.0"
},
{
"libraryName": "graphene-pk11",
"typingsPackageName": "graphene-pk11",
@@ -642,6 +696,12 @@
"sourceRepoURL": "https://handsontable.com/",
"asOfVersion": "0.35.0"
},
{
"libraryName": "hibp",
"typingsPackageName": "hibp",
"sourceRepoURL": "https://github.com/wKovacs64/hibp",
"asOfVersion": "7.3.0"
},
{
"libraryName": "homeworks",
"typingsPackageName": "homeworks",
@@ -678,6 +738,12 @@
"sourceRepoURL": "https://github.com/facebook/immutable-js",
"asOfVersion": "3.8.7"
},
{
"libraryName": "interactjs",
"typingsPackageName": "interact.js",
"sourceRepoURL": "https://github.com/taye/interact.js",
"asOfVersion": "1.3.0"
},
{
"libraryName": "inversify",
"typingsPackageName": "inversify",
@@ -906,12 +972,24 @@
"sourceRepoURL": "https://github.com/blakeembrey/lower-case-first",
"asOfVersion": "1.0.1"
},
{
"libraryName": "mali",
"typingsPackageName": "mali",
"sourceRepoURL": "https://github.com/malijs/mali",
"asOfVersion": "0.9.2"
},
{
"libraryName": "maquette",
"typingsPackageName": "maquette",
"sourceRepoURL": "http://maquettejs.org/",
"asOfVersion": "2.1.6"
},
{
"libraryName": "maxmind",
"typingsPackageName": "maxmind",
"sourceRepoURL": "https://github.com/runk/node-maxmind",
"asOfVersion": "2.0.5"
},
{
"libraryName": "mendixmodelsdk",
"typingsPackageName": "mendixmodelsdk",
@@ -948,6 +1026,12 @@
"sourceRepoURL": "https://github.com/mweststrate/mobservable-react",
"asOfVersion": "1.0.0"
},
{
"libraryName": "Mobx Cookie",
"typingsPackageName": "mobx-cookie",
"sourceRepoURL": "https://github.com/will-stone/mobx-cookie",
"asOfVersion": "1.1.1"
},
{
"libraryName": "Moment",
"typingsPackageName": "moment",
@@ -966,6 +1050,12 @@
"sourceRepoURL": "https://github.com/mqttjs/MQTT.js",
"asOfVersion": "2.5.0"
},
{
"libraryName": "nano",
"typingsPackageName": "nano",
"sourceRepoURL": "https://github.com/apache/couchdb-nano",
"asOfVersion": "7.0.0"
},
{
"libraryName": "ng-table",
"typingsPackageName": "ng-table",
@@ -990,6 +1080,12 @@
"sourceRepoURL": "https://github.com/paularmstrong/normalizr",
"asOfVersion": "2.0.18"
},
{
"libraryName": "Nuka Carousel",
"typingsPackageName": "nuka-carousel",
"sourceRepoURL": "https://github.com/FormidableLabs/nuka-carousel/",
"asOfVersion": "4.4.6"
},
{
"libraryName": "Numbro",
"typingsPackageName": "numbro",
@@ -1170,6 +1266,12 @@
"sourceRepoURL": "https://github.com/react-ga/react-ga",
"asOfVersion": "2.3.0"
},
{
"libraryName": "react-i18next",
"typingsPackageName": "react-i18next",
"sourceRepoURL": "https://github.com/i18next/react-i18next",
"asOfVersion": "8.1.0"
},
{
"libraryName": "react-monaco-editor",
"typingsPackageName": "react-monaco-editor",
@@ -1224,6 +1326,12 @@
"sourceRepoURL": "https://github.com/tomkp/react-split-pane",
"asOfVersion": "0.1.67"
},
{
"libraryName": "react-svg",
"typingsPackageName": "react-svg",
"sourceRepoURL": "https://github.com/tanem/react-svg",
"asOfVersion": "5.0.0"
},
{
"libraryName": "realm",
"typingsPackageName": "realm",
@@ -1254,6 +1362,12 @@
"sourceRepoURL": "https://github.com/zalmoxisus/redux-devtools-extension",
"asOfVersion": "2.13.2"
},
{
"libraryName": "redux-little-router",
"typingsPackageName": "redux-little-router",
"sourceRepoURL": "https://github.com/FormidableLabs/redux-little-router",
"asOfVersion": "15.1.0"
},
{
"libraryName": "redux-persist",
"typingsPackageName": "redux-persist",
@@ -1392,6 +1506,12 @@
"sourceRepoURL": "https://github.com/zeh/simplesignal",
"asOfVersion": "1.0.0"
},
{
"libraryName": "sip.js",
"typingsPackageName": "sip.js",
"sourceRepoURL": "https://github.com/onsip/SIP.js",
"asOfVersion": "0.12.0"
},
{
"libraryName": "smooth-scrollbar",
"typingsPackageName": "smooth-scrollbar",
@@ -1422,6 +1542,12 @@
"sourceRepoURL": "https://github.com/mozilla/source-map",
"asOfVersion": "0.5.7"
},
{
"libraryName": "Spectacle",
"typingsPackageName": "spectacle",
"sourceRepoURL": "http://github.com/FormidableLabs/spectacle/",
"asOfVersion": "5.2.3"
},
{
"libraryName": "Spin.js",
"typingsPackageName": "spin.js",
@@ -1518,6 +1644,12 @@
"sourceRepoURL": "https://github.com/samchon/tstl",
"asOfVersion": "1.5.7"
},
{
"libraryName": "typed.js",
"typingsPackageName": "typed.js",
"sourceRepoURL": "https://github.com/mattboldt/typed.js",
"asOfVersion": "2.0.9"
},
{
"libraryName": "TypeScript",
"typingsPackageName": "typescript",
@@ -1542,6 +1674,12 @@
"sourceRepoURL": "https://github.com/dpa99c/phonegap-launch-navigator",
"asOfVersion": "4.0.0"
},
{
"libraryName": "Universal Router",
"typingsPackageName": "universal-router",
"sourceRepoURL": "https://github.com/kriasoft/universal-router",
"asOfVersion": "8.0.0"
},
{
"libraryName": "upper-case",
"typingsPackageName": "upper-case",
@@ -1566,6 +1704,12 @@
"sourceRepoURL": "https://github.com/ansman/validate.js",
"asOfVersion": "0.11.0"
},
{
"libraryName": "vega",
"typingsPackageName": "vega",
"sourceRepoURL": "https://github.com/vega/vega",
"asOfVersion": "3.2.0"
},
{
"libraryName": "vso-node-api",
"typingsPackageName": "vso-node-api",
@@ -1596,6 +1740,12 @@
"sourceRepoURL": "https://github.com/tgdwyer/WebCola",
"asOfVersion": "3.2.0"
},
{
"libraryName": "WebdriverIO",
"typingsPackageName": "webdriverio",
"sourceRepoURL": "git@github.com:webdriverio/webdriverio.git",
"asOfVersion": "5.0.0"
},
{
"libraryName": "webgme",
"typingsPackageName": "webgme",
+4 -3
View File
@@ -1,7 +1,7 @@
{
"private": true,
"name": "definitely-typed",
"version": "0.0.2",
"version": "0.0.3",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped",
"repository": {
"type": "git",
@@ -22,6 +22,7 @@
},
"devDependencies": {
"dtslint": "github:Microsoft/dtslint#production",
"types-publisher": "Microsoft/types-publisher#production"
}
"types-publisher": "github:Microsoft/types-publisher#production"
},
"dependencies": {}
}
+30
View File
@@ -0,0 +1,30 @@
import A11yDialog = require('a11y-dialog');
const dialogEl = new A11yDialog(document.getElementById("test"));
const dialogElTwo = new A11yDialog(document.getElementById("test"), document.getElementById("testContainer"));
const dialogElThree = new A11yDialog(document.getElementById("test"), "dummy-element");
dialogEl.show();
dialogEl.hide();
dialogElTwo.destroy();
dialogElThree.create();
// Test out interfaces that extends Element.
dialogEl.on("show", (el: HTMLElement) => {
el.textContent;
});
// Test out element and event.
dialogEl.on("create", (el: HTMLElement, evt) => {
el.textContent;
evt.target;
});
dialogEl.on('hide', () => {
const t = 5;
});
dialogEl.off("show", (el: HTMLElement) => {
el.textContent;
});
+31
View File
@@ -0,0 +1,31 @@
// Type definitions for a11y-dialog 5.2
// Project: https://github.com/edenspiekermann/a11y-dialog
// Definitions by: Yuto <https://github.com/Goyatuzo>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.8
type DialogEvents = "show" | "hide" | "destroy" | "create";
declare class A11yDialog {
constructor(el: Element | null, containers?: NodeList | Element | string | null);
/**
* Shows the dialog.
*/
show(): void;
/**
* Hides the dialog.
*/
hide(): void;
/**
* Unbind click listeners from dialog openers and closers and remove all bound custom event listeners registered with `.on()`
*/
destroy(): void;
/**
* Bind click listeners to dialog openers and closers.
*/
create(el?: Element | null, containers?: NodeList | Element | string | null): void;
on(evt: DialogEvents, callback: (dialogElement: any, event: Event) => void): void;
off(evt: DialogEvents, callback: (dialogElement: any, event: Event) => void): void;
}
export = A11yDialog;
@@ -20,6 +20,6 @@
},
"files": [
"index.d.ts",
"nuka-carousel-tests.tsx"
"a11y-dialog-tests.ts"
]
}
}
@@ -0,0 +1,17 @@
import { AbstractLevelDOWN } from 'abstract-leveldown';
const test = (levelDown: AbstractLevelDOWN<any, string>) => {
levelDown.put("key", "value", (err?) => { });
levelDown.put(1, "value", { something: true }, (err?) => { });
levelDown.get("key", (err?) => { });
levelDown.get(1, { something: true }, (err?) => { });
};
// $ExpectType void
test(new AbstractLevelDOWN('here'));
// $ExpectType void
test(AbstractLevelDOWN('there'));
// $ExpectType void
test(new AbstractLevelDOWN<any, string>('here'));
// $ExpectType void
test(AbstractLevelDOWN<any, string>('there'));
+114
View File
@@ -0,0 +1,114 @@
// Type definitions for abstract-leveldown 5.0
// Project: https://github.com/Level/abstract-leveldown
// Definitions by: Meirion Hughes <https://github.com/MeirionHughes>
// Daniel Byrne <https://github.com/danwbyrne>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
export interface AbstractOptions {
readonly [k: string]: any;
}
export type ErrorCallback = (err: Error | undefined) => void;
export type ErrorValueCallback<V> = (err: Error | undefined, value: V) => void;
export type ErrorKeyValueCallback<K, V> = (err: Error | undefined, key: K, value: V) => void;
export interface AbstractOpenOptions extends AbstractOptions {
createIfMissing?: boolean;
errorIfExists?: boolean;
}
export interface AbstractGetOptions extends AbstractOptions {
asBuffer?: boolean;
}
export interface AbstractLevelDOWN<K = any, V = any> extends AbstractOptions {
open(cb: ErrorCallback): void;
open(options: AbstractOpenOptions, cb: ErrorCallback): void;
close(cb: ErrorCallback): void;
get(key: K, cb: ErrorValueCallback<V>): void;
get(key: K, options: AbstractGetOptions, cb: ErrorValueCallback<V>): void;
put(key: K, value: V, cb: ErrorCallback): void;
put(key: K, value: V, options: AbstractOptions, cb: ErrorCallback): void;
del(key: K, cb: ErrorCallback): void;
del(key: K, options: AbstractOptions, cb: ErrorCallback): void;
batch(): AbstractChainedBatch<K, V>;
batch(array: ReadonlyArray<AbstractBatch<K, V>>, cb: ErrorCallback): AbstractChainedBatch<K, V>;
batch(
array: ReadonlyArray<AbstractBatch<K, V>>,
options: AbstractOptions,
cb: ErrorCallback,
): AbstractChainedBatch<K, V>;
iterator(options?: AbstractIteratorOptions<K>): AbstractIterator<K, V>;
}
export interface AbstractLevelDOWNConstructor {
// tslint:disable-next-line no-unnecessary-generics
new <K = any, V = any>(location: string): AbstractLevelDOWN<K, V>;
// tslint:disable-next-line no-unnecessary-generics
<K = any, V = any>(location: string): AbstractLevelDOWN<K, V>;
}
export interface AbstractIteratorOptions<K = any> extends AbstractOptions {
gt?: K;
gte?: K;
lt?: K;
lte?: K;
reverse?: boolean;
limit?: number;
keys?: boolean;
values?: boolean;
keyAsBuffer?: boolean;
valueAsBuffer?: boolean;
}
export type AbstractBatch<K = any, V = any> = PutBatch<K, V> | DelBatch<K, V>;
export interface PutBatch<K = any, V = any> {
readonly type: 'put';
readonly key: K;
readonly value: V;
}
export interface DelBatch<K = any, V = any> {
readonly type: 'del';
readonly key: K;
}
export interface AbstractChainedBatch<K = any, V = any> extends AbstractOptions {
put: (key: K, value: V) => this;
del: (key: K) => this;
clear: () => this;
write(cb: ErrorCallback): any;
write(options: any, cb: ErrorCallback): any;
}
export interface AbstractChainedBatchConstructor {
// tslint:disable-next-line no-unnecessary-generics
new <K = any, V = any>(db: any): AbstractChainedBatch<K, V>;
// tslint:disable-next-line no-unnecessary-generics
<K = any, V = any>(db: any): AbstractChainedBatch<K, V>;
}
export interface AbstractIterator<K, V> extends AbstractOptions {
db: AbstractLevelDOWN<K, V>;
next(cb: ErrorKeyValueCallback<K, V>): this;
end(cb: ErrorCallback): void;
}
export interface AbstractIteratorConstructor {
// tslint:disable-next-line no-unnecessary-generics
new <K = any, V = any>(db: any): AbstractIterator<K, V>;
// tslint:disable-next-line no-unnecessary-generics
<K = any, V = any>(db: any): AbstractIterator<K, V>;
}
export const AbstractLevelDOWN: AbstractLevelDOWNConstructor;
export const AbstractIterator: AbstractIteratorConstructor;
export const AbstractChainedBatch: AbstractChainedBatchConstructor;
+23
View File
@@ -0,0 +1,23 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"abstract-leveldown-tests.ts"
]
}
+3
View File
@@ -0,0 +1,3 @@
{
"extends": "dtslint/dt.json"
}
@@ -20,11 +20,17 @@ const l3: AcceptLanguageParser.Language = {
quality: 0.9
};
type Lang = "en-US" | "ko-KR";
const enUs: Lang = "en-US";
const koKr: Lang = "ko-KR";
const parsed1: AcceptLanguageParser.Language[] = AcceptLanguageParser.parse('');
const pick1: string | null = AcceptLanguageParser.pick([''], '');
const pick2: string | null = AcceptLanguageParser.pick([''], [l1, l2, l3]);
const pick3: string | null = AcceptLanguageParser.pick([''], '', {});
const pick4: string | null = AcceptLanguageParser.pick([''], '', { loose: true });
const pick5: Lang | null = AcceptLanguageParser.pick<Lang>([enUs, koKr], [l1, l2, l3]);
const pick6: Lang | null = AcceptLanguageParser.pick([enUs, koKr], [l1, l2, l3]);
const pickOptions: AcceptLanguageParser.PickOptions = {
loose: true
+5 -4
View File
@@ -1,17 +1,18 @@
// Type definitions for accept-language-parser 1.5
// Project: https://github.com/opentable/accept-language-parser
// Definitions by: Niklas Wulf <https://github.com/kampfgnom>
// Wooram Jun <https://github.com/chatoo2412>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
// https://github.com/opentable/accept-language-parser/blob/v1.4.1/index.js
// https://github.com/opentable/accept-language-parser/blob/v1.5.0/index.js
export function parse(acceptLanguage: string): Language[];
export function pick(
supportedLanguages: string[],
export function pick<T extends string>(
supportedLanguages: T[],
acceptLanguage: string | Language[],
options?: PickOptions
): string | null;
): T | null;
export interface Language {
code: string;
+31
View File
@@ -0,0 +1,31 @@
import * as accept from 'accept';
accept.charsets("iso-8859-5, unicode-1-1;q=0.8"); // charset === "iso-8859-5"
accept.charset("iso-8859-5, unicode-1-1;q=0.8", ["unicode-1-1"]); // charset === "unicode-1-1"
accept.encoding("gzip, deflate, sdch"); // encoding === "gzip"
accept.encoding("gzip, deflate, sdch", ["deflate", "identity"]);
const encodings = accept.encodings("compress;q=0.5, gzip;q=1.0"); // encodings === ["gzip", "compress", "identity"]
encodings.lastIndexOf('');
accept.language("en;q=0.7, en-GB;q=0.8");
accept.language("en;q=0.7, en-GB;q=0.8", ["en-gb"]); // language === "en-GB"
const languages = accept.languages("da, en;q=0.7, en-GB;q=0.8"); // languages === ["da", "en-GB", "en"]
languages.lastIndexOf('');
accept.mediaType("text/plain, application/json;q=0.5, text/html, */*;q=0.1");
accept.mediaType("text/plain, application/json;q=0.5, text/html, */*;q=0.1", ["application/json", "text/html"]);
const mediaTypes = accept.mediaTypes("text/plain, application/json;q=0.5, text/html, */*;q=0.1");
// mediaTypes === ["text/plain", "text/html", "application/json", "*/*"]
mediaTypes.lastIndexOf('');
const headers = {
accept: 'text/plain, application/json;q=0.5, text/html, */*;q=0.1',
'accept-language': 'da, en;q=0.7, en-GB;q=0.8'
};
const all = accept.parseAll(headers);
all.charsets.length;
all.encodings.length;
all.languages.length;
all.mediaTypes.length;
+22
View File
@@ -0,0 +1,22 @@
// Type definitions for accept 3.1
// Project: https://github.com/hapijs/accept#readme
// Definitions by: feinoujc <https://github.com/feinoujc>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
export function charset(charsetHeader?: string, preferences?: string[]): string;
export function charsets(charsetHeader?: string): string[];
export function encoding(encodingHeader?: string, preferences?: string[]): string;
export function encodings(encodingHeader?: string): string[];
export function language(languageHeader?: string, preferences?: string[]): string;
export function languages(languageHeader?: string): string[];
export function mediaType(mediaTypeHeader?: string, preferences?: string[]): string;
export function mediaTypes(mediaTypeHeader?: string): string[];
export function parseAll(
headers: Record<string, string | string[] | undefined>
): {
charsets: string[];
encodings: string[];
languages: string[];
mediaTypes: string[];
};
@@ -18,6 +18,6 @@
},
"files": [
"index.d.ts",
"gitlab-tests.ts"
"accept-tests.ts"
]
}
+11 -1
View File
@@ -549,6 +549,16 @@ declare namespace AceAjax {
getFoldsInRange(range: Range): any;
highlight(text: string): void;
/**
* Highlight lines from `startRow` to `EndRow`.
* @param startRow Define the start line of the highlight
* @param endRow Define the end line of the highlight
* @param clazz Set the CSS class for the marker
* @param inFront Set to `true` to establish a front marker
**/
highlightLines(startRow:number, endRow: number, clazz: string, inFront: boolean): Range;
/**
* Sets the `EditSession` to point to a new `Document`. If a `BackgroundTokenizer` exists, it also points to `doc`.
@@ -1223,7 +1233,7 @@ declare namespace AceAjax {
/**
* Returns `true` if the current `textInput` is in focus.
**/
isFocused(): void;
isFocused(): boolean;
/**
* Blurs the current `textInput`.
+1 -1
View File
@@ -123,7 +123,7 @@ const aceSelectionTests = {
},
"test: moveCursor word left with umlauts": function () {
var session = new AceAjax.EditSession(" Fu� F��e");
var session = new AceAjax.EditSession(" Fu¢ F¢¢e");
var selection = session.getSelection();
selection.moveCursorTo(0, 9)
+1 -3
View File
@@ -246,9 +246,7 @@ declare namespace acorn {
let LooseParser: ILooseParserClass | undefined;
let pluginsLoose: PluginsObject | undefined;
interface ILooseParserClass {
new (input: string, options?: Options): ILooseParser;
}
type ILooseParserClass = new (input: string, options?: Options) => ILooseParser;
interface ILooseParser {}
+10 -4
View File
@@ -1,13 +1,15 @@
// Type definitions for ActionCable
// Project: https://github.com/rails/rails/tree/master/actioncable
// Type definitions for ActionCable 5.2
// Project: https://github.com/rails/rails/tree/master/actioncable/app/assets/javascripts
// Definitions by: Vincent Zhu <https://github.com/zhu1230>
// Jared Szechy <https://github.com/szechyjs>
// Definitions: https://github.com/zhu1230/DefinitelyTyped
// TypeScript Version: 2.3
declare module ActionCable {
interface Channel {
unsubscribe(): void;
perform(action: string, data: {}): void;
send(data: Object): boolean;
send(data: any): boolean;
}
interface Subscriptions {
@@ -16,12 +18,16 @@ declare module ActionCable {
interface Cable {
subscriptions: Subscriptions;
send(data: any): void;
connect(): void;
disconnect(): void;
ensureActiveConnection(): void;
}
interface CreateMixin {
connected(): void;
disconnected(): void;
received(obj: Object): void;
received(obj: any): void;
[key: string]: Function;
}
+17
View File
@@ -0,0 +1,17 @@
import activeWin = require('active-win');
// $ExpectType Promise<Result>
activeWin();
// $ExpectType Result
activeWin.sync();
let win = {
title: 'Unicorns - Google Search',
id: 5762,
owner: {
name: 'Google Chrome',
processId: 310,
},
};
win = activeWin.sync();
+30
View File
@@ -0,0 +1,30 @@
// Type definitions for active-win 4.0
// Project: https://github.com/sindresorhus/active-win#readme
// Definitions by: BendingBender <https://github.com/BendingBender>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
export = activeWin;
declare function activeWin(): Promise<activeWin.Result>;
declare namespace activeWin {
function sync(): Result;
interface Result {
title: string;
id: number;
bounds?: {
x: number;
y: number;
width: number;
height: number;
};
owner: {
name: string;
processId: number;
bundleId?: number;
path?: string;
};
memoryUsage?: number;
}
}
+23
View File
@@ -0,0 +1,23 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"active-win-tests.ts"
]
}
@@ -0,0 +1,28 @@
import * as ActiveStorage from 'activestorage';
ActiveStorage.start();
const delegate: ActiveStorage.DirectUploadDelegate = {
directUploadWillCreateBlobWithXHR(xhr) {
console.log(xhr.status);
},
directUploadWillStoreFileWithXHR(xhr) {
console.log(xhr.status);
},
};
const d = new ActiveStorage.DirectUpload(
new File([], 'blank.txt'),
'/rails/active_storage/direct_uploads',
delegate
);
d.create((error, blob) => {
if (error) {
console.log(error.message);
} else {
const { byte_size, checksum, content_type, filename, signed_id } = blob;
console.log({ byte_size, checksum, content_type, filename, signed_id });
}
});
+33
View File
@@ -0,0 +1,33 @@
// Type definitions for ActiveStorage 5.2
// Project: https://github.com/rails/rails/tree/master/activestorage/app/javascipt
// Definitions by: Cameron Bothner <https://github.com/cbothner>
// Definitions: https://github.com/cbothner/DefinitelyTyped
// TypeScript Version: 2.1
export as namespace ActiveStorage
export function start(): void;
export class DirectUpload {
id: number;
file: File;
url: string;
constructor(file: File, url: string, delegate: DirectUploadDelegate)
create(callback: (error: Error, blob: Blob) => void): void;
}
export interface DirectUploadDelegate {
directUploadWillCreateBlobWithXHR?: (xhr: XMLHttpRequest) => void;
directUploadWillStoreFileWithXHR?: (xhr: XMLHttpRequest) => void;
}
export interface Blob {
byte_size: number;
checksum: string;
content_type: string;
filename: string;
signed_id: string;
}
+16
View File
@@ -0,0 +1,16 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": ["es6", "dom"],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": ["../"],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": ["index.d.ts", "activestorage-tests.ts"]
}
+40
View File
@@ -0,0 +1,40 @@
/*
| Copyright 2018 Esri
|
| Licensed under the Apache License, Version 2.0 (the "License");
| you may not use this file except in compliance with the License.
| You may obtain a copy of the License at
|
| http://www.apache.org/licenses/LICENSE-2.0
|
| Unless required by applicable law or agreed to in writing, software
| distributed under the License is distributed on an "AS IS" BASIS,
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
| See the License for the specific language governing permissions and
| limitations under the License.
*/
import * as adlib from "adlib";
const transform1: adlib.TransformFunction =
(key: string, value: any, settings: any, param?: any): any => {
return null;
};
const transformsList: adlib.TransformsList = {
firstXform: transform1
};
const template = {
value: '{{ instance.color }}'
};
const settings = {
instance: {
color: 'red'
}
};
const interpolated = adlib.adlib(template, settings, transformsList);
const list: string[] = adlib.listDependencies(template);
+75
View File
@@ -0,0 +1,75 @@
// Type definitions for adlib 3.0
// Project: https://github.com/Esri/adlib
// Definitions by: Esri <https://github.com/Esri>
// Mike Tschudi <https://github.com/MikeTschudi>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
/*
| Copyright 2018 Esri
|
| Licensed under the Apache License, Version 2.0 (the "License");
| you may not use this file except in compliance with the License.
| You may obtain a copy of the License at
|
| http://www.apache.org/licenses/LICENSE-2.0
|
| Unless required by applicable law or agreed to in writing, software
| distributed under the License is distributed on an "AS IS" BASIS,
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
| See the License for the specific language governing permissions and
| limitations under the License.
*/
/**
* Transform function to apply to interpolated value.
*
* @param key Path within a handlebar-style expression to attempt to replace; e.g., `s.animal.type` in
* https://github.com/Esri/adlib#transforms
* @param value Value to replace expression with
* @param settings Hash providing values to insert into template; see https://github.com/Esri/adlib#general-pattern
* @param param Parameter for transform function; e.g., the `optional` transform accepts a count of levels
* to delete if the value is not found (default is 0--just the current level);
* see https://github.com/Esri/adlib#optional-transform
*/
export interface TransformFunction {
(
key: string,
value: any,
settings: any,
param?: any
): any;
}
/**
* Set of transformation functions keyed by the transform function's name.
*/
export interface TransformsList {
[ transformFnName: string ]: TransformFunction;
}
/**
* A JavaScript library for interpolating property values in JSON Objects.
*
* @param template A template that possibly containing handlebar-style property values to replace;
* see https://github.com/Esri/adlib#general-pattern
* @param settings Hash providing values to insert into template; see https://github.com/Esri/adlib#general-pattern
* @param transforms Set of transformation functions
* @return Copy of template with replacements performed
*/
export function adlib(
template: any,
settings: any,
transforms?: TransformsList
): any;
/**
* Reads a template and spits out unique handlebar-style property values.
*
* @param template A template that possibly containing handlebar-style property values to replace;
* see https://github.com/Esri/adlib#general-pattern
* @return List of unique property values in template
*/
export function listDependencies(
template: any
): string [];
+23
View File
@@ -0,0 +1,23 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"adlib-tests.ts"
]
}
+34 -27
View File
@@ -1,62 +1,69 @@
import AdmZip = require("adm-zip");
import AdmZip = require('adm-zip');
// reading archives
var zip = new AdmZip("./my_file.zip");
var zipEntries: AdmZip.IZipEntry[] = zip.getEntries(); // an array of ZipEntry records
const zip = new AdmZip('./my_file.zip');
const zipEntries: AdmZip.IZipEntry[] = zip.getEntries(); // an array of ZipEntry records
zipEntries.forEach(function (zipEntry) {
zipEntries.forEach(zipEntry => {
console.log(zipEntry.toString()); // outputs zip entries information
if (zipEntry.entryName == "my_file.txt") {
if (zipEntry.entryName === 'my_file.txt') {
console.log(zipEntry.getData().toString('utf8'));
}
});
// outputs the content of some_folder/my_file.txt
console.log(zip.readAsText("some_folder/my_file.txt"));
console.log(zip.readAsText('some_folder/my_file.txt'));
// extracts the specified file to the specified location
zip.extractEntryTo(/*entry name*/"some_folder/my_file.txt", /*target path*/"/home/me/tempfolder", /*overwrite*/true)
zip.extractEntryTo(
/*entry name*/ 'some_folder/my_file.txt',
/*target path*/ '/home/me/tempfolder',
/*overwrite*/ true
);
// extracts everything
zip.extractAllTo(/*target path*/"/home/me/zipcontent/", /*overwrite*/true);
zip.extractAllTo(/*target path*/ '/home/me/zipcontent/', /*overwrite*/ true);
// extracts everything and calls callback -> async extracction
zip.extractAllToAsync(/*target path*/"/home/me/zipcontent/", /*overwrite*/true, (error: Error)=> {});
zip.extractAllToAsync(
/*target path*/ '/home/me/zipcontent/',
/*overwrite*/ true,
(error: Error) => {}
);
// creating archives
var zip = new AdmZip();
new AdmZip();
// add file directly
zip.addFile("test.txt", new Buffer("inner content of the file"), "entry comment goes here");
zip.addFile('test.txt', new Buffer('inner content of the file'), 'entry comment goes here');
// add local file
zip.addLocalFile("/home/me/some_picture.png");
zip.addLocalFile('/home/me/some_picture.png');
// get everything as a buffer
var willSendthis = zip.toBuffer();
const willSendthis = zip.toBuffer();
// or write everything to disk
zip.writeZip(/*target file name*/"/home/me/files.zip");
zip.writeZip(/*target file name*/ '/home/me/files.zip');
function processZipEntry(zipEntry: AdmZip.IZipEntry) {
console.log('comment', zipEntry.comment);
}
//tests taken from examples at https://github.com/cthackers/adm-zip/wiki/ADM-ZIP
import Zip = require("adm-zip");
// tests taken from examples at https://github.com/cthackers/adm-zip/wiki/ADM-ZIP
import Zip = require('adm-zip');
// loads and parses existing zip file local_file.zip
var zip = new Zip("local_file.zip");
new Zip('local_file.zip');
// creates new in memory zip
zip = new Zip();
new Zip();
// loads and parses existing zip file local_file.zip
zip = new Zip("local_file.zip");
new Zip('local_file.zip');
// get all entries and iterate them
zip.getEntries().forEach((entry) => {
var entryName = entry.entryName;
var decompressedData = zip.readFile(entry); // decompressed buffer of the entry
console.log(zip.readAsText(entry)); // outputs the decompressed content of the entry
zip.getEntries().forEach(entry => {
const entryName = entry.entryName;
const decompressedData = zip.readFile(entry); // decompressed buffer of the entry
console.log(zip.readAsText(entry)); // outputs the decompressed content of the entry
});
// will extract the file myfile.txt from the archive to /home/user/folder/subfolder/myfile.txt
zip.extractEntryTo("folder/subfolder/myfile.txt", "/home/user/", true, true);
zip.extractEntryTo('folder/subfolder/myfile.txt', '/home/user/', true, true);
// will extract the file myfile.txt from the archive to /home/user/myfile.txt
zip.extractEntryTo("folder/subfolder/myfile.txt", "/home/user/", false, true);
zip.extractEntryTo('folder/subfolder/myfile.txt', '/home/user/', false, true);
function isAdmZipEntry(obj: any): obj is AdmZip.IZipEntry {
return obj !== null && typeof obj === "object" && typeof obj['entryName'] === 'string';
return obj !== null && typeof obj === 'object' && typeof obj['entryName'] === 'string';
}
+93 -155
View File
@@ -1,90 +1,56 @@
// Type definitions for adm-zip v0.4.4
// Type definitions for adm-zip 0.4
// Project: https://github.com/cthackers/adm-zip
// Definitions by: John Vilk <https://github.com/jvilk>, Abner Oliveira <https://github.com/abner>
// Definitions by: John Vilk <https://github.com/jvilk>
// Abner Oliveira <https://github.com/abner>
// BendingBender <https://github.com/BendingBender>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference types="node" />
declare class AdmZip {
/**
* Create a new, empty archive.
* @param fileNameOrRawData If provided, reads an existing archive. Otherwise creates a new, empty archive.
*/
constructor();
constructor(fileNameOrRawData?: string | Buffer);
/**
* Read an existing archive.
* Extracts the given entry from the archive and returns the content.
* @param entry The full path of the entry or a `IZipEntry` object.
* @return `Buffer` or `null` in case of error.
*/
constructor(fileName: string);
constructor(rawData: Buffer);
readFile(entry: string | AdmZip.IZipEntry): Buffer | null;
/**
* Extracts the given entry from the archive and returns the content as a
* Buffer object.
* @param entry String with the full path of the entry
* @return Buffer or Null in case of error
* Asynchronous `readFile`.
* @param entry The full path of the entry or a `IZipEntry` object.
* @param callback Called with a `Buffer` or `null` in case of error.
*/
readFile(entry: string): Buffer;
/**
* Extracts the given entry from the archive and returns the content as a
* Buffer object.
* @param entry ZipEntry object
* @return Buffer or Null in case of error
*/
readFile(entry: AdmZip.IZipEntry): Buffer;
/**
* Asynchronous readFile
* @param entry String with the full path of the entry
* @param callback Called with a Buffer or Null in case of error
*/
readFileAsync(entry: string, callback: (data: Buffer, err: string) => any): void;
/**
* Asynchronous readFile
* @param entry ZipEntry object
* @param callback Called with a Buffer or Null in case of error
* @return Buffer or Null in case of error
*/
readFileAsync(entry: AdmZip.IZipEntry, callback: (data: Buffer, err: string) => any): void;
readFileAsync(
entry: string | AdmZip.IZipEntry,
callback: (data: Buffer | null, err: string) => any
): void;
/**
* Extracts the given entry from the archive and returns the content as
* plain text in the given encoding
* @param entry String with the full path of the entry
* @param encoding Optional. If no encoding is specified utf8 is used
* @return String
* plain text in the given encoding.
* @param entry The full path of the entry or a `IZipEntry` object.
* @param encoding If no encoding is specified `"utf8"` is used.
*/
readAsText(fileName: string, encoding?: string): string;
readAsText(fileName: string | AdmZip.IZipEntry, encoding?: string): string;
/**
* Extracts the given entry from the archive and returns the content as
* plain text in the given encoding
* @param entry ZipEntry object
* @param encoding Optional. If no encoding is specified utf8 is used
* @return String
*/
readAsText(fileName: AdmZip.IZipEntry, encoding?: string): string;
/**
* Asynchronous readAsText
* @param entry String with the full path of the entry
* Asynchronous `readAsText`.
* @param entry The full path of the entry or a `IZipEntry` object.
* @param callback Called with the resulting string.
* @param encoding Optional. If no encoding is specified utf8 is used
* @param encoding If no encoding is specified `"utf8"` is used.
*/
readAsTextAsync(fileName: string, callback: (data: string) => any, encoding?: string): void;
/**
* Asynchronous readAsText
* @param entry ZipEntry object
* @param callback Called with the resulting string.
* @param encoding Optional. If no encoding is specified utf8 is used
*/
readAsTextAsync(fileName: AdmZip.IZipEntry, callback: (data: string) => any, encoding?: string): void;
readAsTextAsync(
fileName: string | AdmZip.IZipEntry,
callback: (data: string) => any,
encoding?: string
): void;
/**
* Remove the entry from the file or the entry and all its nested directories
* and files if the given entry is a directory
* @param entry String with the full path of the entry
* and files if the given entry is a directory.
* @param entry The full path of the entry or a `IZipEntry` object.
*/
deleteFile(entry: string): void;
/**
* Remove the entry from the file or the entry and all its nested directories
* and files if the given entry is a directory
* @param entry A ZipEntry object.
*/
deleteFile(entry: AdmZip.IZipEntry): void;
deleteFile(entry: string | AdmZip.IZipEntry): void;
/**
* Adds a comment to the zip. The zip must be rewritten after
* adding the comment.
@@ -92,72 +58,55 @@ declare class AdmZip {
*/
addZipComment(comment: string): void;
/**
* Returns the zip comment
* @return The zip comment.
*/
getZipComment(): string;
/**
* Adds a comment to a specified zipEntry. The zip must be rewritten after
* Adds a comment to a specified file or `IZipEntry`. The zip must be rewritten after
* adding the comment.
* The comment cannot exceed 65535 characters in length.
* @param entry String with the full path of the entry
* @param entry The full path of the entry or a `IZipEntry` object.
* @param comment The comment to add to the entry.
*/
addZipEntryComment(entry: string, comment: string): void;
/**
* Adds a comment to a specified zipEntry. The zip must be rewritten after
* adding the comment.
* The comment cannot exceed 65535 characters in length.
* @param entry ZipEntry object.
* @param comment The comment to add to the entry.
*/
addZipEntryComment(entry: AdmZip.IZipEntry, comment: string): void;
addZipEntryComment(entry: string | AdmZip.IZipEntry, comment: string): void;
/**
* Returns the comment of the specified entry.
* @param entry String with the full path of the entry.
* @return String The comment of the specified entry.
* @param entry The full path of the entry or a `IZipEntry` object.
* @return The comment of the specified entry.
*/
getZipEntryComment(entry: string): string;
/**
* Returns the comment of the specified entry
* @param entry ZipEntry object.
* @return String The comment of the specified entry.
*/
getZipEntryComment(entry: AdmZip.IZipEntry): string;
getZipEntryComment(entry: string | AdmZip.IZipEntry): string;
/**
* Updates the content of an existing entry inside the archive. The zip
* must be rewritten after updating the content
* @param entry String with the full path of the entry.
* must be rewritten after updating the content.
* @param entry The full path of the entry or a `IZipEntry` object.
* @param content The entry's new contents.
*/
updateFile(entry: string, content: Buffer): void;
/**
* Updates the content of an existing entry inside the archive. The zip
* must be rewritten after updating the content
* @param entry ZipEntry object.
* @param content The entry's new contents.
*/
updateFile(entry: AdmZip.IZipEntry, content: Buffer): void;
updateFile(entry: string | AdmZip.IZipEntry, content: Buffer): void;
/**
* Adds a file from the disk to the archive.
* @param localPath Path to a file on disk.
* @param zipPath Path to a directory in the archive. Defaults to the empty
* string.
* @param zipName Name for the file.
*/
addLocalFile(localPath: string, zipPath?: string): void;
addLocalFile(localPath: string, zipPath?: string, zipName?: string): void;
/**
* Adds a local directory and all its nested files and directories to the
* archive.
* @param localPath Path to a folder on disk.
* @param zipPath Path to a folder in the archive. Defaults to an empty
* string.
* @param zipPath Path to a folder in the archive. Default: `""`.
* @param filter RegExp or Function if files match will be included.
*/
addLocalFolder(localPath: string, zipPath?: string): void;
addLocalFolder(
localPath: string,
zipPath?: string,
filter?: RegExp | ((filename: string) => boolean)
): void;
/**
* Allows you to create a entry (file or directory) in the zip file.
* If you want to create a directory the entryName must end in / and a null
* If you want to create a directory the `entryName` must end in `"/"` and a `null`
* buffer should be provided.
* @param entryName Entry path
* @param entryName Entry path.
* @param content Content to add to the entry; must be a 0-length buffer
* for a directory.
* @param comment Comment to add to the entry.
@@ -165,89 +114,81 @@ declare class AdmZip {
*/
addFile(entryName: string, data: Buffer, comment?: string, attr?: number): void;
/**
* Returns an array of ZipEntry objects representing the files and folders
* inside the archive
* Returns an array of `IZipEntry` objects representing the files and folders
* inside the archive.
*/
getEntries(): AdmZip.IZipEntry[];
/**
* Returns a ZipEntry object representing the file or folder specified by
* ``name``.
* Returns a `IZipEntry` object representing the file or folder specified by `name`.
* @param name Name of the file or folder to retrieve.
* @return ZipEntry The entry corresponding to the name.
* @return The entry corresponding to the `name`.
*/
getEntry(name: string): AdmZip.IZipEntry;
/**
* Extracts the given entry to the given targetPath.
* Extracts the given entry to the given `targetPath`.
* If the entry is a directory inside the archive, the entire directory and
* its subdirectories will be extracted.
* @param entry String with the full path of the entry
* @param targetPath Target folder where to write the file
* @param maintainEntryPath If maintainEntryPath is true and the entry is
* inside a folder, the entry folder will be created in targetPath as
* well. Default is TRUE
* @param entry The full path of the entry or a `IZipEntry` object.
* @param targetPath Target folder where to write the file.
* @param maintainEntryPath If maintainEntryPath is `true` and the entry is
* inside a folder, the entry folder will be created in `targetPath` as
* well. Default: `true`.
* @param overwrite If the file already exists at the target path, the file
* will be overwriten if this is true. Default is FALSE
*
* @return Boolean
* will be overwriten if this is `true`. Default: `false`.
*/
extractEntryTo(entryPath: string, targetPath: string, maintainEntryPath?: boolean, overwrite?: boolean): boolean;
extractEntryTo(
entryPath: string | AdmZip.IZipEntry,
targetPath: string,
maintainEntryPath?: boolean,
overwrite?: boolean
): boolean;
/**
* Extracts the given entry to the given targetPath.
* If the entry is a directory inside the archive, the entire directory and
* its subdirectories will be extracted.
* @param entry ZipEntry object
* @param targetPath Target folder where to write the file
* @param maintainEntryPath If maintainEntryPath is true and the entry is
* inside a folder, the entry folder will be created in targetPath as
* well. Default is TRUE
* Extracts the entire archive to the given location.
* @param targetPath Target location.
* @param overwrite If the file already exists at the target path, the file
* will be overwriten if this is true. Default is FALSE
* @return Boolean
*/
extractEntryTo(entryPath: AdmZip.IZipEntry, targetPath: string, maintainEntryPath?: boolean, overwrite?: boolean): boolean;
/**
* Extracts the entire archive to the given location
* @param targetPath Target location
* @param overwrite If the file already exists at the target path, the file
* will be overwriten if this is true. Default is FALSE
* will be overwriten if this is `true`. Default: `false`.
*/
extractAllTo(targetPath: string, overwrite?: boolean): void;
/**
* Extracts the entire archive to the given location
* @param targetPath Target location
* Extracts the entire archive to the given location.
* @param targetPath Target location.
* @param overwrite If the file already exists at the target path, the file
* will be overwriten if this is true. Default is FALSE
* @param callback The callback function will be called afeter extraction
* will be overwriten if this is `true`. Default: `false`.
* @param callback The callback function will be called after extraction.
*/
extractAllToAsync(targetPath: string, overwrite: boolean, callback: (error: Error) => void): void;
extractAllToAsync(
targetPath: string,
overwrite?: boolean,
callback?: (error: Error) => void
): void;
/**
* Writes the newly created zip file to disk at the specified location or
* if a zip was opened and no ``targetFileName`` is provided, it will
* overwrite the opened zip
* @param targetFileName
* if a zip was opened and no `targetFileName` is provided, it will
* overwrite the opened zip.
*/
writeZip(targetPath?: string): void;
writeZip(targetFileName?: string, callback?: (error: Error | null) => void): void;
/**
* Returns the content of the entire zip file as a Buffer object
* @return Buffer
* Returns the content of the entire zip file.
*/
toBuffer(): Buffer;
}
declare namespace AdmZip {
/**
* The ZipEntry is more than a structure representing the entry inside the
* The `IZipEntry` is more than a structure representing the entry inside the
* zip file. Beside the normal attributes and headers a entry can have, the
* class contains a reference to the part of the file where the compressed
* data resides and decompresses it when requested. It also compresses the
* data and creates the headers required to write in the zip file.
*/
// disable warning about the I-prefix in interface name to prevent breaking stuff for users without a major bump
// tslint:disable-next-line:interface-name
interface IZipEntry {
/**
* Represents the full name and path of the file
*/
entryName: string;
rawEntryName: Buffer;
readonly rawEntryName: Buffer;
/**
* Extra data associated with this entry.
*/
@@ -256,15 +197,16 @@ declare namespace AdmZip {
* Entry comment.
*/
comment: string;
name: string;
readonly name: string;
/**
* Read-Only property that indicates the type of the entry.
*/
isDirectory: boolean;
readonly isDirectory: boolean;
/**
* Get the header associated with this ZipEntry.
*/
header: Buffer;
attr: number;
/**
* Retrieve the compressed data for this entry. Note that this may trigger
* compression if any properties were modified.
@@ -278,11 +220,7 @@ declare namespace AdmZip {
/**
* Set the (uncompressed) data to be associated with this entry.
*/
setData(value: string): void;
/**
* Set the (uncompressed) data to be associated with this entry.
*/
setData(value: Buffer): void;
setData(value: string | Buffer): void;
/**
* Get the decompressed data associated with this entry.
*/
+2 -2
View File
@@ -6,7 +6,7 @@
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": false,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": [
@@ -20,4 +20,4 @@
"index.d.ts",
"adm-zip-tests.ts"
]
}
}
+1 -77
View File
@@ -1,79 +1,3 @@
{
"extends": "dtslint/dt.json",
"rules": {
"adjacent-overload-signatures": false,
"array-type": false,
"arrow-return-shorthand": false,
"ban-types": false,
"callable-types": false,
"comment-format": false,
"dt-header": false,
"eofline": false,
"export-just-namespace": false,
"import-spacing": false,
"interface-name": false,
"interface-over-type-literal": false,
"jsdoc-format": false,
"max-line-length": false,
"member-access": false,
"new-parens": false,
"no-any-union": false,
"no-boolean-literal-compare": false,
"no-conditional-assignment": false,
"no-consecutive-blank-lines": false,
"no-construct": false,
"no-declare-current-package": false,
"no-duplicate-imports": false,
"no-duplicate-variable": false,
"no-empty-interface": false,
"no-for-in-array": false,
"no-inferrable-types": false,
"no-internal-module": false,
"no-irregular-whitespace": false,
"no-mergeable-namespace": false,
"no-misused-new": false,
"no-namespace": false,
"no-object-literal-type-assertion": false,
"no-padding": false,
"no-redundant-jsdoc": false,
"no-redundant-jsdoc-2": false,
"no-redundant-undefined": false,
"no-reference-import": false,
"no-relative-import-in-test": false,
"no-self-import": false,
"no-single-declare-module": false,
"no-string-throw": false,
"no-unnecessary-callback-wrapper": false,
"no-unnecessary-class": false,
"no-unnecessary-generics": false,
"no-unnecessary-qualifier": false,
"no-unnecessary-type-assertion": false,
"no-useless-files": false,
"no-var-keyword": false,
"no-var-requires": false,
"no-void-expression": false,
"no-trailing-whitespace": false,
"object-literal-key-quotes": false,
"object-literal-shorthand": false,
"one-line": false,
"one-variable-per-declaration": false,
"only-arrow-functions": false,
"prefer-conditional-expression": false,
"prefer-const": false,
"prefer-declare-function": false,
"prefer-for-of": false,
"prefer-method-signature": false,
"prefer-template": false,
"radix": false,
"semicolon": false,
"space-before-function-paren": false,
"space-within-parens": false,
"strict-export-declare-modifiers": false,
"trim-file": false,
"triple-equals": false,
"typedef-whitespace": false,
"unified-signatures": false,
"void-return": false,
"whitespace": false
}
"extends": "dtslint/dt.json"
}
+1 -1
View File
@@ -451,7 +451,7 @@ declare namespace adone {
| encoding.Multibyte;
}
const defaultCharUnicode: "�";
const defaultCharUnicode: string;
const defaultCharSingleByte: "?";
+10
View File
@@ -0,0 +1,10 @@
import * as aesjs from 'aes-js';
const key = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
const data: Uint8Array = aesjs.utils.utf8.toBytes('hello world');
const ecb = new aesjs.ModeOfOperation.ecb(key);
ecb.decrypt(ecb.encrypt(data));
const hex: string = aesjs.utils.hex.fromBytes(data);
+134
View File
@@ -0,0 +1,134 @@
// Type definitions for aes-js 3.1
// Project: https://github.com/ricmoo/aes-js
// Definitions by: Federico Bond <https://github.com/federicobond>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
export type ByteSource = ArrayBuffer | Uint8Array | number[];
export class AES {
/**
* Create a new AES block cipher.
* @param key The cipher key.
*/
constructor(key: ByteSource)
encrypt(v: ByteSource): ByteSource;
}
/**
* Create a new Counter state for CTR cipher mode.
* @param initialValue The Counter initial value.
*/
export class Counter {
constructor(initialValue: number)
setValue(value: number): void;
setBytes(bytes: ByteSource): void;
increment(): void;
}
export namespace ModeOfOperation {
class ModeOfOperationECB {
/**
* Create a new ECB stream cipher.
* @param key The cipher key.
*/
constructor(key: ByteSource)
encrypt(v: ByteSource): Uint8Array;
decrypt(v: ByteSource): Uint8Array;
}
class ModeOfOperationCBC {
/**
* Create a new CBC stream cipher.
* @param key The cipher key.
* @param iv The cipher initialization vector.
*/
constructor(key: ByteSource, iv: ByteSource);
encrypt(v: ByteSource): Uint8Array;
decrypt(v: ByteSource): Uint8Array;
}
class ModeOfOperationCFB {
/**
* Create a new CFB stream cipher.
* @param key The cipher key.
* @param iv The cipher initialization vector.
* @param segmentSize The cipher segment size.
*/
constructor(key: ByteSource, iv: ByteSource, segmentSize: number);
encrypt(v: ByteSource): Uint8Array;
decrypt(v: ByteSource): Uint8Array;
}
class ModeOfOperationOFB {
/**
* Create a new OFB stream cipher.
* @param key The cipher key.
* @param iv The cipher initialization vector.
*/
constructor(key: ByteSource, iv: ByteSource);
encrypt(v: ByteSource): Uint8Array;
decrypt(v: ByteSource): Uint8Array;
}
class ModeOfOperationCTR {
/**
* Create a new CTR stream cipher.
* @param key The cipher key.
* @param counter The cipher counter state.
*/
constructor(key: ByteSource, counter?: Counter)
encrypt(v: ByteSource): Uint8Array;
decrypt(v: ByteSource): Uint8Array;
}
const ecb: typeof ModeOfOperationECB;
const cbc: typeof ModeOfOperationCBC;
const cfb: typeof ModeOfOperationCFB;
const ofb: typeof ModeOfOperationOFB;
const ctr: typeof ModeOfOperationCTR;
}
export namespace utils {
namespace utf8 {
/**
* Convert a UTF8 encoded string to a Uint8Array.
* @param data The input string.
*/
function toBytes(data: string): Uint8Array;
/**
* Convert an array-like object containing UTF8 data to a string.
* @param data The input data.
*/
function fromBytes(data: ByteSource): string;
}
namespace hex {
/**
* Convert a hexadecimal string to a Uint8Array.
* @param data The input string.
*/
function toBytes(data: string): Uint8Array;
/**
* Convert an array-like object to a hexadecimal string.
* @param data The input data.
*/
function fromBytes(data: ByteSource): string;
}
}
export namespace padding {
namespace pkcs7 {
/**
* Add standard PKCS7 padding to an array.
* @param data The input data.
*/
function pad(data: ByteSource): Uint8Array;
/**
* Remove standard PKCS7 padding from an array.
* @param data The input data.
*/
function strip(data: ByteSource): Uint8Array;
}
}
+23
View File
@@ -0,0 +1,23 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"aes-js-tests.ts"
]
}
+453 -306
View File
@@ -1,345 +1,492 @@
// Type definitions for AFRAME 0.7
// Type definitions for AFRAME 0.8
// Project: https://aframe.io/
// Definitions by: Paul Shannon <https://github.com/devpaul>
// Roberto Ritger <https://github.com/bertoritger>
// Trygve Wastvedt <https://github.com/twastvedt>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
// TypeScript Version: 2.8
/**
* Extended tests available at https://github.com/devpaul/aframe-typings.git
* Extended tests and examples available at https://github.com/devpaul/aframe-experiments.git
*/
/// <reference types="three" />
/// <reference types="tween.js" />
// Globals
declare var AFRAME: AFrame.AFrameGlobal;
declare var hasNativeWebVRImplementation: boolean;
import * as three from 'three';
import * as tween from '@tweenjs/tween.js';
interface Document {
createElement(tagName: string): AFrame.Entity;
querySelector(selectors: 'a-scene'): AFrame.Scene;
querySelector(selectors: string): AFrame.Entity<any>;
querySelectorAll(selectors: string): NodeListOf<AFrame.Entity<any> | Element>;
export type ThreeLib = typeof three;
export type TweenLib = typeof tween;
export interface ObjectMap<T = any> {
[key: string]: T;
}
// Interfaces
declare namespace AFrame {
interface ObjectMap<T = any> {
[ key: string ]: T;
}
export interface Animation {
attribute: string;
begin: string | number;
delay: number;
direction: 'alternate' | 'alternateReverse' | 'normal' | 'reverse';
dur: number;
easing(): void;
end: string;
fill: 'backwards' | 'both' | 'forwards' | 'none';
from: any; // TODO type
repeat: number | 'indefinite';
to: number;
}
interface AFrameGlobal {
AEntity: Entity;
ANode: ANode;
AScene: Scene;
components: { [ key: string ]: ComponentDescriptor };
geometries: { [ key: string ]: GeometryDescriptor };
primitives: { [ key: string ]: Entity };
registerComponent<T extends Component>(name: string, component: ComponentDefinition<T>): ComponentConstructor<T>;
registerElement(name: string, element: ANode): void;
registerGeometry<T extends Geometry>(name: string, geometry: GeometryDefinition<T>): GeometryConstructor<T>;
registerPrimitive(name: string, primitive: PrimitiveDefinition): void;
registerShader<T extends Shader>(name: string, shader: T): ShaderConstructor<T>;
registerSystem<T extends System>(name: string, definition: SystemDefinition<T>): SystemConstructor<T>;
schema: SchemaUtils;
shaders: { [ key: string ]: ShaderDescriptor };
systems: { [key: string]: SystemConstructor };
THREE: typeof THREE;
TWEEN: typeof TWEEN;
utils: Utils;
version: string;
}
export interface ANode extends HTMLElement {
// Only public APIs added. Many methods intentionally left out.
// createdCallback
// attachedCallback
// attributeChangedCallback
closestScene(): Scene;
closest(selector: string): ANode;
// detachedCallback
hasLoaded: boolean;
load(cb?: () => void, childFilter?: (el: Element) => boolean): void;
// updateMixins
registerMixin(id: string): void;
setAttribute(type: string, newValue: any): void;
unregisterMixin(id: string): void;
removeMixinListener(id: string): void;
attachMixinListener(mixin: HTMLElement): void;
emit(name: string, detail?: any, bubbles?: boolean): void;
emitter(name: string, detail?: any, bubbles?: boolean): () => void;
}
interface Animation {
attribute: string;
begin: string | number;
delay: number;
direction: 'alternate' | 'alternateReverse' | 'normal' | 'reverse';
dur: number;
easing(): void;
end: string;
fill: 'backwards' | 'both' | 'forwards' | 'none';
from: any; // TODO type
repeat: number | 'indefinite';
to: number;
}
export interface Behavior {
tick(): void;
}
interface ANode extends HTMLElement {
// Only public APIs added. Many methods intentionally left out.
// createdCallback
// attachedCallback
// attributeChangedCallback
closestScene(): Scene;
closest(selector: string): ANode;
// detachedCallback
hasLoaded: boolean;
load(cb?: () => void, childFilter?: (el: Element) => boolean): void;
// updateMixins
registerMixin(id: string): void;
setAttribute(type: string, newValue: any): void;
unregisterMixin(id: string): void;
removeMixinListener(id: string): void;
attachMixinListener(mixin: HTMLElement): void;
emit(name: string, detail?: any, bubbles?: boolean): void;
emitter(name: string, detail?: any, bubbles?: boolean): () => void;
}
export interface Component<T extends object = any, S extends System = System> {
attrName?: string;
data: T;
dependencies?: string[];
el: Entity;
id: string;
multiple?: boolean;
name: string;
schema: Schema<T>;
system: S | undefined;
interface Behavior {
tick(): void;
}
init(data?: T): void;
pause(): void;
play(): void;
remove(): void;
tick?(time: number, timeDelta: number): void;
update(oldData: T): void;
updateSchema?(): void;
interface Component<T extends { [key: string]: any } = any, S extends System = System> {
attrName?: string;
data: T;
dependencies?: string[];
el: Entity;
id: string;
multiple?: boolean;
extendSchema(update: Schema): void;
flushToDOM(): void;
}
export interface ComponentConstructor<T extends object> {
new (el: Entity, attrValue: string, id: string): T & Component;
prototype: T & {
name: string;
schema: Schema<T>;
system: S | undefined;
init(this: this, data?: T): void;
pause(this: this): void;
play(this: this): void;
remove(this: this): void;
tick?(this: this, time: number, timeDelta: number): void;
update(this: this, oldData: T): void;
updateSchema?(this: this): void;
extendSchema(this: this, update: Schema): void;
flushToDOM(this: this): void;
}
interface ComponentConstructor<T extends Component> {
new (el: Entity, attrValue: string, id: string): T;
}
type ComponentDefinition<T extends Component = Component> = Partial<T>;
interface ComponentDescriptor<T extends Component = Component> {
Component: ComponentConstructor<T>;
dependencies: string[] | undefined;
multiple: boolean | undefined;
// internal APIs2
// parse
// parseAttrValueForCache
// schema
// stringify
// type
}
interface Coordinate {
x: number;
y: number;
z: number;
}
interface DefaultComponents {
position: Component<Coordinate>;
rotation: Component<Coordinate>;
scale: Component<Coordinate>;
}
interface Entity<C = ObjectMap<Component>> extends ANode {
components: C & DefaultComponents;
isPlaying: boolean;
object3D: THREE.Object3D;
object3DMap: ObjectMap<THREE.Object3D>;
sceneEl?: Scene;
addState(name: string): void;
flushToDOM(recursive?: boolean): void;
/**
* @deprecated since 0.4.0
*/
getComputedAttribute(attr: string): Component;
getDOMAttribute(attr: string): any;
getObject3D(type: string): THREE.Object3D;
getOrCreateObject3D(type: string, construct: any): THREE.Object3D;
is(stateName: string): boolean;
pause(): void;
system: System;
play(): void;
setObject3D(type: string, obj: THREE.Object3D): void;
removeAttribute(attr: string, property?: string): void;
removeObject3D(type: string): void;
removeState(stateName: string): void;
// getAttribute specific usages
getAttribute(type: string): any;
getAttribute(type: 'position' | 'rotation' | 'scale'): Coordinate;
// setAttribute specific usages
setAttribute(attr: string, value: any): void;
setAttribute(attr: string, property: string, componentAttrValue?: any): void;
setAttribute(type: 'position' | 'rotation' | 'scale', value: Coordinate): void;
// addEventListener specific usages
addEventListener<K extends keyof EntityEventMap>(type: K, listener: (event: Event & EntityEventMap[K]) => void, useCapture?: boolean): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
}
type DetailEvent<D> = Event & {
detail: D;
target: EventTarget & Entity;
pause(): void;
};
}
interface EntityEventMap {
'child-attached': DetailEvent<{ el: Element | Entity }>;
'child-detached': DetailEvent<{ el: Element | Entity }>;
'componentchanged': DetailEvent<{
name: string,
id: string
}>;
'componentremoved': DetailEvent<{
name: string,
id: string,
newData: any,
oldData: any
}>;
'loaded': EventListener;
'pause': EventListener;
'play': EventListener;
'stateadded': DetailEvent<{ state: string }>;
'stateremoved': DetailEvent<{ state: string }>;
'schemachanged': DetailEvent<{ componentName: string }>;
}
export interface ComponentDescriptor<T extends Component = Component> {
Component: ComponentConstructor<T>;
dependencies: string[] | undefined;
multiple: boolean | undefined;
interface Geometry {
// internal APIs2
// parse
// parseAttrValueForCache
// schema
// stringify
// type
}
export interface Coordinate {
x: number;
y: number;
z: number;
}
export interface DefaultComponents {
position: Component<Coordinate>;
rotation: Component<Coordinate>;
scale: Component<Coordinate>;
}
export interface Entity<C = ObjectMap<Component>> extends ANode {
components: C & DefaultComponents;
isPlaying: boolean;
object3D: THREE.Object3D;
object3DMap: ObjectMap<THREE.Object3D>;
sceneEl?: Scene;
addState(name: string): void;
flushToDOM(recursive?: boolean): void;
/**
* @deprecated since 0.4.0
*/
getComputedAttribute(attr: string): Component;
getDOMAttribute(attr: string): any;
getObject3D(type: string): THREE.Object3D;
getOrCreateObject3D(type: string, construct: any): THREE.Object3D;
is(stateName: string): boolean;
pause(): void;
play(): void;
setObject3D(type: string, obj: THREE.Object3D): void;
removeAttribute(attr: string, property?: string): void;
removeObject3D(type: string): void;
removeState(stateName: string): void;
// getAttribute specific usages
getAttribute(type: string): any;
getAttribute(type: 'position' | 'rotation' | 'scale'): Coordinate;
// setAttribute specific usages
setAttribute(attr: string, value: any): void;
setAttribute(attr: string, property: string, componentAttrValue?: any): void;
setAttribute(type: 'position' | 'rotation' | 'scale', value: Coordinate): void;
// addEventListener specific usages
addEventListener<K extends keyof EntityEventMap>(
type: K,
listener: (event: Event & EntityEventMap[K]) => void,
useCapture?: boolean
): void;
addEventListener(
type: string,
listener: EventListenerOrEventListenerObject,
useCapture?: boolean
): void;
}
export type DetailEvent<D> = Event & {
detail: D;
target: EventTarget & Entity;
};
export interface EntityEventMap {
'child-attached': DetailEvent<{ el: Element | Entity }>;
'child-detached': DetailEvent<{ el: Element | Entity }>;
componentchanged: DetailEvent<{
name: string;
geometry: THREE.Geometry;
schema: Schema<any>;
id: string;
}>;
componentremoved: DetailEvent<{
name: string;
id: string;
newData: any;
oldData: any;
}>;
loaded: EventListener;
pause: EventListener;
play: EventListener;
stateadded: DetailEvent<{ state: string }>;
stateremoved: DetailEvent<{ state: string }>;
schemachanged: DetailEvent<{ componentName: string }>;
}
init(this: this, data: { [P in keyof this['schema']]: any }): void;
// Would like the above to be:
// init?(this: this, data?: { [P in keyof T['schema']]: T['schema'][P]['default'] } ): void;
// I think this is prevented by the following issue: https://github.com/Microsoft/TypeScript/issues/21760.
}
export interface Geometry<T = any> {
data: T;
name: string;
geometry: THREE.Geometry;
schema: Schema<any>;
interface GeometryConstructor<T extends Geometry> {
new (): T;
}
init(data: any): void;
}
type GeometryDefinition<T extends Geometry = Geometry> = Partial<T>;
export interface GeometryConstructor<T extends object = object> {
new (): T & Geometry;
}
interface GeometryDescriptor<T extends Geometry = Geometry> {
Geometry: GeometryConstructor<T>;
schema: Schema;
}
export interface GeometryDescriptor<T extends Geometry = Geometry> {
Geometry: GeometryConstructor<T>;
schema: Schema;
}
type MultiPropertySchema<T extends { [key: string ]: any }> = {
[P in keyof T]: SinglePropertySchema<T[P]> | T[P];
export type MultiPropertySchema<T extends object> = {
[P in keyof T]: SinglePropertySchema<T[P]> | T[P]
};
export type PropertyTypes =
| 'array'
| 'asset'
| 'audio'
| 'boolean'
| 'color'
| 'int'
| 'map'
| 'model'
| 'number'
| 'selector'
| 'selectorAll'
| 'string'
| 'vec2'
| 'vec3'
| 'vec4';
export type SceneEvents = 'enter-vr' | 'exit-vr' | 'loaded' | 'renderstart';
export interface Scene extends Entity {
behaviors: Behavior[];
camera: THREE.Camera;
canvas: HTMLCanvasElement;
effect: THREE.VREffect;
isMobile: boolean;
object3D: THREE.Scene;
renderer: THREE.WebGLRenderer;
renderStarted: boolean;
systems: ObjectMap<System>;
time: number;
enterVR(): Promise<void> | void;
exitVR(): Promise<void> | void;
reload(): void;
addEventListener(
type: string,
listener: EventListenerOrEventListenerObject,
useCapture?: boolean
): void;
addEventListener(type: SceneEvents, listener: EventListener, useCapture?: boolean): void;
}
export type Schema<T extends object = object> = SinglePropertySchema<T> | MultiPropertySchema<T>;
export interface SchemaUtils {
isSingleProperty(schema: Schema): boolean;
process(schema: Schema): boolean;
}
export interface Shader {
name: string;
data: object;
schema: Schema<this['data']>;
material: THREE.Material;
vertexShader: string;
fragmentShader: string;
init(data?: this['data']): void;
tick?(time: number, timeDelta: number): void;
update(oldData: this['data']): void;
}
export interface ShaderConstructor<T extends object> {
new (): T;
}
export interface ShaderDescriptor<T extends Shader = Shader> {
Shader: ShaderConstructor<T>;
schema: Schema;
}
export interface SinglePropertySchema<T> {
type?: PropertyTypes;
default?: T;
parse?(value: string): T;
stringify?(value: T): string;
}
export interface System<T extends object = any> {
data: T;
schema: Schema<T>;
init(): void;
pause(): void;
play(): void;
tick?(t: number, dt: number): void;
}
export interface SystemConstructor<T extends object = object> {
new (scene: Scene): T & System;
}
export interface Utils {
coordinates: {
isCoordinate(value: string): boolean;
parse(value: string): Coordinate;
stringify(coord: Coordinate): string;
};
entity: {
getComponentProperty(entity: Entity, componentName: string, delimiter?: string): any;
setComponentProperty(
entity: Entity,
componentName: string,
value: any,
delimiter?: string
): void;
};
device: {
isWebXRAvailable: boolean;
getVRDisplay(): VRDisplay[];
checkHeadsetConnected(): boolean;
checkHasPositionalTracking(): boolean;
isMobile(): boolean;
isTablet(): boolean;
isIOS(): boolean;
isGearVR(): boolean;
isOculusGo(): boolean;
isR7(): boolean;
isLandscape(): boolean;
isBrowserEnvironment(): boolean;
isNodeEnvironment(): boolean;
PolyfillControls(object3D: THREE.Object3D): void;
};
styleParser: {
parse(value: string): object;
stringify(data: object): string;
};
deepEqual(a: any, b: any): boolean;
diff(a: object, b: object): object;
extend(target: object, ...source: object[]): object;
extendDeep(target: object, ...source: object[]): object;
interface PrimitiveDefinition {
defaultComponents?: any; // TODO cleanup type
deprecated?: boolean;
mappings?: any; // TODO cleanup type
transforms?: any; // TODO cleanup type
}
throttle(
tickFunction: () => void,
minimumInterval: number,
optionalContext?: {}
): (t: number, dt: number) => void;
throttleTick(
tickFunction: (t: number, dt: number) => void,
minimumInterval: number,
optionalContext?: {}
): (t: number, dt: number) => void;
}
type PropertyTypes = 'array' | 'asset' | 'audio' | 'boolean' | 'color' |
'int' | 'map' | 'model' | 'number' | 'selector' | 'selectorAll' |
'string' | 'vec2' | 'vec3' | 'vec4';
// Definitions
// used as mixins to register functions to create classes (newable functions) in A-Frame
export type ComponentDefinition<T extends object = object> = T & Partial<Component> & ThisType<T & Component>;
export type GeometryDefinition<T extends object = object, U = any> = T & Partial<Geometry<U>>;
export type NodeDefinition<T extends object = object> = T & Partial<ANode>;
export interface PrimitiveDefinition {
defaultComponents?: any; // TODO cleanup type
deprecated?: boolean;
mappings?: any; // TODO cleanup type
transforms?: any; // TODO cleanup type
}
export interface MinimalShaderDefinition {
schema: Shader['schema'];
}
export type ShaderDefinition<T extends object = MinimalShaderDefinition & object> = T &
Partial<Shader>;
export type SystemDefinition<T extends object = object> = T & Partial<System>;
type SceneEvents = 'enter-vr' | 'exit-vr' | 'loaded' | 'renderstart';
// root export
export interface AFrame {
AComponent: Component;
AEntity: Entity;
ANode: ANode;
AScene: Scene;
interface Scene extends Entity {
behaviors: Behavior[];
camera: THREE.Camera;
canvas: HTMLCanvasElement;
effect: THREE.VREffect;
isMobile: boolean;
object3D: THREE.Scene;
renderer: THREE.WebGLRenderer;
renderStarted: boolean;
systems: ObjectMap<System>;
time: number;
enterVR(): Promise<void> | void;
exitVR(): Promise<void> | void;
reload(): void;
addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
addEventListener(type: SceneEvents, listener: EventListener, useCapture?: boolean): void;
}
type Schema<T = { [key: string]: any }> = SinglePropertySchema<T> | MultiPropertySchema<T>;
interface SchemaUtils {
isSingleProperty(schema: Schema): boolean;
process(schema: Schema): boolean;
}
interface Shader {
name: string;
data: { [key: string]: any };
schema: Schema<this['data']>;
material: THREE.Material;
vertexShader: string;
fragmentShader: string;
init(this: this, data?: this['data']): void;
tick?(this: this, time: number, timeDelta: number): void;
update(this: this, oldData: this['data']): void;
}
interface ShaderConstructor<T extends Shader> {
new (): T;
}
type ShaderDefinition<T extends Shader = Shader> = Partial<T>;
interface ShaderDescriptor<T extends Shader = Shader> {
Shader: ShaderConstructor<T>;
schema: Schema;
}
interface SinglePropertySchema<T> {
type?: PropertyTypes;
'default'?: T;
parse?(value: string): T;
stringify?(value: T): string;
}
interface System {
data: { [key: string]: any };
schema: Schema<this['data']>;
init(this: this): void;
pause(this: this): void;
play(this: this): void;
tick?(this: this, t: number, dt: number): void;
}
interface SystemConstructor<T extends System = System> {
new (scene: Scene): T;
}
type SystemDefinition<T extends System = System> = Partial<T>;
interface Utils {
coordinates: {
isCoordinate(value: string): boolean;
parse(value: string): Coordinate;
stringify(coord: Coordinate): string;
components: ObjectMap<ComponentDescriptor>;
geometries: ObjectMap<GeometryDescriptor>;
primitives: {
getMeshMixin(): {
defaultComponents: { material: object };
mappings: { [key: string]: any }; // TODO improve any type
};
entity: {
getComponentProperty(entity: Entity, componentName: string, delimiter?: string): any;
setComponentProperty(entity: Entity, componentName: string, value: any, delimiter?: string): void;
};
styleParser: {
parse(value: string): object;
stringify(data: object): string;
};
deepEqual(a: any, b: any): boolean;
diff(a: object, b: object): object;
extend(target: object, ... source: object[]): object;
extendDeep(target: object, ... source: object[]): object;
primitives: ObjectMap<Entity>;
};
scenes: Scene[];
schema: SchemaUtils;
shaders: ObjectMap<ShaderDescriptor>;
systems: ObjectMap<SystemConstructor>;
THREE: ThreeLib;
TWEEN: TweenLib;
utils: Utils;
version: string;
throttle(tickFunction: () => void, minimumInterval: number, optionalContext?: {}): (t: number, dt: number) => void;
throttleTick(tickFunction: (t: number, dt: number) => void, minimumInterval: number, optionalContext?: {}): (t: number, dt: number) => void;
registerComponent<T extends object>(
name: string,
component: ComponentDefinition<T>
): ComponentConstructor<T>;
registerElement(name: string, element: object): void;
registerGeometry<T extends object>(
name: string,
geometry: GeometryDefinition<T>
): GeometryConstructor<T>;
registerPrimitive(name: string, primitive: PrimitiveDefinition): void;
registerShader<T extends MinimalShaderDefinition & object>(
name: string,
shader: ShaderDefinition<T>
): ShaderConstructor<T>;
registerSystem<T extends object>(
name: string,
definition: SystemDefinition<T>
): SystemConstructor<T>;
}
// module.exports
export const AComponent: AFrame['AComponent'];
export const AEntity: AFrame['AEntity'];
export const ANode: AFrame['ANode'];
export const AScene: AFrame['AScene'];
export const components: AFrame['components'];
export const geometries: AFrame['geometries'];
export const primitives: AFrame['primitives'];
export const scenes: AFrame['scenes'];
export const schema: AFrame['schema'];
export const shaders: AFrame['shaders'];
export const systems: AFrame['systems'];
export const THREE: AFrame['THREE'];
export const TWEEN: AFrame['TWEEN'];
export const utils: AFrame['utils'];
export const version: AFrame['version'];
export const registerComponent: AFrame['registerComponent'];
export const registerElement: AFrame['registerElement'];
export const registerGeometry: AFrame['registerGeometry'];
export const registerPrimitive: AFrame['registerPrimitive'];
export const registerShader: AFrame['registerShader'];
export const registerSystem: AFrame['registerSystem'];
// global exports
declare global {
var hasNativeWebVRImplementation: boolean;
namespace AFRAME {
const AComponent: AFrame['AComponent'];
const AEntity: AFrame['AEntity'];
const ANode: AFrame['ANode'];
const AScene: AFrame['AScene'];
const components: AFrame['components'];
const geometries: AFrame['geometries'];
const primitives: AFrame['primitives'];
const scenes: AFrame['scenes'];
const schema: AFrame['schema'];
const shaders: AFrame['shaders'];
const systems: AFrame['systems'];
const THREE: AFrame['THREE'];
const TWEEN: AFrame['TWEEN'];
const utils: AFrame['utils'];
const version: string;
const registerComponent: AFrame['registerComponent'];
const registerElement: AFrame['registerElement'];
const registerGeometry: AFrame['registerGeometry'];
const registerPrimitive: AFrame['registerPrimitive'];
const registerShader: AFrame['registerShader'];
const registerSystem: AFrame['registerSystem'];
}
/**
* Custom elements augment document methods to return custom HTML
*/
interface Document {
createElement(tagName: string): Entity;
querySelector(selectors: 'a-scene'): Scene;
querySelector(selectors: string): Entity<any>;
querySelectorAll(selectors: string): NodeListOf<Entity<any> | Element>;
}
interface HTMLCollection extends HTMLCollectionBase {
/**
* Retrieves a select object or an object from an options collection.
*/
namedItem(name: string): Element | Entity | null;
item(index: number): Element | Entity;
[index: number]: Element | Entity;
}
}
File diff suppressed because it is too large Load Diff
@@ -1,3 +1,14 @@
import {
Component,
Entity,
MultiPropertySchema,
System,
SystemDefinition,
THREE,
Geometry,
registerComponent
} from 'aframe';
// Global
const threeCamera = new AFRAME.THREE.Camera();
AFRAME.TWEEN.Easing;
@@ -16,7 +27,7 @@ entity.setAttribute('material', 'color', 'red');
entity.components['geometry'].data;
type MyEntity = AFrame.Entity<{
type MyEntity = Entity<{
camera: THREE.Camera;
material: THREE.Material;
sound: { pause(): void };
@@ -33,35 +44,38 @@ entity.setAttribute('light', {
intensity: 2.0
});
entity.addEventListener('child-detached', (event) => {
entity.addEventListener('child-detached', event => {
event.detail;
});
// Components
interface TestComponent extends AFrame.Component {
multiply: (f: number) => number;
// interface TestComponent extends Component {
// multiply: (f: number) => number;
//
// data: {
// myProperty: any[],
// string: string,
// num: number
// };
//
// system: TestSystem;
// }
data: {
myProperty: any[],
string: string,
num: number
};
system: TestSystem;
}
const Component = AFRAME.registerComponent<TestComponent>('test-component', {
const Component = registerComponent('test-component', {
schema: {
myProperty: {
default: [],
parse() { return [true]; },
parse() {
return [true];
}
},
string: { type: 'string' },
num: 0
},
init() {
this.data.num = 0;
this.el.setAttribute('custom-attribute', 'custom-value');
},
update() {},
tick() {},
@@ -69,9 +83,9 @@ const Component = AFRAME.registerComponent<TestComponent>('test-component', {
pause() {},
play() {},
multiply(this: TestComponent, f: number) {
multiply(f: number) {
// Reference to system because both were registered with the same name.
return f * this.data.num * this.system.data.counter;
return f * this.data.num * this.system!.data.counter;
}
});
@@ -81,13 +95,7 @@ scene.hasLoaded;
// System
interface TestSystem extends AFrame.System {
data: {
counter: number;
};
}
const testSystem: AFrame.SystemDefinition<TestSystem> = {
const testSystem: SystemDefinition = {
schema: {
counter: 0
},
@@ -101,13 +109,7 @@ AFRAME.registerSystem('test-component', testSystem);
// Register Custom Geometry
interface TestGeometry extends AFrame.Geometry {
schema: AFrame.MultiPropertySchema<{
groupIndex: number;
}>;
}
AFRAME.registerGeometry<TestGeometry>('a-test-geometry', {
AFRAME.registerGeometry('a-test-geometry', {
schema: {
groupIndex: { default: 0 }
},
+3 -2
View File
@@ -21,6 +21,7 @@
},
"files": [
"index.d.ts",
"aframe-tests.ts"
"test/aframe-tests.ts",
"test/aframe-io-tests.ts"
]
}
}
+99 -98
View File
@@ -1,109 +1,110 @@
import Agenda = require("agenda");
import { Db, Server } from "mongodb";
import { Db, Server, MongoClient } from "mongodb";
var mongoConnectionString = "mongodb://127.0.0.1/agenda";
var agenda = new Agenda({ db: { address: mongoConnectionString } });
(async () => {
var agenda = new Agenda({ db: { address: mongoConnectionString } });
var agenda = new Agenda({
mongo: (await MongoClient.connect(mongoConnectionString)).db(),
db: { collection: 'agenda-jobs' },
});
agenda.define<{ foo: Error }>('delete old users', (job, done) => {
done(job.attrs.data.foo)
agenda.define<{ foo: Error }>('delete old users', (job, done) => {
done(job.attrs.data.foo)
});
agenda.on('ready', () => {
agenda.every('3 minutes', 'delete old users');
// Alternatively, you could also do:
agenda.every('*/3 * * * *', 'delete old users');
agenda.start();
});
agenda.define('send email report', { priority: 'high', concurrency: 10 }, (job, done) => {
});
agenda.on('ready', () => {
agenda.schedule('in 20 minutes', 'send email report', { to: 'admin@example.com' });
agenda.start();
});
agenda.on('ready', () => {
var weeklyReport = agenda.create('send email report', { to: 'another-guy@example.com' });
weeklyReport.repeatEvery('1 week').save();
agenda.start();
});
var agenda = new Agenda({ processEvery: '30 seconds' });
agenda.defaultConcurrency(5);
var agenda = new Agenda({ defaultConcurrency: 5 });
agenda.lockLimit(0);
var agenda = new Agenda({ lockLimit: 0 });
agenda.defaultLockLimit(0);
var agenda = new Agenda({ defaultLockLimit: 0 });
agenda.defaultLockLifetime(10000);
var agenda = new Agenda({ defaultLockLifetime: 10000 });
agenda.define('some long running job', function (job, done) {
done();
});
agenda.every('15 minutes', ['printAnalyticsReport', 'sendNotifications', 'updateUserRecords']);
agenda.schedule('tomorrow at noon', 'printAnalyticsReport', { userCount: 100 });
agenda.schedule('tomorrow at noon', ['printAnalyticsReport', 'sendNotifications', 'updateUserRecords']);
agenda.now('do the hokey pokey');
var job = agenda.create<{ userCount: number }>('printAnalyticsReport', { userCount: 100 });
await job.save();
const jobs = await agenda.jobs({ name: 'printAnalyticsReport' });
jobs.forEach((job) => {
job.save();
});
let numRemoved = await agenda.cancel({ name: 'printAnalyticsReport' });
numRemoved = await agenda.purge();
await agenda.stop();
await job.agenda.now('do the hokey pokey');
job.repeatEvery('10 minutes');
job.repeatEvery('10 minutes', { timezone: 'America/New_York' });
job.repeatEvery('10 minutes', { skipImmediate: true });
job.repeatAt('3:30pm');
job.schedule('tomorrow at 6pm');
job.priority('low');
job.priority(10);
job.unique({ 'data.type': 'active', 'data.userId': '123' });
job.fail('insuficient disk space');
job.fail(new Error('insufficient disk space'));
const job2 = await job.run();
await job.remove();
});
agenda.on('ready', () => {
agenda.every('3 minutes', 'delete old users');
// Alternatively, you could also do:
agenda.every('*/3 * * * *', 'delete old users');
agenda.start();
});
agenda.define('send email report', { priority: 'high', concurrency: 10 }, (job, done) => {
});
agenda.on('ready', () => {
agenda.schedule('in 20 minutes', 'send email report', { to: 'admin@example.com' });
agenda.start();
});
agenda.on('ready', () => {
var weeklyReport = agenda.create('send email report', { to: 'another-guy@example.com' });
weeklyReport.repeatEvery('1 week').save();
agenda.start();
});
var agenda = new Agenda({ processEvery: '30 seconds' });
agenda.defaultConcurrency(5);
var agenda = new Agenda({ defaultConcurrency: 5 });
agenda.lockLimit(0);
var agenda = new Agenda({ lockLimit: 0 });
agenda.defaultLockLimit(0);
var agenda = new Agenda({ defaultLockLimit: 0 });
agenda.defaultLockLifetime(10000);
var agenda = new Agenda({ defaultLockLifetime: 10000 });
agenda.define('some long running job', function(job, done) {
done();
});
agenda.every('15 minutes', ['printAnalyticsReport', 'sendNotifications', 'updateUserRecords']);
agenda.schedule('tomorrow at noon', 'printAnalyticsReport', { userCount: 100 });
agenda.schedule('tomorrow at noon', ['printAnalyticsReport', 'sendNotifications', 'updateUserRecords']);
agenda.now('do the hokey pokey');
var job = agenda.create<{ userCount: number }>('printAnalyticsReport', { userCount: 100 });
job.save(function(err) {
console.log("Job successfully saved");
});
agenda.jobs({ name: 'printAnalyticsReport' }, function(err, jobs) {
// Work with jobs (see below)
});
agenda.cancel({ name: 'printAnalyticsReport' }, function(err, numRemoved) {
});
agenda.purge(function(err, numRemoved) {
});
agenda.stop(function() {
process.exit(0);
});
job.agenda.now('do the hokey pokey');
job.repeatEvery('10 minutes');
job.repeatAt('3:30pm');
job.schedule('tomorrow at 6pm');
job.priority('low');
job.priority(10);
job.unique({ 'data.type': 'active', 'data.userId': '123' });
job.fail('insuficient disk space');
job.fail(new Error('insufficient disk space'));
job.run(function(err, job) {
console.log("I don't know why you would need to do this...");
});
job.remove(function(err) {
if (!err) console.log("Successfully removed job from collection");
})
class ExtendedAgenda extends Agenda {
async start() { }
async start() { }
}
const extendedAgenda: ExtendedAgenda = new ExtendedAgenda()
+34 -51
View File
@@ -1,4 +1,4 @@
// Type definitions for Agenda v1.0.3
// Type definitions for Agenda v2.0.0
// Project: https://github.com/agenda/agenda
// Definitions by: Meir Gottlieb <https://github.com/meirgottlieb>
// Jeff Principe <https://github.com/princjef>
@@ -64,7 +64,7 @@ declare class Agenda extends EventEmitter {
defaultConcurrency(value: number): this;
/**
* Takes a number shich specifies the max number jobs that can be locked at any given moment. By default it is
* Takes a number which specifies the max number jobs that can be locked at any given moment. By default it is
* 0 for no max.
* @param value The value to set.
*/
@@ -95,16 +95,14 @@ declare class Agenda extends EventEmitter {
/**
* Find all Jobs matching `query` and pass same back in cb().
* @param query
* @param cb
*/
jobs<T extends Agenda.JobAttributesData = Agenda.JobAttributesData>(query: any, cb: ResultCallback<Agenda.Job<T>[]>): void;
jobs<T extends Agenda.JobAttributesData = Agenda.JobAttributesData>(query: any): Promise<Agenda.Job<T>[]>;
/**
* Removes all jobs in the database without defined behaviors. Useful if you change a definition name and want
* to remove old jobs.
* @param cb Called with the number of jobs removed.
*/
purge(cb?: ResultCallback<number>): void;
purge(): Promise<number>;
/**
* Defines a job with the name of jobName. When a job of job name gets run, it will be passed to fn(job, done).
@@ -123,46 +121,41 @@ declare class Agenda extends EventEmitter {
* @param names The name or names of the job(s) to run.
* @param data An optional argument that will be passed to the processing function under job.attrs.data.
* @param options An optional argument that will be passed to job.repeatEvery.
* @param cb An optional callback function which will be called when the job has been persisted in the database.
*/
every<T extends Agenda.JobAttributesData = Agenda.JobAttributesData>(interval: number | string, names: string, data?: T, options?: any, cb?: ResultCallback<Agenda.Job<T>>): Agenda.Job<T>;
every<T extends Agenda.JobAttributesData = Agenda.JobAttributesData>(interval: number | string, names: string[], data?: T, options?: any, cb?: ResultCallback<Agenda.Job<T>[]>): Agenda.Job<T>[];
every<T extends Agenda.JobAttributesData = Agenda.JobAttributesData>(interval: number | string, names: string, data?: T, options?: any): Promise<Agenda.Job<T>>;
every<T extends Agenda.JobAttributesData = Agenda.JobAttributesData>(interval: number | string, names: string[], data?: T, options?: any): Promise<Agenda.Job<T>[]>;
/**
* Schedules a job to run name once at a given time.
* @param when A Date or a String such as tomorrow at 5pm.
* @param names The name or names of the job(s) to run.
* @param data An optional argument that will be passed to the processing function under job.attrs.data.
* @param cb An optional callback function which will be called when the job has been persisted in the database.
*/
schedule<T extends Agenda.JobAttributesData = Agenda.JobAttributesData>(when: Date | string, names: string, data?: T, cb?: ResultCallback<Agenda.Job<T>>): Agenda.Job<T>;
schedule<T extends Agenda.JobAttributesData = Agenda.JobAttributesData>(when: Date | string, names: string[], data?: T, cb?: ResultCallback<Agenda.Job<T>[]>): Agenda.Job<T>[];
schedule<T extends Agenda.JobAttributesData = Agenda.JobAttributesData>(when: Date | string, names: string, data?: T): Promise<Agenda.Job<T>>;
schedule<T extends Agenda.JobAttributesData = Agenda.JobAttributesData>(when: Date | string, names: string[], data?: T): Promise<Agenda.Job<T>[]>;
/**
* Schedules a job to run name once immediately.
* @param name The name of the job to run.
* @param data An optional argument that will be passed to the processing function under job.attrs.data.
* @param cb An optional callback function which will be called when the job has been persisted in the database.
*/
now<T extends Agenda.JobAttributesData = Agenda.JobAttributesData>(name: string, data?: T, cb?: ResultCallback<Agenda.Job<T>>): Agenda.Job<T>;
now<T extends Agenda.JobAttributesData = Agenda.JobAttributesData>(name: string, data?: T): Promise<Agenda.Job<T>>;
/**
* Cancels any jobs matching the passed mongodb-native query, and removes them from the database.
* @param query Mongodb native query.
* @param cb Called with the number of jobs removed.
*/
cancel(query: any, cb?: ResultCallback<number>): void;
cancel(query: any): Promise<number>;
/**
* Starts the job queue processing, checking processEvery time to see if there are new jobs.
*/
start(): void;
start(): Promise<void>;
/**
* Stops the job queue processing. Unlocks currently running jobs.
* @param cb Called after the job processing queue shuts down and unlocks all jobs.
*/
stop(cb: Callback): void;
stop(): Promise<void>;
}
declare namespace Agenda {
@@ -196,7 +189,7 @@ declare namespace Agenda {
defaultLockLimit?: number;
/**
* Takes a number shich specifies the max number jobs that can be locked at any given moment. By default it is
* Takes a number which specifies the max number jobs that can be locked at any given moment. By default it is
* 0 for no max.
*/
lockLimit?: number;
@@ -210,17 +203,7 @@ declare namespace Agenda {
/**
* Specifies that Agenda should be initialized using and existing MongoDB connection.
*/
mongo?: {
/**
* The MongoDB database connection to use.
*/
db: Db;
/**
* The name of the collection to use.
*/
collection?: string;
}
mongo?: Db;
/**
* Specifies that Agenda should connect to MongoDB.
@@ -228,8 +211,10 @@ declare namespace Agenda {
db?: {
/**
* The connection URL.
* Required when using `db` option to connect.
* Not required when an existing connection is passed as `mongo` property.
*/
address: string;
address?: string;
/**
* The name of the collection to use.
@@ -238,6 +223,7 @@ declare namespace Agenda {
/**
* Connection options to pass to MongoDB.
* Not required when an existing connection is passed as `mongo` property.
*/
options?: any;
}
@@ -350,57 +336,57 @@ declare namespace Agenda {
/**
* Specifies an interval on which the job should repeat.
* @param interval A human-readable format String, a cron format String, or a Number.
* @param options An optional argument that can include a timezone field. The timezone should be a string as
* accepted by moment-timezone and is considered when using an interval in the cron string format.
* @param options An optional argument that can include a timezone field or skipImmediate field.
* The timezone should be a string as accepted by moment-timezone and is considered when using an interval in the cron string format.
* Setting skipImmediate as true will skip the immediate run. The first run will occur only in configured interval.
*/
repeatEvery(interval: string | number, options?: { timezone?: string }): Job<T>
repeatEvery(interval: string | number, options?: { timezone?: string, skipImmediate?: boolean }): this
/**
* Specifies a time when the job should repeat. [Possible values](https://github.com/matthewmueller/date#examples).
* @param time
*/
repeatAt(time: string): Job<T>
repeatAt(time: string): this
/**
* Disables the job.
*/
disable(): Job<T>;
disable(): this;
/**
* Enables the job.
*/
enable(): Job<T>;
enable(): this;
/**
* Ensure that only one instance of this job exists with the specified properties
* @param value The properties associated with the job that must be unqiue.
* @param opts
*/
unique(value: any, opts?: { insertOnly?: boolean }): Job<T>;
unique(value: any, opts?: { insertOnly?: boolean }): this;
/**
* Specifies the next time at which the job should run.
* @param time The next time at which the job should run.
*/
schedule(time: string | Date): Job<T>;
schedule(time: string | Date): this;
/**
* Specifies the priority weighting of the job.
* @param value The priority of the job (lowest|low|normal|high|highest|number).
*/
priority(value: string | number): Job<T>;
priority(value: string | number): this;
/**
* Sets job.attrs.failedAt to now, and sets job.attrs.failReason to reason.
* @param reason A message or Error object that indicates why the job failed.
*/
fail(reason: string | Error): Job<T>;
fail(reason: string | Error): this;
/**
* Runs the given job and calls callback(err, job) upon completion. Normally you never need to call this manually
* @param cb Called when the job is completed.
*/
run(cb?: ResultCallback<Job<T>>): Job<T>;
run(): Promise<this>;
/**
* Returns true if the job is running; otherwise, returns false.
@@ -409,27 +395,24 @@ declare namespace Agenda {
/**
* Saves the job into the database.
* @param cb Called when the job is saved.
*/
save(cb?: ResultCallback<Job<T>>): Job<T>;
save(): Promise<this>;
/**
* Removes the job from the database and cancels the job.
* @param cb Called after the job has beeb removed from the database.
*/
remove(cb?: Callback): void;
remove(): Promise<void>;
/**
* Resets the lock on the job. Useful to indicate that the job hasn't timed out when you have very long running
* jobs.
* @param cb Called after the job has been saved to the database.
*/
touch(cb?: Callback): void;
touch(): Promise<this>;
/**
* Calculates next time the job should run
*/
computeNextRunAt(): Job<T>;
computeNextRunAt(): this;
}
interface JobOptions {
+23
View File
@@ -0,0 +1,23 @@
import agent = require('agent-base');
agent(); // $ExpectType Agent
agent({ timeout: 1000 }); // $ExpectType Agent
agent((req, opts) => {}); // $ExpectType Agent
agent((req, opts) => {}, { timeout: 1000 }); // $ExpectType Agent
agent(async (req, opts) => {}); // $ExpectType Agent
agent(async (req, opts) => {}, { timeout: 1000 }); // $ExpectType Agent
agent(0); // $ExpectError
agent(1); // $ExpectError
agent(''); // $ExpectError
agent(true); // $ExpectError
agent(null); // $ExpectError
agent((req, opts) => {}, 0); // $ExpectError
agent((req, opts) => {}, 1); // $ExpectError
agent((req, opts) => {}, ''); // $ExpectError
agent((req, opts) => {}, true); // $ExpectError
agent((req, opts) => {}, null); // $ExpectError
agent((req, opts) => {}, (req, opts) => {}); // $ExpectError
+44
View File
@@ -0,0 +1,44 @@
// Type definitions for agent-base 4.2
// Project: https://github.com/TooTallNate/node-agent-base#readme
// Definitions by: Christopher Quadflieg <https://github.com/Shinigami92>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference types="node" />
import { EventEmitter } from 'events';
declare namespace Agent {
type AgentCallback = (
req?: any,
opts?: {
secureEndpoint: boolean;
}
) => void;
interface AgentOptions {
timeout?: number;
host?: string;
port?: number;
[key: string]: any;
}
interface Agent extends EventEmitter {
_promisifiedCallback: boolean;
timeout: number | null;
options?: AgentOptions;
callback: AgentCallback;
addRequest: (req?: any, opts?: any) => void;
freeSocket: (socket: any, opts: any) => void;
}
}
/**
* Base `http.Agent` implementation.
* No pooling/keep-alive is implemented by default.
*/
declare function Agent(opts?: Agent.AgentOptions): Agent.Agent;
declare function Agent(
callback: Agent.AgentCallback,
opts?: Agent.AgentOptions
): Agent.Agent;
export = Agent;
+24
View File
@@ -0,0 +1,24 @@
{
"compilerOptions": {
"module": "commonjs",
"target": "es6",
"lib": [
"es6"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"agent-base-tests.ts"
]
}
@@ -0,0 +1,206 @@
import * as React from 'react';
import * as PropTypes from 'prop-types';
import * as AirbnbPropTypes from 'airbnb-prop-types';
class ClassComp extends React.Component {
render() {
return null;
}
}
function FuncComp() {
return null;
}
// $ExpectType Requireable<number | null>
AirbnbPropTypes.and([PropTypes.number]);
// $ExpectType Requireable<number | null>
AirbnbPropTypes.and([PropTypes.number, AirbnbPropTypes.nonNegativeInteger]);
// $ExpectType Validator<number>
AirbnbPropTypes.and([PropTypes.number, AirbnbPropTypes.integer()], 'foo').isRequired;
// $ExpectType Requireable<number>
AirbnbPropTypes.between({ lt: 1 });
// $ExpectType Requireable<number>
AirbnbPropTypes.between({ lte: 2 });
// $ExpectType Requireable<number>
AirbnbPropTypes.between({ gt: 3 });
// $ExpectType Requireable<number>
AirbnbPropTypes.between({ gte: 4 });
// $ExpectType Requireable<number>
AirbnbPropTypes.between({ lt: 1, gt: 0 });
// $ExpectType Requireable<boolean>
AirbnbPropTypes.booleanSome('foo', 'bar', 'baz');
// $ExpectType Requireable<ReactNodeLike>
AirbnbPropTypes.childrenHavePropXorChildren('foo');
// $ExpectType Requireable<ReactNodeLike>
AirbnbPropTypes.childrenOf(PropTypes.string);
// $ExpectType Requireable<ReactNodeLike>
AirbnbPropTypes.childrenOfType(ClassComp);
// $ExpectType Requireable<ReactNodeLike>
AirbnbPropTypes.childrenOfType(FuncComp);
// $ExpectType Requireable<ReactNodeLike>
AirbnbPropTypes.childrenOfType('div');
// $ExpectType Requireable<ReactNodeLike>
AirbnbPropTypes.childrenOfType(ClassComp, FuncComp, 'div');
// $ExpectType Requireable<ReactNodeLike>
AirbnbPropTypes.childrenSequenceOf({ validator: PropTypes.number });
// $ExpectType Requireable<ReactNodeLike>
AirbnbPropTypes.childrenSequenceOf({ validator: PropTypes.string, max: 100 });
// $ExpectType Requireable<ReactNodeLike>
AirbnbPropTypes.childrenSequenceOf({ validator: PropTypes.bool, min: 0 });
// $ExpectType Requireable<ReactNodeLike>
AirbnbPropTypes.componentWithName('Foo');
// $ExpectType Requireable<ReactNodeLike>
AirbnbPropTypes.componentWithName(/Foo/);
// $ExpectType Requireable<ReactNodeLike>
AirbnbPropTypes.componentWithName('Foo', { stripHOCs: ['connect'] });
// $ExpectType Requireable<number>
AirbnbPropTypes.disallowedIf(PropTypes.number, 'foo', PropTypes.string);
// $ExpectType Requireable<ReactElementLike>
AirbnbPropTypes.elementType(ClassComp);
// $ExpectType Requireable<ReactElementLike>
AirbnbPropTypes.elementType(FuncComp);
// $ExpectType Requireable<ReactElementLike>
AirbnbPropTypes.elementType('div');
// $ExpectType Requireable<ReactElementLike>
AirbnbPropTypes.elementType('*');
// $ExpectError
AirbnbPropTypes.elementType(ClassComp, FuncComp, 'div');
// $ExpectType Requireable<null | undefined>
AirbnbPropTypes.explicitNull();
// $ExpectType Validator<never>
AirbnbPropTypes.explicitNull().isRequired;
interface ForbidShape {
foo: string;
bar: number;
baz?: boolean | null;
}
// $ExpectType ValidationMap<{ foo: string | null; bar: number; baz: boolean | null; }>
AirbnbPropTypes.forbidExtraProps({
foo: PropTypes.string,
bar: PropTypes.number.isRequired,
baz: PropTypes.bool,
});
// $ExpectType ValidationMap<ForbidShape>
AirbnbPropTypes.forbidExtraProps<ForbidShape>({
foo: PropTypes.string.isRequired,
bar: PropTypes.number.isRequired,
baz: PropTypes.bool,
});
// $ExpectType Requireable<number>
AirbnbPropTypes.integer();
// $ExpectType Requireable<{}>
AirbnbPropTypes.keysOf(PropTypes.number);
// $ExpectType Requireable<{}>
AirbnbPropTypes.keysOf(PropTypes.number, 'foo');
// $ExpectType Requireable<{}>
AirbnbPropTypes.keysOf(PropTypes.oneOf(['foo', 'bar']));
// $ExpectType Requireable<number>
AirbnbPropTypes.mutuallyExclusiveProps(PropTypes.number);
// $ExpectType Requireable<number>
AirbnbPropTypes.mutuallyExclusiveProps(PropTypes.number, 'foo');
// $ExpectType Requireable<string>
AirbnbPropTypes.mutuallyExclusiveProps(PropTypes.string, 'foo', 'bar');
// $ExpectType Requireable<boolean>
AirbnbPropTypes.mutuallyExclusiveTrueProps('foo');
// $ExpectType Requireable<boolean>
AirbnbPropTypes.mutuallyExclusiveTrueProps('foo', 'bar');
// $ExpectType Requireable<ReactNodeLike>
AirbnbPropTypes.nChildren(1, PropTypes.number);
// $ExpectType Requireable<ReactNodeLike>
AirbnbPropTypes.nChildren(1, AirbnbPropTypes.childrenOfType('span'));
// $ExpectType Requireable<number>
AirbnbPropTypes.nonNegativeInteger;
// $ExpectType Requireable<number>
AirbnbPropTypes.nonNegativeNumber();
// $ExpectType Requireable<string>
AirbnbPropTypes.numericString();
// $ExpectType Requireable<{}>
AirbnbPropTypes.object();
// $ExpectType Requireable<{ foo: string; }>
AirbnbPropTypes.object<{ foo: string }>();
AirbnbPropTypes.or([PropTypes.bool.isRequired, AirbnbPropTypes.explicitNull().isRequired]);
AirbnbPropTypes.or([PropTypes.bool, PropTypes.number, PropTypes.arrayOf(PropTypes.string)]);
AirbnbPropTypes.or([PropTypes.number, PropTypes.string, PropTypes.bool], 'foo');
// $ExpectType Requireable<number>
AirbnbPropTypes.range(0, 10);
// $ExpectType Requireable<5>
AirbnbPropTypes.range<5>(0, 10);
// $ExpectType Requireable<string | null>
AirbnbPropTypes.requiredBy('foo', PropTypes.string);
// $ExpectType Validator<number>
AirbnbPropTypes.requiredBy('bar', PropTypes.number, 42).isRequired;
// $ExpectType Requireable<{}>
AirbnbPropTypes.restrictedProp();
// $ExpectType Requireable<{}>
AirbnbPropTypes.restrictedProp(() => 'Error');
// $ExpectType Requireable<{}>
AirbnbPropTypes.restrictedProp(() => new Error('Error'));
// $ExpectType Requireable<{}>
AirbnbPropTypes.sequenceOf({ validator: PropTypes.number });
// $ExpectType Requireable<{}>
AirbnbPropTypes.sequenceOf({ validator: PropTypes.number }, { validator: PropTypes.string });
// $ExpectType Requireable<{}>
AirbnbPropTypes.sequenceOf(
{ validator: PropTypes.number, min: 0, max: 10 },
{ validator: PropTypes.string },
{ validator: PropTypes.bool },
);
interface ShapeShape {
foo: string;
bar?: number | null;
}
// $ExpectType Requireable<{ foo: string | null; }>
AirbnbPropTypes.shape({
foo: PropTypes.string,
});
// $ExpectType Requireable<{ foo: string | null; bar: number | null; }>
AirbnbPropTypes.shape({
foo: PropTypes.string,
bar: PropTypes.number,
});
// $ExpectType Requireable<ShapeShape>
AirbnbPropTypes.shape<ShapeShape>({
foo: PropTypes.string.isRequired,
bar: PropTypes.number,
});
// $ExpectType Requireable<string>
AirbnbPropTypes.stringStartsWith('foo');
// $ExpectType Requireable<any[]>
AirbnbPropTypes.uniqueArray();
// $ExpectType Requireable<string[]>
AirbnbPropTypes.uniqueArray<string>();
// $ExpectType Requireable<{ [key: string]: number | null; }>
AirbnbPropTypes.valuesOf(PropTypes.number);
+198
View File
@@ -0,0 +1,198 @@
// Type definitions for airbnb-prop-types 2.11
// Project: https://github.com/airbnb/prop-types
// Definitions by: Miles Johnson <https://github.com/milesj>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 3.0
import * as PropTypes from 'prop-types';
export interface ReactComponentLike {
setState(...args: any[]): any;
forceUpdate(...args: any[]): any;
render(): PropTypes.ReactNodeLike;
props: any;
state: any;
context: any;
refs: any;
}
export interface ReactClassComponentLike {
new (...args: any[]): ReactComponentLike;
}
export type ReactFunctionComponentLike = (...args: any[]) => PropTypes.ReactNodeLike;
export type ReactTypeLike = string | ReactClassComponentLike | ReactFunctionComponentLike;
export interface Specifier<T = any> {
max?: number;
min?: number;
validator: PropTypes.Validator<T>;
}
export function and<A>(
propTypes: [PropTypes.Validator<A>],
name?: string,
): PropTypes.Requireable<A>;
export function and<A, B>(
propTypes: [PropTypes.Validator<A>, PropTypes.Validator<B>],
name?: string,
): PropTypes.Requireable<A & B>;
export function and<A, B, C>(
propTypes: [PropTypes.Validator<A>, PropTypes.Validator<B>, PropTypes.Validator<C>],
name?: string,
): PropTypes.Requireable<A & B & C>;
export function and<T>(
propTypes: Array<PropTypes.Validator<any>>,
name?: string,
): PropTypes.Requireable<T>;
export function between(options: {
lt?: number;
lte?: number;
gt?: number;
gte?: number;
}): PropTypes.Requireable<number>;
export function booleanSome(...props: string[]): PropTypes.Requireable<boolean>;
export function childrenHavePropXorChildren<T = PropTypes.ReactNodeLike>(
prop: string | symbol,
): PropTypes.Requireable<T>;
export function childrenOf<T = PropTypes.ReactNodeLike, P = any>(
propType: PropTypes.Validator<P>,
): PropTypes.Requireable<T>;
export function childrenOfType<T = PropTypes.ReactNodeLike>(
...types: ReactTypeLike[]
): PropTypes.Requireable<T>;
export function childrenSequenceOf<T = PropTypes.ReactNodeLike>(
...specifiers: Specifier[]
): PropTypes.Requireable<T>;
export function componentWithName<T = PropTypes.ReactNodeLike>(
name: string | RegExp,
options?: { stripHOCs: ReadonlyArray<string> },
): PropTypes.Requireable<T>;
export function disallowedIf<T>(
propType: PropTypes.Requireable<T>,
otherPropName: string,
otherPropType: PropTypes.Validator<any>,
): PropTypes.Requireable<T>;
export function elementType<T = PropTypes.ReactElementLike>(
type: ReactTypeLike,
): PropTypes.Requireable<T>;
export function explicitNull(): PropTypes.Requireable<null | undefined>;
export function forbidExtraProps<T extends object>(
propTypes: PropTypes.ValidationMap<T>,
): PropTypes.ValidationMap<T>;
export function integer(): PropTypes.Requireable<number>;
export function keysOf<T, P>(
propType: PropTypes.Validator<P>,
name?: string,
): PropTypes.Requireable<T>;
export function mutuallyExclusiveProps<T>(
propType: PropTypes.Requireable<T>,
...propNames: string[]
): PropTypes.Requireable<T>;
export function mutuallyExclusiveProps<T>(
// tslint:disable-next-line:unified-signatures
propType: PropTypes.Validator<T>,
...propNames: string[]
): PropTypes.Requireable<T>;
export function mutuallyExclusiveTrueProps(...propNames: string[]): PropTypes.Requireable<boolean>;
export function nChildren<T = PropTypes.ReactNodeLike, P = any>(
n: number,
propType?: PropTypes.Validator<P>,
): PropTypes.Requireable<T>;
export const nonNegativeInteger: PropTypes.Requireable<number>;
export function nonNegativeNumber(): PropTypes.Requireable<number>;
export function numericString(): PropTypes.Requireable<string>;
export function object<T extends object>(): PropTypes.Requireable<T>;
export function or<A>(propTypes: [PropTypes.Validator<A>], name?: string): PropTypes.Requireable<A>;
export function or<A, B>(
propTypes: [PropTypes.Validator<A>, PropTypes.Validator<B>],
name?: string,
): PropTypes.Requireable<A | B>;
export function or<A, B, C>(
propTypes: [PropTypes.Validator<A>, PropTypes.Validator<B>, PropTypes.Validator<C>],
name?: string,
): PropTypes.Requireable<A | B | C>;
export function or<T>(
propTypes: Array<PropTypes.Validator<T>>,
name?: string,
): PropTypes.Requireable<T>;
export function or<T = any>(
// tslint:disable-next-line:unified-signatures
propTypes: Array<PropTypes.Validator<any>>,
name?: string,
): PropTypes.Requireable<T>;
export function range<T extends number>(min?: number, max?: number): PropTypes.Requireable<T>;
export function range(min?: number, max?: number): PropTypes.Requireable<number>;
export function requiredBy<P>(
requiredByPropName: string,
propType: PropTypes.Validator<P>,
defaultValue?: any,
): PropTypes.Requireable<P>;
export function restrictedProp<T>(
messageFunction?: (
props: object,
propName: string,
componentName: string,
location: string,
propFullName: string,
) => string | Error | undefined,
): PropTypes.Requireable<T>;
export function sequenceOf<T>(...specifiers: Specifier[]): PropTypes.Requireable<T>;
export function shape<T extends object>(
propTypes: PropTypes.ValidationMap<T>,
): PropTypes.Requireable<T>;
export function stringStartsWith(string: string): PropTypes.Requireable<string>;
export function uniqueArray<T = any>(): PropTypes.Requireable<T[]>;
export function uniqueArrayOf<T, P>(
propType: PropTypes.Validator<P>,
mapperOrName: ((value: any) => any) | string,
name?: string,
): PropTypes.Requireable<T[]>;
export function valuesOf<T>(
propType: PropTypes.Validator<T>,
): PropTypes.Requireable<{ [key: string]: T }>;
export function withShape<T extends object, P, S>(
propType: PropTypes.Validator<P>,
propTypes: PropTypes.ValidationMap<S>,
): PropTypes.Requireable<T>;
+16
View File
@@ -0,0 +1,16 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": ["es6"],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": ["../"],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": ["index.d.ts", "airbnb-prop-types-tests.ts"]
}
@@ -1,8 +1,6 @@
{
"extends": "dtslint/dt.json",
"rules": {
// TODO
"no-any-union": false,
"no-unnecessary-generics": false
}
}
+1
View File
@@ -2,6 +2,7 @@
// Project: https://github.com/epoberezkin/ajv-errors
// Definitions by: Afshawn Lotfi <https://github.com/afshawnlotfi>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.2
import { Ajv } from "ajv";
@@ -1,6 +1,6 @@
{
"private": true,
"dependencies": {
"tslint": "*"
"ajv": "*"
}
}
@@ -0,0 +1,22 @@
import { parse, stringify } from 'ale-url-parser';
let url;
let urlObject;
url = stringify({});
console.log(url);
url = stringify({
protocol: 'protocol',
host: 'host',
path: ['foo', 'bar', 'baz'],
hash: 'hash',
query: {
foo: 1,
bar: [2, '3']
}
});
console.log(url);
urlObject = parse('//any.dom.ain.co.m/foo/bar?test=1&test=2#hash');
console.log(urlObject);
+29
View File
@@ -0,0 +1,29 @@
// Type definitions for ale-url-parser 0.10
// Project: https://github.com/msn0/ale-url-parser#readme
// Definitions by: Michał Jezierski <https://github.com/msn0>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
export interface QueryParams {
[key: string]: any;
}
export interface UrlObject {
protocol?: string;
host?: string;
path?: string[];
query?: QueryParams;
hash?: string;
}
/**
* Parse url string into url object.
* @return UrlObject
*/
export function parse(url: string): UrlObject;
/**
* Stringify url object into url string.
* @return string
*/
export function stringify(urlObject: UrlObject): string;
+24
View File
@@ -0,0 +1,24 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6",
"dom"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"ale-url-parser-tests.ts"
]
}
+45 -12
View File
@@ -21,6 +21,7 @@ let _algoliaResponse: Response = {
processingTimeMS: 32,
query: '',
params: '',
index: '',
};
let _clientOptions: ClientOptions = {
@@ -103,7 +104,8 @@ let _algoliaQueryParameters: QueryParameters = {
filters: '',
attributesToRetrieve: [''],
restrictSearchableAttributes: [''],
facets: '',
facets: [''],
facetingAfterDistinct: true,
maxValuesPerFacet: 2,
attributesToHighlight: [''],
attributesToSnippet: [''],
@@ -120,28 +122,29 @@ let _algoliaQueryParameters: QueryParameters = {
typoTolerance: false,
allowTyposOnNumericTokens: false,
ignorePlurals: false,
disableTypoToleranceOnAttributes: '',
disableTypoToleranceOnAttributes: [''],
aroundLatLng: '',
aroundLatLngViaIP: '',
aroundRadius: 0,
aroundPrecision: 0,
minimumAroundRadius: 0,
insideBoundingBox: [[0]],
queryType: '',
queryType: 'prefixAll',
insidePolygon: [[0]],
removeWordsIfNoResults: '',
removeWordsIfNoResults: 'firstWords',
advancedSyntax: false,
optionalWords: [''],
removeStopWords: [''],
disableExactOnAttributes: [''],
exactOnSingleWordQuery: '',
alternativesAsExact: true,
exactOnSingleWordQuery: 'attribute',
alternativesAsExact: ["ignorePlurals"],
distinct: 0,
getRankingInfo: false,
numericAttributesToIndex: [''],
numericAttributesForFiltering: [''],
numericFilters: [''],
tagFilters: '',
facetFilters: '',
tagFilters: [''],
facetFilters: [''],
analytics: false,
analyticsTags: [''],
synonyms: true,
@@ -171,8 +174,38 @@ index.partialUpdateObjects([{}], false).then(() => {});
let indexName : string = index.indexName;
// complete copy
client.copyIndex('from', 'to').then(()=>{})
client.copyIndex('from', 'to', ()=> {})
client.copyIndex('from', 'to').then(()=>{});
client.copyIndex('from', 'to', ()=> {});
// with scope
client.copyIndex('from', 'to', ['settings']).then(()=>{})
client.copyIndex('from', 'to', ['synonyms', 'rules'], ()=> {})
client.copyIndex('from', 'to', ['settings']).then(()=>{});
client.copyIndex('from', 'to', ['synonyms', 'rules'], ()=> {});
// Browsing
const browser = index.browseAll();
index.browseAll('query');
index.browseAll('', {
filters: 'dog',
});
let hits: Object[] = [];
browser.on('result', function onResult(content) {
hits = hits.concat(content.hits);
});
browser.on('end', function onEnd() {
const _message = `We got ${hits.length} hits`
});
browser.on('error', function onError(err) {
throw err;
});
browser.stop();
index.browse("", {
advancedSyntax: false,
attributesToRetrieve: ['dogs']
});
client.copyIndex('from', 'to', ['settings']).then(()=>{});
client.copyIndex('from', 'to', ['synonyms', 'rules'], ()=> {});
+163 -99
View File
@@ -1,11 +1,14 @@
// Type definitions for algoliasearch-client-js 3.27.0
// Type definitions for algoliasearch-client-js 3.30.0
// Project: https://github.com/algolia/algoliasearch-client-js
// Definitions by: Baptiste Coquelle <https://github.com/cbaptiste>
// Haroen Viaene <https://github.com/haroenv>
// Aurélien Hervé <https://github.com/aherve>
// Samuel Vaillant <https://github.com/samouss>
// Kai Eichinger <https://github.com/keichinger>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.2
// TypeScript Version: 2.8
type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>
declare namespace algoliasearch {
/**
@@ -611,6 +614,11 @@ declare namespace algoliasearch {
options: SearchForFacetValues.Parameters,
cb: (err: Error, res: SearchForFacetValues.Response) => void
): void;
/**
* Browse an index
* https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
*/
browse(query: string, parameters: BrowseParameters, cb: (err: Error, res: BrowseResponse) => void): void;
/**
* Browse an index
* https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
@@ -620,7 +628,7 @@ declare namespace algoliasearch {
* Browse an index
* https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
*/
browse(query: string): Promise<BrowseResponse>;
browse(query: string, parameters?: BrowseParameters): Promise<BrowseResponse>;
/**
* Browse an index from a cursor
* https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
@@ -638,7 +646,7 @@ declare namespace algoliasearch {
* Browse an entire index
* https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
*/
browseAll(): Promise<Response>;
browseAll(query?: string, parameters?: BrowseParameters): Browser;
/**
* Clear an index content
* https://github.com/algolia/algoliasearch-client-js#clear-index---clearindex
@@ -966,6 +974,22 @@ declare namespace algoliasearch {
query: string;
processingTimeMS: number;
}
type BrowseParameters = Omit<
QueryParameters,
| "typoTolerance"
| "distinct"
| "facets"
| "getRankingInfo"
| "attributesToHighlight"
| "attributesToSnippet"
>
interface Browser {
on(type: "error", cb: (err: Error) => void): void
on(type: "end", cb: () => void): void
on(type: "stop", cb: () => void): void
on(type: "result", cb: (content: BrowseResponse) => void): void
stop(): void
}
/**
* Describes a synonym object
*/
@@ -1099,112 +1123,121 @@ declare namespace algoliasearch {
userToken?: string;
}
interface QueryParameters {
/**
* Query string used to perform the search
* default: ''
* https://www.algolia.com/doc/api-reference/api-parameters/query/
*/
query?: string;
/**
* Filter the query with numeric, facet or/and tag filters
* default: ""
* https://www.algolia.com/doc/api-reference/api-parameters/filters/
*/
filters?: string;
/**
* A string that contains the list of attributes you want to retrieve in order to minimize the size of the JSON answer.
* default: *
* https://www.algolia.com/doc/api-reference/api-parameters/attributesToRetrieve/
*/
attributesToRetrieve?: string[];
/**
* List of attributes you want to use for textual search
* default: attributeToIndex
* https://www.algolia.com/doc/api-reference/api-parameters/restrictSearchableAttributes/
*/
restrictSearchableAttributes?: string[];
/**
* You can use facets to retrieve only a part of your attributes declared in attributesForFaceting attributes
* default: []
* https://www.algolia.com/doc/api-reference/api-parameters/facets/
*/
facets?: string[];
/**
* Query string used to perform the search
* default: ''
* https://github.com/algolia/algoliasearch-client-js#query
*/
query?: string;
/**
* Filter the query with numeric, facet or/and tag filters
* default: ""
* https://github.com/algolia/algoliasearch-client-js#filters
*/
filters?: string;
/**
* A string that contains the list of attributes you want to retrieve in order to minimize the size of the JSON answer.
* default: *
* https://github.com/algolia/algoliasearch-client-js#attributestoretrieve
*/
attributesToRetrieve?: string[];
/**
* List of attributes you want to use for textual search
* default: attributeToIndex
* https://github.com/algolia/algoliasearch-client-js#restrictsearchableattributes
*/
restrictSearchableAttributes?: string[];
/**
* You can use facets to retrieve only a part of your attributes declared in attributesForFaceting attributes
* default: ""
* https://github.com/algolia/algoliasearch-client-js#facets
*/
facets?: string;
* Force faceting to be applied after de-duplication (via the Distinct setting).
* When using the distinct setting in combination with faceting, facet counts may be higher than expected.
* This is because the engine, by default, computes faceting before applying de-duplication (distinct).
* When facetingAfterDistinct is set to true, the engine calculates faceting after the de-duplication has been applied.
* default ""
* https://www.algolia.com/doc/api-reference/api-parameters/facetingAfterDistinct/
*/
facetingAfterDistinct?: boolean;
/**
* Limit the number of facet values returned for each facet.
* default: ""
* https://github.com/algolia/algoliasearch-client-js#maxvaluesperfacet
* default: 100
* https://www.algolia.com/doc/api-reference/api-parameters/maxValuesPerFacet/
*/
maxValuesPerFacet?: number;
/**
* Default list of attributes to highlight. If set to null, all indexed attributes are highlighted.
* default: null
* https://github.com/algolia/algoliasearch-client-js#attributestohighlight
* https://www.algolia.com/doc/api-reference/api-parameters/attributesToHighlight/
*/
attributesToHighlight?: string[];
/**
* Default list of attributes to snippet alongside the number of words to return
* default: null
* https://github.com/algolia/algoliasearch-client-js#attributestosnippet
* https://www.algolia.com/doc/api-reference/api-parameters/attributesToSnippet/
*/
attributesToSnippet?: string[];
/**
* Specify the string that is inserted before the highlighted parts in the query result
* default: <em>
* https://github.com/algolia/algoliasearch-client-js#highlightpretag
* https://www.algolia.com/doc/api-reference/api-parameters/highlightPreTag/
*/
highlightPreTag?: string;
/**
* Specify the string that is inserted after the highlighted parts in the query result
* default: </em>
* https://github.com/algolia/algoliasearch-client-js#highlightposttag
* https://www.algolia.com/doc/api-reference/api-parameters/highlightPostTag/
*/
highlightPostTag?: string;
/**
* String used as an ellipsis indicator when a snippet is truncated.
* default: …
* https://github.com/algolia/algoliasearch-client-js#snippetellipsistext
* https://www.algolia.com/doc/api-reference/api-parameters/snippetEllipsisText/
*/
snippetEllipsisText?: string;
/**
* If set to true, restrict arrays in highlights and snippets to items that matched the query at least partially else return all array items in highlights and snippets
* default: false
* https://github.com/algolia/algoliasearch-client-js#restricthighlightandsnippetarrays
* https://www.algolia.com/doc/api-reference/api-parameters/restrictHighlightAndSnippetArrays/
*/
restrictHighlightAndSnippetArrays?: boolean;
/**
* Pagination parameter used to select the number of hits per page
* default: 20
* https://github.com/algolia/algoliasearch-client-js#hitsperpage
* https://www.algolia.com/doc/api-reference/api-parameters/hitsPerPage/
*/
hitsPerPage?: number;
/**
* Pagination parameter used to select the page to retrieve.
* default: 0
* https://github.com/algolia/algoliasearch-client-js#page
* https://www.algolia.com/doc/api-reference/api-parameters/page/
*/
page?: number;
/**
* Offset of the first hit to return
* default: null
* https://github.com/algolia/algoliasearch-client-js#offset
* https://www.algolia.com/doc/api-reference/api-parameters/offset/
*/
offset?: number;
/**
* Number of hits to return.
* default: null
* https://github.com/algolia/algoliasearch-client-js#length
* https://www.algolia.com/doc/api-reference/api-parameters/length/
*/
length?: number;
/**
* The minimum number of characters needed to accept one typo.
* default: 4
* https://github.com/algolia/algoliasearch-client-js#minwordsizefor1typo
* https://www.algolia.com/doc/api-reference/api-parameters/minWordSizefor1Typo/
*/
minWordSizefor1Typo?: number;
/**
* The minimum number of characters needed to accept two typo.
* fault: 8
* https://github.com/algolia/algoliasearch-client-js#minwordsizefor2typos
* https://www.algolia.com/doc/api-reference/api-parameters/minWordSizefor2Typos/
*/
minWordSizefor2Typos?: number;
/**
@@ -1214,62 +1247,62 @@ declare namespace algoliasearch {
* 'false' The typo tolerance is disabled. All results with typos will be hidden.
* 'min' Only keep results with the minimum number of typos
* 'strict' Hits matching with 2 typos are not retrieved if there are some matching without typos.
* https://github.com/algolia/algoliasearch-client-js#minwordsizefor2typos
* https://www.algolia.com/doc/api-reference/api-parameters/typoTolerance/
*/
typoTolerance?: boolean;
/**
* If set to false, disables typo tolerance on numeric tokens (numbers).
* default:
* https://github.com/algolia/algoliasearch-client-js#allowtyposonnumerictokens
* https://www.algolia.com/doc/api-reference/api-parameters/allowTyposOnNumericTokens/
*/
allowTyposOnNumericTokens?: boolean;
/**
* If set to true, plural won't be considered as a typo
* default: false
* https://github.com/algolia/algoliasearch-client-js#ignoreplurals
* https://www.algolia.com/doc/api-reference/api-parameters/ignorePlurals/
*/
ignorePlurals?: boolean;
/**
* List of attributes on which you want to disable typo tolerance
* default: ""
* https://github.com/algolia/algoliasearch-client-js#disabletypotoleranceonattributes
* default: []
* https://www.algolia.com/doc/api-reference/api-parameters/disableTypoToleranceOnAttributes/
*/
disableTypoToleranceOnAttributes?: string;
disableTypoToleranceOnAttributes?: string[];
/**
* Search for entries around a given location
* default: ""
* https://github.com/algolia/algoliasearch-client-js#aroundlatlng
* https://www.algolia.com/doc/api-reference/api-parameters/aroundLatLng/
*/
aroundLatLng?: string;
/**
* Search for entries around a given latitude/longitude automatically computed from user IP address.
* default: ""
* https://github.com/algolia/algoliasearch-client-js#aroundlatlngviaip
* https://www.algolia.com/doc/api-reference/api-parameters/aroundLatLngViaIP/
*/
aroundLatLngViaIP?: string;
/**
* Control the radius associated with a geo search. Defined in meters.
* default: null
* You can specify aroundRadius=all if you want to compute the geo distance without filtering in a geo area
* https://github.com/algolia/algoliasearch-client-js#aroundradius
* https://www.algolia.com/doc/api-reference/api-parameters/aroundRadius/
*/
aroundRadius?: number | 'all';
/**
* Control the precision of a geo search
* default: null
* https://github.com/algolia/algoliasearch-client-js#aroundprecision
* https://www.algolia.com/doc/api-reference/api-parameters/aroundPrecision/
*/
aroundPrecision?: number;
/**
* Define the minimum radius used for a geo search when aroundRadius is not set.
* default: null
* https://github.com/algolia/algoliasearch-client-js#minimumaroundradius
* https://www.algolia.com/doc/api-reference/api-parameters/minimumAroundRadius/
*/
minimumAroundRadius?: number;
/**
* Search entries inside a given area defined by the two extreme points of a rectangle
* default: null
* https://github.com/algolia/algoliasearch-client-js#insideboundingbox
* https://www.algolia.com/doc/api-reference/api-parameters/insideBoundingBox/
*/
insideBoundingBox?: number[][];
/**
@@ -1278,13 +1311,13 @@ declare namespace algoliasearch {
* 'prefixAll' All query words are interpreted as prefixes. This option is not recommended.
* 'prefixLast' Only the last word is interpreted as a prefix (default behavior).
* 'prefixNone' No query word is interpreted as a prefix. This option is not recommended.
* https://github.com/algolia/algoliasearch-client-js#querytype
* https://www.algolia.com/doc/api-reference/api-parameters/queryType/
*/
queryType?: any;
queryType?: "prefixAll"|"prefixLast"|"prefixNone";
/**
* Search entries inside a given area defined by a set of points
* defauly: ''
* https://github.com/algolia/algoliasearch-client-js#insidepolygon
* https://www.algolia.com/doc/api-reference/api-parameters/insidePolygon/
*/
insidePolygon?: number[][];
/**
@@ -1294,19 +1327,19 @@ declare namespace algoliasearch {
* 'firstWords' When a query does not return any results, the first word will be added as optional
* 'allOptional' When a query does not return any results, a second trial will be made with all words as optional
* 'none' No specific processing is done when a query does not return any results
* https://github.com/algolia/algoliasearch-client-js#removewordsifnoresults
* https://www.algolia.com/doc/api-reference/api-parameters/removeWordsIfNoResults/
*/
removeWordsIfNoResults?: string;
removeWordsIfNoResults?: "none"|"lastWords"|"firstWords"|"allOptional";
/**
* Enables the advanced query syntax
* default: false
* https://github.com/algolia/algoliasearch-client-js#advancedsyntax
* https://www.algolia.com/doc/api-reference/api-parameters/advancedSyntax/
*/
advancedSyntax?: boolean;
/**
* A string that contains the comma separated list of words that should be considered as optional when found in the query
* default: []
* https://github.com/algolia/algoliasearch-client-js#optionalwords
* https://www.algolia.com/doc/api-reference/api-parameters/optionalWords/
*/
optionalWords?: string[];
/**
@@ -1314,13 +1347,13 @@ declare namespace algoliasearch {
* default: false
* true|false: enable or disable stop words for all 41 supported languages; or
* a list of language ISO codes (as a comma-separated string) for which stop words should be enable
* https://github.com/algolia/algoliasearch-client-js#removestopwords
* https://www.algolia.com/doc/api-reference/api-parameters/removeStopWords/
*/
removeStopWords?: string[];
removeStopWords?: boolean|string[];
/**
* List of attributes on which you want to disable the computation of exact criteria
* default: []
* https://github.com/algolia/algoliasearch-client-js#disableexactonattributes
* https://www.algolia.com/doc/api-reference/api-parameters/disableExactOnAttributes/
*/
disableExactOnAttributes?: string[];
/**
@@ -1329,81 +1362,90 @@ declare namespace algoliasearch {
* 'none': no exact on single word query
* 'word': exact set to 1 if the query word is found in the record
* 'attribute': exact set to 1 if there is an attribute containing a string equals to the query
* https://github.com/algolia/algoliasearch-client-js#exactonsinglewordquery
* https://www.algolia.com/doc/api-reference/api-parameters/exactOnSingleWordQuery/
*/
exactOnSingleWordQuery?: string;
exactOnSingleWordQuery?: "attribute"|"none"|"word";
/**
* Specify the list of approximation that should be considered as an exact match in the ranking formula
* default: ['ignorePlurals', 'singleWordSynonym']
* 'ignorePlurals': alternative words added by the ignorePlurals feature
* 'singleWordSynonym': single-word synonym (For example "NY" = "NYC")
* 'multiWordsSynonym': multiple-words synonym
* https://github.com/algolia/algoliasearch-client-js#alternativesasexact
* https://www.algolia.com/doc/api-reference/api-parameters/alternativesAsExact/
*/
alternativesAsExact?: any;
alternativesAsExact?: Array<"ignorePlurals"|"singleWordSynonym"|"multiWordsSynonym">;
/**
* If set to 1, enables the distinct feature, disabled by default, if the attributeForDistinct index setting is set.
* https://github.com/algolia/algoliasearch-client-js#distinct
* https://www.algolia.com/doc/api-reference/api-parameters/distinct/
*/
distinct?: any;
distinct?: number|boolean;
/**
* If set to true, the result hits will contain ranking information in the _rankingInfo attribute.
* default: false
* https://github.com/algolia/algoliasearch-client-js#getrankinginfo
* https://www.algolia.com/doc/api-reference/api-parameters/getRankingInfo/
*/
getRankingInfo?: boolean;
/**
* @deprecated Use `numericAttributesForFiltering` instead
* All numerical attributes are automatically indexed as numerical filters
* default: ''
* https://github.com/algolia/algoliasearch-client-js#numericattributestoindex
* https://www.algolia.com/doc/api-reference/api-parameters/numericAttributesForFiltering/
*/
numericAttributesToIndex?: string[];
/**
* All numerical attributes are automatically indexed as numerical filters
* default: ''
* https://www.algolia.com/doc/api-reference/api-parameters/numericAttributesForFiltering/
*/
numericAttributesForFiltering?: string[];
/**
* @deprecated please use filters instead
* A string that contains the comma separated list of numeric filters you want to apply.
* https://github.com/algolia/algoliasearch-client-js#numericfilters-deprecated
* https://www.algolia.com/doc/api-reference/api-parameters/numericFilters/
*/
numericFilters?: string[];
/**
* @deprecated
*
* Filter the query by a set of tags.
* https://github.com/algolia/algoliasearch-client-js#tagfilters-deprecated
* Default: []
* https://www.algolia.com/doc/api-reference/api-parameters/tagFilters/
*/
tagFilters?: string;
tagFilters?: string[];
/**
* @deprecated
* Filter the query by a set of facets.
* https://github.com/algolia/algoliasearch-client-js#facetfilters-deprecated
* Default: []
* https://www.algolia.com/doc/api-reference/api-parameters/facetFilters/
*/
facetFilters?: string;
facetFilters?: string[]|string[][];
/**
* If set to false, this query will not be taken into account in the analytics feature.
* default true
* https://github.com/algolia/algoliasearch-client-js#analytics
* https://www.algolia.com/doc/api-reference/api-parameters/analytics/
*/
analytics?: boolean;
/**
* If set, tag your query with the specified identifiers
* default: null
* https://github.com/algolia/algoliasearch-client-js#analyticstags
* default: []
* https://www.algolia.com/doc/api-reference/api-parameters/analyticsTags/
*/
analyticsTags?: string[];
/**
* If set to false, the search will not use the synonyms defined for the targeted index.
* default: true
* https://github.com/algolia/algoliasearch-client-js#synonyms
* https://www.algolia.com/doc/api-reference/api-parameters/synonyms/
*/
synonyms?: boolean;
/**
* If set to false, words matched via synonym expansion will not be replaced by the matched synonym in the highlighted result.
* default: true
* https://github.com/algolia/algoliasearch-client-js#replacesynonymsinhighlight
* https://www.algolia.com/doc/api-reference/api-parameters/replaceSynonymsInHighlight/
*/
replaceSynonymsInHighlight?: boolean;
/**
* Configure the precision of the proximity ranking criterion
* default: 1
* https://github.com/algolia/algoliasearch-client-js#minproximity
* https://www.algolia.com/doc/api-reference/api-parameters/minProximity/
*/
minProximity?: number;
@@ -1421,6 +1463,10 @@ declare namespace algoliasearch {
* The query for the search in this facet
*/
facetQuery: string;
/**
* The maximum number of facets to fetch
*/
maxFacetHits?: number;
}
interface Response {
@@ -1452,7 +1498,7 @@ declare namespace algoliasearch {
interface Task {
taskID: number;
createdAt: string;
objectID?: string;
objectID?: string;
}
interface TaskStatus {
@@ -1641,7 +1687,7 @@ declare namespace algoliasearch {
* a list of language ISO codes (as a comma-separated string) for which stop words should be enable
* https://github.com/algolia/algoliasearch-client-js#removestopwords
*/
removeStopWords?: string[];
removeStopWords?: boolean | string[];
/**
* List of attributes on which you want to apply word-splitting ("decompounding") for
* each of the languages supported (German, Dutch, and Finnish as of 05/2018)
@@ -1735,47 +1781,65 @@ declare namespace algoliasearch {
interface Response {
/**
* Contains all the hits matching the query
* https://github.com/algolia/algoliasearch-client-js#response-format
* https://www.algolia.com/doc/api-reference/api-methods/search/?language=javascript#response
*/
hits: any[];
/**
* Current page
* https://github.com/algolia/algoliasearch-client-js#response-format
* https://www.algolia.com/doc/api-reference/api-methods/search/?language=javascript#response
*/
page: number;
/**
* Number of total hits matching the query
* https://github.com/algolia/algoliasearch-client-js#response-format
* https://www.algolia.com/doc/api-reference/api-methods/search/?language=javascript#response
*/
nbHits: number;
/**
* Number of pages
* https://github.com/algolia/algoliasearch-client-js#response-format
* https://www.algolia.com/doc/api-reference/api-methods/search/?language=javascript#response
*/
nbPages: number;
/**
* Number of hits per pages
* https://github.com/algolia/algoliasearch-client-js#response-format
* https://www.algolia.com/doc/api-reference/api-methods/search/?language=javascript#response
*/
hitsPerPage: number;
/**
* Engine processing time (excluding network transfer)
* https://github.com/algolia/algoliasearch-client-js#response-format
* https://www.algolia.com/doc/api-reference/api-methods/search/?language=javascript#response
*/
processingTimeMS: number;
/**
* Query used to perform the search
* https://github.com/algolia/algoliasearch-client-js#response-format
* https://www.algolia.com/doc/api-reference/api-methods/search/?language=javascript#response
*/
query: string;
/**
* GET parameters used to perform the search
* https://github.com/algolia/algoliasearch-client-js#response-format
* https://www.algolia.com/doc/api-reference/api-methods/search/?language=javascript#response
*/
params: string;
facets?: {
[facetName: string]: { [facetValue: string]: number };
};
facets_stats?: {
[facetName: string]: {
avg: number,
max: number,
min: number,
sum: number,
};
};
/**
* The index name is only set when searching multiple indices.
* https://www.algolia.com/doc/api-reference/api-methods/multiple-queries/?language=javascript#response
*/
index?: string;
/**
* The cursor is only set when browsing the index.
* https://www.algolia.com/doc/api-reference/api-methods/browse/
*/
cursor?: string;
}
interface MultiResponse {
+119 -75
View File
@@ -1,11 +1,15 @@
// Type definitions for algoliasearch-client-js 3.27.0
// Type definitions for algoliasearch-client-js 3.30.0
// Project: https://github.com/algolia/algoliasearch-client-js
// Definitions by: Baptiste Coquelle <https://github.com/cbaptiste>
// Haroen Viaene <https://github.com/haroenv>
// Aurélien Hervé <https://github.com/aherve>
// Samuel Vaillant <https://github.com/samouss>
// Claas Brüggemann <https://github.com/ClaasBrueggemann>
// Kai Eichinger <https://github.com/keichinger>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.2
// TypeScript Version: 2.8
type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>
declare namespace algoliasearch {
/**
@@ -129,6 +133,11 @@ declare namespace algoliasearch {
options: SearchForFacetValues.Parameters,
cb: (err: Error, res: SearchForFacetValues.Response) => void
): void;
/**
* Browse an index
* https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
*/
browse(query: string, parameters: BrowseParameters, cb: (err: Error, res: BrowseResponse) => void): void;
/**
* Browse an index
* https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
@@ -138,7 +147,7 @@ declare namespace algoliasearch {
* Browse an index
* https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
*/
browse(query: string): Promise<BrowseResponse>;
browse(query: string, parameters?: BrowseParameters): Promise<BrowseResponse>;
/**
* Browse an index from a cursor
* https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
@@ -193,114 +202,122 @@ declare namespace algoliasearch {
query: string;
processingTimeMS: number;
}
type BrowseParameters = Omit<
QueryParameters,
| "typoTolerance"
| "distinct"
| "facets"
| "getRankingInfo"
| "attributesToHighlight"
| "attributesToSnippet"
>
interface QueryParameters {
/**
* Query string used to perform the search
* default: ''
* https://github.com/algolia/algoliasearch-client-js#query
* https://www.algolia.com/doc/api-reference/api-parameters/query/
*/
query?: string;
/**
* Filter the query with numeric, facet or/and tag filters
* default: ""
* https://github.com/algolia/algoliasearch-client-js#filters
* https://www.algolia.com/doc/api-reference/api-parameters/filters/
*/
filters?: string;
/**
* A string that contains the list of attributes you want to retrieve in order to minimize the size of the JSON answer.
* default: *
* https://github.com/algolia/algoliasearch-client-js#attributestoretrieve
* https://www.algolia.com/doc/api-reference/api-parameters/attributesToRetrieve/
*/
attributesToRetrieve?: string[];
/**
* List of attributes you want to use for textual search
* default: attributeToIndex
* https://github.com/algolia/algoliasearch-client-js#restrictsearchableattributes
* https://www.algolia.com/doc/api-reference/api-parameters/restrictSearchableAttributes/
*/
restrictSearchableAttributes?: string[];
/**
* You can use facets to retrieve only a part of your attributes declared in attributesForFaceting attributes
* default: ""
* https://github.com/algolia/algoliasearch-client-js#facets
* default: []
* https://www.algolia.com/doc/api-reference/api-parameters/facets/
*/
facets?: string;
facets?: string[];
/**
* Limit the number of facet values returned for each facet.
* default: ""
* https://github.com/algolia/algoliasearch-client-js#maxvaluesperfacet
* default: 100
* https://www.algolia.com/doc/api-reference/api-parameters/maxValuesPerFacet/
*/
maxValuesPerFacet?: number;
/**
* Default list of attributes to highlight. If set to null, all indexed attributes are highlighted.
* default: null
* https://github.com/algolia/algoliasearch-client-js#attributestohighlight
* https://www.algolia.com/doc/api-reference/api-parameters/attributesToHighlight/
*/
attributesToHighlight?: string[];
/**
* Default list of attributes to snippet alongside the number of words to return
* default: null
* https://github.com/algolia/algoliasearch-client-js#attributestosnippet
* https://www.algolia.com/doc/api-reference/api-parameters/attributesToSnippet/
*/
attributesToSnippet?: string[];
/**
* Specify the string that is inserted before the highlighted parts in the query result
* default: <em>
* https://github.com/algolia/algoliasearch-client-js#highlightpretag
* https://www.algolia.com/doc/api-reference/api-parameters/highlightPreTag/
*/
highlightPreTag?: string;
/**
* Specify the string that is inserted after the highlighted parts in the query result
* default: </em>
* https://github.com/algolia/algoliasearch-client-js#highlightposttag
* https://www.algolia.com/doc/api-reference/api-parameters/highlightPostTag/
*/
highlightPostTag?: string;
/**
* String used as an ellipsis indicator when a snippet is truncated.
* default: …
* https://github.com/algolia/algoliasearch-client-js#snippetellipsistext
* https://www.algolia.com/doc/api-reference/api-parameters/snippetEllipsisText/
*/
snippetEllipsisText?: string;
/**
* If set to true, restrict arrays in highlights and snippets to items that matched the query at least partially else return all array items in highlights and snippets
* default: false
* https://github.com/algolia/algoliasearch-client-js#restricthighlightandsnippetarrays
* https://www.algolia.com/doc/api-reference/api-parameters/restrictHighlightAndSnippetArrays/
*/
restrictHighlightAndSnippetArrays?: boolean;
/**
* Pagination parameter used to select the number of hits per page
* default: 20
* https://github.com/algolia/algoliasearch-client-js#hitsperpage
* https://www.algolia.com/doc/api-reference/api-parameters/hitsPerPage/
*/
hitsPerPage?: number;
/**
* Pagination parameter used to select the page to retrieve.
* default: 0
* https://github.com/algolia/algoliasearch-client-js#page
* https://www.algolia.com/doc/api-reference/api-parameters/page/
*/
page?: number;
/**
* Offset of the first hit to return
* default: null
* https://github.com/algolia/algoliasearch-client-js#offset
* https://www.algolia.com/doc/api-reference/api-parameters/offset/
*/
offset?: number;
/**
* Number of hits to return.
* default: null
* https://github.com/algolia/algoliasearch-client-js#length
* https://www.algolia.com/doc/api-reference/api-parameters/length/
*/
length?: number;
/**
* The minimum number of characters needed to accept one typo.
* default: 4
* https://github.com/algolia/algoliasearch-client-js#minwordsizefor1typo
* https://www.algolia.com/doc/api-reference/api-parameters/minWordSizefor1Typo/
*/
minWordSizefor1Typo?: number;
/**
* The minimum number of characters needed to accept two typo.
* fault: 8
* https://github.com/algolia/algoliasearch-client-js#minwordsizefor2typos
* https://www.algolia.com/doc/api-reference/api-parameters/minWordSizefor2Typos/
*/
minWordSizefor2Typos?: number;
/**
@@ -310,62 +327,62 @@ declare namespace algoliasearch {
* 'false' The typo tolerance is disabled. All results with typos will be hidden.
* 'min' Only keep results with the minimum number of typos
* 'strict' Hits matching with 2 typos are not retrieved if there are some matching without typos.
* https://github.com/algolia/algoliasearch-client-js#minwordsizefor2typos
* https://www.algolia.com/doc/api-reference/api-parameters/typoTolerance/
*/
typoTolerance?: boolean;
/**
* If set to false, disables typo tolerance on numeric tokens (numbers).
* default:
* https://github.com/algolia/algoliasearch-client-js#allowtyposonnumerictokens
* https://www.algolia.com/doc/api-reference/api-parameters/allowTyposOnNumericTokens/
*/
allowTyposOnNumericTokens?: boolean;
/**
* If set to true, plural won't be considered as a typo
* default: false
* https://github.com/algolia/algoliasearch-client-js#ignoreplurals
* https://www.algolia.com/doc/api-reference/api-parameters/ignorePlurals/
*/
ignorePlurals?: boolean;
/**
* List of attributes on which you want to disable typo tolerance
* default: ""
* https://github.com/algolia/algoliasearch-client-js#disabletypotoleranceonattributes
* default: []
* https://www.algolia.com/doc/api-reference/api-parameters/disableTypoToleranceOnAttributes/
*/
disableTypoToleranceOnAttributes?: string;
disableTypoToleranceOnAttributes?: string[];
/**
* Search for entries around a given location
* default: ""
* https://github.com/algolia/algoliasearch-client-js#aroundlatlng
* https://www.algolia.com/doc/api-reference/api-parameters/aroundLatLng/
*/
aroundLatLng?: string;
/**
* Search for entries around a given latitude/longitude automatically computed from user IP address.
* default: ""
* https://github.com/algolia/algoliasearch-client-js#aroundlatlngviaip
* https://www.algolia.com/doc/api-reference/api-parameters/aroundLatLngViaIP/
*/
aroundLatLngViaIP?: string;
/**
* Control the radius associated with a geo search. Defined in meters.
* default: null
* You can specify aroundRadius=all if you want to compute the geo distance without filtering in a geo area
* https://github.com/algolia/algoliasearch-client-js#aroundradius
* https://www.algolia.com/doc/api-reference/api-parameters/aroundRadius/
*/
aroundRadius?: number | 'all';
/**
* Control the precision of a geo search
* default: null
* https://github.com/algolia/algoliasearch-client-js#aroundprecision
* https://www.algolia.com/doc/api-reference/api-parameters/aroundPrecision/
*/
aroundPrecision?: number;
/**
* Define the minimum radius used for a geo search when aroundRadius is not set.
* default: null
* https://github.com/algolia/algoliasearch-client-js#minimumaroundradius
* https://www.algolia.com/doc/api-reference/api-parameters/minimumAroundRadius/
*/
minimumAroundRadius?: number;
/**
* Search entries inside a given area defined by the two extreme points of a rectangle
* default: null
* https://github.com/algolia/algoliasearch-client-js#insideboundingbox
* https://www.algolia.com/doc/api-reference/api-parameters/insideBoundingBox/
*/
insideBoundingBox?: number[][];
/**
@@ -374,13 +391,13 @@ declare namespace algoliasearch {
* 'prefixAll' All query words are interpreted as prefixes. This option is not recommended.
* 'prefixLast' Only the last word is interpreted as a prefix (default behavior).
* 'prefixNone' No query word is interpreted as a prefix. This option is not recommended.
* https://github.com/algolia/algoliasearch-client-js#querytype
* https://www.algolia.com/doc/api-reference/api-parameters/queryType/
*/
queryType?: any;
queryType?: "prefixAll"|"prefixLast"|"prefixNone";
/**
* Search entries inside a given area defined by a set of points
* defauly: ''
* https://github.com/algolia/algoliasearch-client-js#insidepolygon
* https://www.algolia.com/doc/api-reference/api-parameters/insidePolygon/
*/
insidePolygon?: number[][];
/**
@@ -390,19 +407,19 @@ declare namespace algoliasearch {
* 'firstWords' When a query does not return any results, the first word will be added as optional
* 'allOptional' When a query does not return any results, a second trial will be made with all words as optional
* 'none' No specific processing is done when a query does not return any results
* https://github.com/algolia/algoliasearch-client-js#removewordsifnoresults
* https://www.algolia.com/doc/api-reference/api-parameters/removeWordsIfNoResults/
*/
removeWordsIfNoResults?: string;
removeWordsIfNoResults?: "none"|"lastWords"|"firstWords"|"allOptional";
/**
* Enables the advanced query syntax
* default: false
* https://github.com/algolia/algoliasearch-client-js#advancedsyntax
* https://www.algolia.com/doc/api-reference/api-parameters/advancedSyntax/
*/
advancedSyntax?: boolean;
/**
* A string that contains the comma separated list of words that should be considered as optional when found in the query
* default: []
* https://github.com/algolia/algoliasearch-client-js#optionalwords
* https://www.algolia.com/doc/api-reference/api-parameters/optionalWords/
*/
optionalWords?: string[];
/**
@@ -410,13 +427,13 @@ declare namespace algoliasearch {
* default: false
* true|false: enable or disable stop words for all 41 supported languages; or
* a list of language ISO codes (as a comma-separated string) for which stop words should be enable
* https://github.com/algolia/algoliasearch-client-js#removestopwords
* https://www.algolia.com/doc/api-reference/api-parameters/removeStopWords/
*/
removeStopWords?: string[];
removeStopWords?: boolean|string[];
/**
* List of attributes on which you want to disable the computation of exact criteria
* default: []
* https://github.com/algolia/algoliasearch-client-js#disableexactonattributes
* https://www.algolia.com/doc/api-reference/api-parameters/disableExactOnAttributes/
*/
disableExactOnAttributes?: string[];
/**
@@ -425,81 +442,90 @@ declare namespace algoliasearch {
* 'none': no exact on single word query
* 'word': exact set to 1 if the query word is found in the record
* 'attribute': exact set to 1 if there is an attribute containing a string equals to the query
* https://github.com/algolia/algoliasearch-client-js#exactonsinglewordquery
* https://www.algolia.com/doc/api-reference/api-parameters/exactOnSingleWordQuery/
*/
exactOnSingleWordQuery?: string;
exactOnSingleWordQuery?: "attribute"|"none"|"word";
/**
* Specify the list of approximation that should be considered as an exact match in the ranking formula
* default: ['ignorePlurals', 'singleWordSynonym']
* 'ignorePlurals': alternative words added by the ignorePlurals feature
* 'singleWordSynonym': single-word synonym (For example "NY" = "NYC")
* 'multiWordsSynonym': multiple-words synonym
* https://github.com/algolia/algoliasearch-client-js#alternativesasexact
* https://www.algolia.com/doc/api-reference/api-parameters/alternativesAsExact/
*/
alternativesAsExact?: any;
alternativesAsExact?: Array<"ignorePlurals"|"singleWordSynonym"|"multiWordsSynonym">;
/**
* If set to 1, enables the distinct feature, disabled by default, if the attributeForDistinct index setting is set.
* https://github.com/algolia/algoliasearch-client-js#distinct
* https://www.algolia.com/doc/api-reference/api-parameters/distinct/
*/
distinct?: any;
distinct?: number|boolean;
/**
* If set to true, the result hits will contain ranking information in the _rankingInfo attribute.
* default: false
* https://github.com/algolia/algoliasearch-client-js#getrankinginfo
* https://www.algolia.com/doc/api-reference/api-parameters/getRankingInfo/
*/
getRankingInfo?: boolean;
/**
* @deprecated Use `numericAttributesForFiltering` instead
* All numerical attributes are automatically indexed as numerical filters
* default: ''
* https://github.com/algolia/algoliasearch-client-js#numericattributestoindex
* https://www.algolia.com/doc/api-reference/api-parameters/numericAttributesForFiltering/
*/
numericAttributesToIndex?: string[];
/**
* All numerical attributes are automatically indexed as numerical filters
* default: ''
* https://www.algolia.com/doc/api-reference/api-parameters/numericAttributesForFiltering/
*/
numericAttributesForFiltering?: string[];
/**
* @deprecated please use filters instead
* A string that contains the comma separated list of numeric filters you want to apply.
* https://github.com/algolia/algoliasearch-client-js#numericfilters-deprecated
* https://www.algolia.com/doc/api-reference/api-parameters/numericFilters/
*/
numericFilters?: string[];
/**
* @deprecated
*
* Filter the query by a set of tags.
* https://github.com/algolia/algoliasearch-client-js#tagfilters-deprecated
* Default: []
* https://www.algolia.com/doc/api-reference/api-parameters/tagFilters/
*/
tagFilters?: string;
tagFilters?: string[];
/**
* @deprecated
* Filter the query by a set of facets.
* https://github.com/algolia/algoliasearch-client-js#facetfilters-deprecated
* Default: []
* https://www.algolia.com/doc/api-reference/api-parameters/facetFilters/
*/
facetFilters?: string;
facetFilters?: string[]|string[][];
/**
* If set to false, this query will not be taken into account in the analytics feature.
* default true
* https://github.com/algolia/algoliasearch-client-js#analytics
* https://www.algolia.com/doc/api-reference/api-parameters/analytics/
*/
analytics?: boolean;
/**
* If set, tag your query with the specified identifiers
* default: null
* https://github.com/algolia/algoliasearch-client-js#analyticstags
* default: []
* https://www.algolia.com/doc/api-reference/api-parameters/analyticsTags/
*/
analyticsTags?: string[];
/**
* If set to false, the search will not use the synonyms defined for the targeted index.
* default: true
* https://github.com/algolia/algoliasearch-client-js#synonyms
* https://www.algolia.com/doc/api-reference/api-parameters/synonyms/
*/
synonyms?: boolean;
/**
* If set to false, words matched via synonym expansion will not be replaced by the matched synonym in the highlighted result.
* default: true
* https://github.com/algolia/algoliasearch-client-js#replacesynonymsinhighlight
* https://www.algolia.com/doc/api-reference/api-parameters/replaceSynonymsInHighlight/
*/
replaceSynonymsInHighlight?: boolean;
/**
* Configure the precision of the proximity ranking criterion
* default: 1
* https://github.com/algolia/algoliasearch-client-js#minproximity
* https://www.algolia.com/doc/api-reference/api-parameters/minProximity/
*/
minProximity?: number;
@@ -529,47 +555,65 @@ declare namespace algoliasearch {
interface Response {
/**
* Contains all the hits matching the query
* https://github.com/algolia/algoliasearch-client-js#response-format
* https://www.algolia.com/doc/api-reference/api-methods/search/?language=javascript#response
*/
hits: any[];
/**
* Current page
* https://github.com/algolia/algoliasearch-client-js#response-format
* https://www.algolia.com/doc/api-reference/api-methods/search/?language=javascript#response
*/
page: number;
/**
* Number of total hits matching the query
* https://github.com/algolia/algoliasearch-client-js#response-format
* https://www.algolia.com/doc/api-reference/api-methods/search/?language=javascript#response
*/
nbHits: number;
/**
* Number of pages
* https://github.com/algolia/algoliasearch-client-js#response-format
* https://www.algolia.com/doc/api-reference/api-methods/search/?language=javascript#response
*/
nbPages: number;
/**
* Number of hits per pages
* https://github.com/algolia/algoliasearch-client-js#response-format
* https://www.algolia.com/doc/api-reference/api-methods/search/?language=javascript#response
*/
hitsPerPage: number;
/**
* Engine processing time (excluding network transfer)
* https://github.com/algolia/algoliasearch-client-js#response-format
* https://www.algolia.com/doc/api-reference/api-methods/search/?language=javascript#response
*/
processingTimeMS: number;
/**
* Query used to perform the search
* https://github.com/algolia/algoliasearch-client-js#response-format
* https://www.algolia.com/doc/api-reference/api-methods/search/?language=javascript#response
*/
query: string;
/**
* GET parameters used to perform the search
* https://github.com/algolia/algoliasearch-client-js#response-format
* https://www.algolia.com/doc/api-reference/api-methods/search/?language=javascript#response
*/
params: string;
facets?: {
[facetName: string]: { [facetValue: string]: number };
};
facets_stats?: {
[facetName: string]: {
avg: number,
max: number,
min: number,
sum: number,
};
};
/**
* The index name is only set when searching multiple indices.
* https://www.algolia.com/doc/api-reference/api-methods/multiple-queries/?language=javascript#response
*/
index?: string;
/**
* The cursor is only set when browsing the index.
* https://www.algolia.com/doc/api-reference/api-methods/browse/
*/
cursor?: string;
}
interface MultiResponse {
File diff suppressed because it is too large Load Diff
+3265
View File
File diff suppressed because it is too large Load Diff
+28
View File
@@ -0,0 +1,28 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"esnext",
"dom"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true,
"esModuleInterop": true
},
"files": [
"index.d.ts",
"ali-app-tests.ts"
],
"exclude": [
".prettierrc"
]
}
+7
View File
@@ -0,0 +1,7 @@
{
"extends": "dtslint/dt.json",
"rules": {
"no-mergeable-namespace": false,
"no-unnecessary-generics": false
}
}
+25
View File
@@ -0,0 +1,25 @@
import * as OSS from 'ali-oss';
const ossOptions: OSS.Options = {
accessKeyId: 'your access key',
accessKeySecret: 'your access secret',
bucket: 'your bucket name',
region: 'oss-cn-hangzhou'
};
const client = new OSS(ossOptions);
const clusterOptions: OSS.ClusterOptions = {
clusters: [],
};
const clusterClient = new OSS.Cluster(clusterOptions);
const imageOptions: OSS.ImageClientOptions = {
imageHost: 'xxxx',
accessKeyId: 'xxxx',
accessKeySecret: 'xxxx',
bucket: 'xxxx'
};
const imageClient = new OSS.ImageClient(imageOptions);
+876
View File
@@ -0,0 +1,876 @@
// Type definitions for ali-oss 6.0
// Project: https://github.com/ali-sdk/ali-oss
// Definitions by: Ptrdu <https://github.com/ptrdu>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
export = OSS;
// basic OSS
declare namespace OSS {
interface Options {
accessKeyId: string; // access secret you create
accessKeySecret: string; // access secret you create
stsToken?: string; // used by temporary authorization
bucket?: string; // the default bucket you want to access If you don't have any bucket, please use putBucket() create one first.
endpoint?: string; // oss region domain. It takes priority over region.
region?: string; // the bucket data region location, please see Data Regions, default is oss-cn-hangzhou.
internal?: boolean; // access OSS with aliyun internal network or not, default is false. If your servers are running on aliyun too, you can set true to save lot of money.
secure?: boolean; // instruct OSS client to use HTTPS (secure: true) or HTTP (secure: false) protocol.
timeout?: string | number; // instance level timeout for all operations, default is 60s
cname?: boolean; // use custom domain name
}
interface Bucket {
name: string;
region: string;
creationDate: string;
StorageClass: StorageType;
}
type StorageType = "Standard" | "IA" | "Archive";
type ACLType = "public-read-write" | "public-read" | "private";
type HTTPMethods = "GET" | "POST" | "DELETE" | "PUT";
interface RequestOptions {
// the operation timeout
timeout?: number;
}
type RuleStatusType = "Enabled" | "Disabled";
interface LifecycleRule {
id?: string; // rule id, if not set, OSS will auto create it with random string.
prefix: string; // store prefix
status: RuleStatusType; // rule status, allow values: Enabled or Disabled
days?: number | string; // expire after the days
date: string; // expire date, e.g.: 2022-10-11T00:00:00.000Z date and days only set one.
}
interface CORSRule {
allowedOrigin: string | string[]; // configure for Access-Control-Allow-Origin header
allowedMethod: string | string[]; // configure for Access-Control-Allow-Methods header
allowedHeader?: string | string[]; // configure for Access-Control-Allow-Headers header
exposeHeader?: string | string[]; // configure for Access-Control-Expose-Headers header
maxAgeSeconds?: string | string[]; // configure for Access-Control-Max-Age header
}
interface OwnerType {
id: string;
displayName: string;
}
interface ObjectMeta {
name: string; // object name on oss
lastModified: string; // object last modified GMT date, e.g.: 2015-02-19T08:39:44.000Z
etag: string; // object etag contains ", e.g.: "5B3C1A2E053D763E1B002CC607C5A0FE"
type: string; // object type, e.g.: Normal
size: number; // object size, e.g.: 344606
storageClass: StorageType;
owner: OwnerType;
}
interface NormalSuccessResponse {
// response status
status: number;
// response headers
headers: object; // todo the object in detail
// response size
size: number;
// request total use time (ms)
rt: number;
}
interface UserMeta {
uid: number;
pid: number;
}
interface ObjectCallback {
url: string; // After a file is uploaded successfully, the OSS sends a callback request to this URL.
host?: string; // The host header value for initiating callback requests.
body: string; // The value of the request body when a callback is initiated, for example, key=$(key)&etag=$(etag)&my_var=$(x:my_var).
contentType?: string; // The Content-Type of the callback requests initiatiated, It supports application/x-www-form-urlencoded and application/json, and the former is the default value.
customValue?: object;
headers?: object; // extra headers, detail see RFC 2616
}
interface ModifyData {
lastModified: string; // object last modified GMT string
etag: string; // object etag contains ", e.g.: "5B3C1A2E053D763E1B002CC607C5A0FE"
}
interface Checkpoint {
file: any; // The file object selected by the user, if the browser is restarted, it needs the user to manually trigger the settings
name: string; // object key
fileSize: number;
partSize: number;
uploadId: string;
doneParts: Array<{ number: number, etag: string }>;
}
interface ObjectPart {
PartNumber: number;
LastModified: any; // {Date} Time when a part is uploaded.
ETag: string;
size: number;
}
interface Upload {
name: string;
uploadId: string;
initiated: any;
}
interface Channel {
Name: string;
Description: string;
Status: string;
LastModified: string;
PublishUrls: string[];
PlayUrls: string[];
}
interface ChannelHistory {
StartTime: string; //
EndTime: string;
RemoteAddr: string; // the remote addr
}
// parameters type
interface ListBucketsQueryType {
prefix?: string; // search buckets using prefix key
marker?: string; // search start from marker, including marker key
'max-keys'?: string | number; // max buckets, default is 100, limit to 1000
}
interface PutBucketOptions {
timeout: number;
storageClass: StorageType;
}
interface PutBucketWebsiteConfig {
index: string; // default page, e.g.: index.html
error?: string; // error page, e.g.: 'error.html'
}
interface ListObjectsQuery {
prefix?: string; // search object using prefix key
marker?: string; // search start from marker, including marker key
delimiter?: string; // delimiter search scope e.g. / only search current dir, not including subdir
'max-keys': string | number; // max objects, default is 100, limit to 1000
}
interface ListObjectResult {
objects: ObjectMeta[];
prefixes: string[];
isTruncated: boolean;
nextMarker: string;
res: NormalSuccessResponse;
}
interface PutObjectOptions {
timeout?: number; // the operation timeout
mime?: string; // custom mime, will send with Content-Type entity header
meta?: UserMeta; // user meta, will send with x-oss-meta- prefix string e.g.: { uid: 123, pid: 110 }
callback: ObjectCallback;
headers?: object;
}
interface PutObjectResult {
name: string;
data: object;
res: NormalSuccessResponse;
}
interface PutStreamOptions {
contentLength?: number; // the stream length, chunked encoding will be used if absent
timeout: number; // the operation timeout
mime: string; // custom mime, will send with Content-Type entity header
meta: UserMeta;
callback: ObjectCallback;
headers?: object;
}
interface AppendObjectOptions {
position?: string; // specify the position which is the content length of the latest object
timeout?: number; // the operation timeout
mime?: string; // custom mime, will send with Content-Type entity header
meta?: UserMeta;
headers?: object;
}
interface AppendObjectResult {
name: string;
url: string; // the url of oss
res: NormalSuccessResponse;
nextAppendPosition: string; // the next position
}
interface HeadObjectOptions {
timeout?: number;
headers?: object;
}
interface HeadObjectResult {
status: number; // response status, maybe 200 or 304
meta: UserMeta;
res: NormalSuccessResponse;
}
interface GetObjectOptions {
timeout?: number;
process?: string; // image process params, will send with x-oss-process e.g.: {process: 'image/resize,w_200'}
headers?: object;
}
interface GetObjectResult {
content?: any; // file content buffer if file parameter is null or ignore
res: NormalSuccessResponse;
}
interface GetStreamOptions {
timeout?: number;
process?: string; // image process params, will send with x-oss-process e.g.: {process: 'image/resize,w_200'}
headers?: object;
}
interface GetStreamResult {
stream?: any; // readable stream instance if response status is not 200, stream will be null.
res: NormalSuccessResponse;
}
interface CopyObjectOptions {
timeout?: number;
meta?: UserMeta;
headers?: object;
}
interface CopyAndPutMetaResult {
data: ModifyData;
res: NormalSuccessResponse;
}
interface DeleteMultiOptions {
quite?: boolean; // quite mode or verbose mode, default is false
timeout?: number;
}
interface DeleteMultiResult {
deleted?: string[]; // deleted object names list
res: NormalSuccessResponse;
}
interface ResponseHeaderType {
'content-type'?: string;
'content-disposition'?: string;
'cache-control'?: string;
}
interface SignatureUrlOptions {
expires?: number; // after expires seconds, the url will become invalid, default is 1800
method?: HTTPMethods; // the HTTP method, default is 'GET'
'Content-Type'?: string; // set the request content type
process?: string;
response?: ResponseHeaderType; // set the response headers for download
callback?: ObjectCallback;
}
interface GetACLResult {
acl: ACLType;
res: NormalSuccessResponse;
}
interface InitMultipartUploadOptions {
timeout?: number;
mime?: string; // Mime file type
meta?: UserMeta;
headers?: object;
}
interface InitMultipartUploadResult {
res: { status: number, headers: object, size: number, rt: number };
bucket: string; // bucket name
name: string; // object name store on OSS
uploadId: string; // upload id, use for uploadPart, completeMultipart
}
interface UploadPartResult {
name: string;
etag: string;
res: NormalSuccessResponse;
}
interface CompleteMultipartUploadOptions {
timeout?: number;
callback?: ObjectCallback;
headers?: object;
}
interface CompleteMultipartUploadResult {
bucket: string;
name: string;
etag: string;
data: object;
res: NormalSuccessResponse;
}
interface MultipartUploadOptions {
parallel?: number; // the number of parts to be uploaded in parallel
partSize?: number; // the suggested size for each part
progress?: (...args: any[]) => any; // the progress callback called after each successful upload of one part
checkpoint?: Checkpoint; // the checkpoint to resume upload, if this is provided, it will continue the upload from where interrupted, otherwise a new multipart upload will be created.
meta?: UserMeta;
mime?: string;
callback?: ObjectCallback;
headers?: object;
timeout?: number;
copyheaders?: object; // {Object} only uploadPartCopy api used, detail
}
interface MultipartUploadResult {
bucket: string;
name: string;
etag: string;
data: object;
res: NormalSuccessResponse;
}
interface MultipartUploadCopyResult {
bucket: string;
name: string;
etag: string;
res: NormalSuccessResponse;
}
interface MultipartUploadCopySourceData {
sourceKey: string; // the source object name
sourceBucketName: string; // sourceData. the source bucket name
startOffset: number; // data copy start byte offset, e.g: 0
endOffset: number; // data copy end byte offset, e.g: 102400
}
interface ListPartsQuery {
'max-parts': number; // The maximum part number in the response of the OSS. default value: 1000.
'part-number-marker': number; // Starting position of a specific list. A part is listed only when the part number is greater than the value of this parameter.
'encoding-type': string; // Specify the encoding of the returned content and the encoding type. Optional value: url
}
interface ListPartsResult {
uploadId: string;
bucket: string;
name: string;
PartNumberMarker: number;
nextPartNumberMarker: number;
maxParts: number;
isTruncated: boolean;
parts: ObjectPart[];
res: NormalSuccessResponse;
}
interface ListUploadsQuery {
prefix?: string;
'max-uploads'?: number;
'key-marker'?: string;
'upload-id-marker'?: string;
}
interface ListUploadsResult {
res: NormalSuccessResponse;
bucket: string;
nextKeyMarker: any;
nextUploadIdMarker: any;
isTruncated: boolean;
uploads: Upload[];
}
interface PutChannelConf {
Description?: string;
Status?: string;
Target?: {
Type: string,
FragDuration: number,
FragCount: number,
PlaylistName: string
};
}
interface PutChannelResult {
publishUrls: string[];
playUrls: string[];
res: NormalSuccessResponse;
}
interface GetChannelResult {
Status: string;
ConnectedTime?: string;
RemoteAddr?: string;
Video?: object;
Audio?: object;
res: NormalSuccessResponse;
}
interface ListChannelsQuery {
prefix: string; // the channel id prefix (returns channels with this prefix)
marker: string; // the channel id marker (returns channels after this id)
'max-keys ': number; // max number of channels to return
}
interface ListChannelsResult {
channels: Channel[];
nextMarker: string | null;
isTruncated: boolean;
res: NormalSuccessResponse;
}
interface ChannelHistoryResult {
records: ChannelHistory;
res: NormalSuccessResponse;
}
interface GetRtmpUrlOptions {
expires?: number; // the expire time in seconds of the url
params?: object; // the additional parameters for url, e.g.: {playlistName: 'play.m3u8'}
timeout?: number; // the operation timeout
}
}
/// cluster
declare namespace OSS {
interface ClusterType {
host: string;
accessKeyId: string;
accessKeySecret: string;
}
interface ClusterOptions {
clusters: ClusterType[];
schedule?: string;
}
class Cluster {
constructor(options: ClusterOptions)
list(query: ListObjectsQuery | null, options: RequestOptions): Promise<ListObjectResult>;
put(name: string, file: any, options?: PutObjectOptions): Promise<PutObjectResult>;
putStream(name: string, stream: any, options?: PutStreamOptions): Promise<{ name: string, res: NormalSuccessResponse }>;
head(name: string, options?: HeadObjectOptions): Promise<HeadObjectResult>;
get(name: string, file?: any, options?: GetObjectOptions): Promise<GetObjectResult>;
getStream(name?: string, options?: GetStreamOptions): Promise<GetStreamResult>;
delete(name: string, options?: RequestOptions): Promise<NormalSuccessResponse>;
copy(name: string, sourceName: string, options?: CopyObjectOptions): Promise<CopyAndPutMetaResult>;
putMeta(name: string, meta: UserMeta, options: RequestOptions): Promise<CopyAndPutMetaResult>;
deleteMulti(names: string[], options?: DeleteMultiOptions): Promise<DeleteMultiResult>;
signatureUrl(name: string, options?: SignatureUrlOptions): string;
putACL(name: string, acl: ACLType, options?: RequestOptions): Promise<NormalSuccessResponse>;
restore(name: string, options?: RequestOptions): Promise<NormalSuccessResponse>;
}
}
// image
declare namespace OSS {
interface ImageClientOptions {
imageHost: string; // your image service domain that binding to a OSS bucket
accessKeyId: string; // access key you create on aliyun console website
accessKeySecret: string; // access secret you create
bucket: string; // the default bucket you want to access If you don't have any bucket, please use putBucket() create one first.
region?: string; // the bucket data region location, please see Data Regions, default is oss-cn-hangzhou
internal?: boolean; // access OSS with aliyun internal network or not, default is false If your servers are running on aliyun too, you can set true to save lot of money.
timeout?: string | number; // instance level timeout for all operations, default is 60s
}
interface ImageGetOptions {
timeout?: number;
headers?: object;
}
interface StyleData {
Name: string; // style name
Content: string; // style content
CreateTime: string; // style create time
LastModifyTime: string; // style last modify time
}
class ImageClient {
constructor(options: ImageClientOptions)
/**
* Get an image from the image channel.
*/
get(name: string, file?: any, options?: ImageGetOptions): Promise<{ content: any, res: NormalSuccessResponse }>;
/**
* Get an image read stream.
*/
getStream(name: string, options?: ImageGetOptions): Promise<{ stream: any, res: NormalSuccessResponse }>;
/**
* Get a image exif info by image object name from the image channel.
*/
getExif(name: string, options?: RequestOptions): Promise<{ data: object, res: NormalSuccessResponse }>;
/**
* Get a image info and exif info by image object name from the image channel.
*/
getInfo(name: string, options?: RequestOptions): Promise<{ data: object, res: NormalSuccessResponse }>;
/**
* todo
*/
putStyle(name: string, style: string, options?: RequestOptions): Promise<{ data: object, res: NormalSuccessResponse }>;
/**
* Get a style by name from the image channel.
*/
getStyle(name: string, options?: RequestOptions): Promise<{ data: StyleData, res: NormalSuccessResponse}>;
/**
* Get all styles from the image channel.
*/
listStyle(options?: RequestOptions): Promise<StyleData[]>;
/**
* todo
*/
deleteStyle(styleName: string, options?: RequestOptions): Promise<NormalSuccessResponse>;
/**
* Create a signature url for directly download.
*/
signatureUrl(name: string, options?: { expires?: string, timeout?: string }): string;
}
}
declare class OSS {
constructor(options: OSS.Options)
/******************************************* the bucket operations *************************************************/
// base operators
/**
* List buckets in this account.
*/
listBuckets(query: OSS.ListBucketsQueryType | null, options?: OSS.RequestOptions): Promise<OSS.Bucket[]>;
/**
* Create a new bucket.
*/
putBucket(name: string, options?: OSS.PutBucketOptions): Promise<{ bucket: string, res: OSS.NormalSuccessResponse }>;
/**
* Use the bucket.
*/
useBucket(name: string): void;
/**
* Delete an empty bucket.
*/
deleteBucket(name: string, options?: OSS.RequestOptions): Promise<OSS.NormalSuccessResponse>;
/**
* Get bucket information,include CreationDate、ExtranetEndpoint、IntranetEndpoint、Location、Name、StorageClass、 Owner、AccessControlList
*/
getBucketInfo(name: string): Promise<any>;
/**
* Get bucket location
*/
getBucketLocation(name: string): Promise<any>;
// ACL operations
/**
* Update the bucket ACL.
*/
putBucketACL(name: string, acl: OSS.ACLType, options?: OSS.RequestOptions): Promise<OSS.NormalSuccessResponse>;
/**
* Get the bucket ACL.
* acl - acl settings string
*/
getBucketACL(name: string, options?: OSS.RequestOptions): Promise<{ acl: string, res: OSS.NormalSuccessResponse }>;
// logging operations
/**
* Update the bucket logging settings. Log file will create every one hour and name format: <prefix><bucket>-YYYY-mm-DD-HH-MM-SS-UniqueString.
*/
putBucketLogging(name: string, prefix?: string, options?: OSS.RequestOptions): Promise<OSS.NormalSuccessResponse>;
/**
* Get the bucket logging settings.
*/
getBucketLogging(name: string, options?: OSS.RequestOptions): Promise<{ enable: boolean, prefix: string | null, res: OSS.NormalSuccessResponse }>;
/**
* Delete the bucket logging settings.
*/
deleteBucketLogging(name: string, options?: OSS.RequestOptions): Promise<OSS.NormalSuccessResponse>;
// Website operations
/**
* Set the bucket as a static website.
*/
putBucketWebsite(name: string, config: OSS.PutBucketWebsiteConfig): Promise<OSS.NormalSuccessResponse>;
/**
* Get the bucket website config.
*/
getBucketWebsite(name: string, options?: OSS.RequestOptions): Promise<{ index: string, error: string, res: OSS.NormalSuccessResponse }>;
/**
* Delete the bucket website config.
*/
deleteBucketWebsite(name: string, options?: OSS.RequestOptions): Promise<OSS.NormalSuccessResponse>;
// referer operations
/**
* Set the bucket request Referer white list.
*/
putBucketReferer(name: string, allowEmpty: boolean, referers: string[], options?: OSS.RequestOptions): Promise<OSS.NormalSuccessResponse>;
/**
* Get the bucket request Referer white list.
*/
getBucketReferer(name: string, options?: OSS.RequestOptions): Promise<{ allowEmpty: boolean, referers: string[], res: OSS.NormalSuccessResponse }>;
/**
* Delete the bucket request Referer white list.
*/
deleteBucketReferer(name: string, options?: OSS.RequestOptions): Promise<OSS.NormalSuccessResponse>;
// lifecycle operations
/**
* Set the bucket object lifecycle.
*/
putBucketLifecycle(name: string, rules: OSS.LifecycleRule[], options?: OSS.RequestOptions): Promise<OSS.NormalSuccessResponse>;
/**
* Get the bucket object lifecycle.
*/
getBucketLifecycle(name: string, options?: OSS.RequestOptions): Promise<{ rules: OSS.LifecycleRule[], res: OSS.NormalSuccessResponse }>;
/**
* Delete the bucket object lifecycle.
*/
deleteBucketLifecycle(name: string, options?: OSS.RequestOptions): Promise<OSS.NormalSuccessResponse>;
// CORS operations
/**
* Set CORS rules of the bucket object
*/
putBucketCORS(name: string, rules: OSS.CORSRule[], options?: OSS.RequestOptions): Promise<OSS.NormalSuccessResponse>;
/**
* Get CORS rules of the bucket object.
*/
getBucketCORS(name: string): Promise<{ rules: OSS.CORSRule[], res: OSS.NormalSuccessResponse }>;
/**
* Delete CORS rules of the bucket object.
*/
deleteBucketCORS(name: string): Promise<OSS.NormalSuccessResponse>;
/********************************************************** Object operations ********************************************/
/**
* List objects in the bucket.
*/
list(query: OSS.ListObjectsQuery | null, options: OSS.RequestOptions): Promise<OSS.ListObjectResult>;
/**
* Add an object to the bucket.
*/
put(name: string, file: any, options?: OSS.PutObjectOptions): Promise<OSS.PutObjectResult>;
/**
* Add a stream object to the bucket.
*/
putStream(name: string, stream: any, options?: OSS.PutStreamOptions): Promise<{ name: string, res: OSS.NormalSuccessResponse }>;
/**
* Append an object to the bucket, it's almost same as put, but it can add content to existing object rather than override it.
*/
append(name: string, file: any, options?: OSS.AppendObjectOptions): Promise<OSS.AppendObjectResult>;
/**
* Get the Object url. If provide baseUrl, will use baseUrl instead the default endpoint.
*/
getObjectUrl(name: string, baseUrl?: string): string;
/**
* Get the Object url. If provide baseUrl, will use baseUrl instead the default bucket and endpoint. Suggest use generateObjectUrl instead of getObjectUrl.
*/
generateObjectUrl(name: string, baseUrl?: string): string;
/**
* Head an object and get the meta info.
*/
head(name: string, options?: OSS.HeadObjectOptions): Promise<OSS.HeadObjectResult>;
/**
* Get an object from the bucket.
*/
get(name: string, file?: any, options?: OSS.GetObjectOptions): Promise<OSS.GetObjectResult>;
/**
* Get an object read stream.
*/
getStream(name?: string, options?: OSS.GetStreamOptions): Promise<OSS.GetStreamResult>;
/**
* Delete an object from the bucket.
*/
delete(name: string, options?: OSS.RequestOptions): Promise<OSS.NormalSuccessResponse>;
/**
* Copy an object from sourceName to name.
*/
copy(name: string, sourceName: string, options?: OSS.CopyObjectOptions): Promise<OSS.CopyAndPutMetaResult>;
/**
* Set an exists object meta.
*/
putMeta(name: string, meta: OSS.UserMeta, options: OSS.RequestOptions): Promise<OSS.CopyAndPutMetaResult>;
/**
* Delete multi objects in one request.
*/
deleteMulti(names: string[], options?: OSS.DeleteMultiOptions): Promise<OSS.DeleteMultiResult>;
/**
* Create a signature url for download or upload object. When you put object with signatureUrl ,you need to pass Content-Type.Please look at the example.
*/
signatureUrl(name: string, options?: OSS.SignatureUrlOptions): string;
/**
* Set object's ACL.
*/
putACL(name: string, acl: OSS.ACLType, options?: OSS.RequestOptions): Promise<OSS.NormalSuccessResponse>;
/**
* Get object's ACL.
*/
getACL(name: string, options?: OSS.RequestOptions): Promise<OSS.GetACLResult>;
/**
* Restore Object.
*/
restore(name: string, options?: OSS.RequestOptions): Promise<OSS.NormalSuccessResponse>;
/**
* multi upload
*/
initMultipartUpload(name: string, options?: OSS.InitMultipartUploadOptions): Promise<OSS.InitMultipartUploadResult>;
/**
* After initiating a Multipart Upload event, you can upload data in parts based on the specified object name and Upload ID.
*/
uploadPart(name: string, uploadId: string, partNo: number, file: any, start: number, end: number, options?: OSS.RequestOptions): Promise<OSS.UploadPartResult>;
/**
* Using Upload Part Copy, you can copy data from an existing object and upload a part of the data.
* When copying a file larger than 1 GB, you must use the Upload Part Copy method. If you want to copy a file smaller than 1 GB, see Copy Object.
*/
uploadPartCopy(
name: string,
uploadId: string,
partNo: number,
range: string,
sourceData: { sourceKey: string, sourceBucketName: string },
options: { timeout?: number, headers?: object }
): Promise<OSS.UploadPartResult>;
/**
* After uploading all data parts, you must call the Complete Multipart Upload API to complete Multipart Upload for the entire file.
*/
completeMultipartUpload(
name: string,
uploadId: string,
parts: Array<{ number: number, etag: string }>,
options?: OSS.CompleteMultipartUploadOptions
): Promise<OSS.CompleteMultipartUploadResult>;
/**
* Upload file with OSS multipart.
*/
multipartUpload(name: string, file: any, options: OSS.MultipartUploadOptions): Promise<OSS.MultipartUploadResult>;
/**
* Copy file with OSS multipart.
* this function contains head, initMultipartUpload, uploadPartCopy, completeMultipartUpload.
* When copying a file larger than 1 GB, you should use the Upload Part Copy method. If you want to copy a file smaller than 1 GB, see Copy Object.
*/
multipartUploadCopy(name: string, sourceData: OSS.MultipartUploadCopySourceData, options?: OSS.MultipartUploadOptions): Promise<OSS.MultipartUploadCopyResult>;
/**
* The ListParts command can be used to list all successfully uploaded parts mapped to a specific upload ID, i.e.: those not completed and not aborted.
*/
listParts(name: string, uploadId: string, query?: OSS.ListPartsQuery, options?: OSS.RequestOptions): Promise<OSS.ListPartsResult>;
/**
* List on-going multipart uploads, i.e.: those not completed and not aborted.
*/
listUploads(query: OSS.ListUploadsQuery, options?: OSS.RequestOptions): Promise<OSS.ListUploadsResult>;
/**
* Abort a multipart upload for object.
*/
abortMultipartUpload(name: string, uploadId: string, options?: OSS.RequestOptions): Promise<OSS.NormalSuccessResponse>;
/************************************************ RTMP Operations *************************************************************/
/**
* Create a live channel.
*/
putChannel(id: string, conf: OSS.PutChannelConf, options?: OSS.RequestOptions): Promise<OSS.PutChannelResult>;
/**
* Get live channel info.
*/
getChannel(id: string, options?: OSS.RequestOptions): Promise<{ data: OSS.PutChannelConf, res: OSS.NormalSuccessResponse }>;
/**
* Delete a live channel.
*/
deleteChannel(id: string, options?: OSS.RequestOptions): Promise<OSS.NormalSuccessResponse>;
/**
* Change the live channel status.
*/
putChannelStatus(id: string, status?: string, options?: OSS.RequestOptions): Promise<OSS.NormalSuccessResponse>;
/**
* Get the live channel status.
*/
getChannelStatus(id: string, options?: OSS.RequestOptions): Promise<OSS.GetChannelResult>;
/**
* List channels.
*/
listChannels(query: OSS.ListChannelsQuery, options?: OSS.RequestOptions): Promise<OSS.ListChannelsResult>;
/**
* Get the live channel history.
*/
getChannelHistory(id: string, options?: OSS.RequestOptions): Promise<OSS.ChannelHistoryResult>;
/**
* Create a VOD playlist for the channel.
*/
createVod(id: string, name: string, time: { startTime: number, endTime: number }, options?: OSS.RequestOptions): Promise<OSS.NormalSuccessResponse>;
/**
* Get signatured rtmp url for publishing.
*/
getRtmpUrl(channelId?: string, options?: OSS.GetRtmpUrlOptions): string;
}
+23
View File
@@ -0,0 +1,23 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"ali-oss-tests.ts"
]
}
+6
View File
@@ -0,0 +1,6 @@
{
"extends": "dtslint/dt.json",
"rules": {
"no-mergeable-namespace": false
}
}
+5
View File
@@ -0,0 +1,5 @@
import allKeys = require('all-keys');
allKeys(Symbol.prototype); // $ExpectType Set<string>
allKeys(Symbol.prototype, { includeObjectPrototype: false }); // $ExpectType Set<string>
allKeys(Symbol.prototype, { includeSymbols: false }); // $ExpectType Set<string>
+29
View File
@@ -0,0 +1,29 @@
// Type definitions for all-keys 2.0
// Project: https://github.com/sindresorhus/all-keys#readme
// Definitions by: BendingBender <https://github.com/BendingBender>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.2
export = allKeys;
/**
* Get all property keys of an object including non-enumerable and inherited ones.
* Like [Reflect.ownKeys()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/ownKeys)
* but traverses up the prototype-chain.
*/
declare function allKeys(obj: object, options?: allKeys.Options): Set<string>;
declare namespace allKeys {
interface Options {
/**
* Include `Object.prototype` properties like `isPrototypeOf`.
* @default true
*/
includeObjectPrototype?: boolean;
/**
* Include [Symbol](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol) keys.
* @default true
*/
includeSymbols?: boolean;
}
}
+23
View File
@@ -0,0 +1,23 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"all-keys-tests.ts"
]
}
@@ -0,0 +1,4 @@
import allPropertyNames = require('all-property-names');
// $ExpectType Set<string>
allPropertyNames(Symbol.prototype);
+9
View File
@@ -0,0 +1,9 @@
// Type definitions for all-property-names 1.0
// Project: https://github.com/sindresorhus/all-property-names#readme
// Definitions by: BendingBender <https://github.com/BendingBender>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.2
export = allPropertyNames;
declare function allPropertyNames(input: object): Set<string>;
+23
View File
@@ -0,0 +1,23 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"all-property-names-tests.ts"
]
}
+7
View File
@@ -0,0 +1,7 @@
import * as almostEqual from 'almost-equal';
const res1 = almostEqual(1.999999, 2.0);
const res2 = almostEqual(1.999999, 2.0, almostEqual.DBL_EPSILON);
const res3 = almostEqual(1.999999, 2.0, almostEqual.FLT_EPSILON, almostEqual.FLT_EPSILON);
+11
View File
@@ -0,0 +1,11 @@
// Type definitions for almost-equal 1.1
// Project: https://github.com/mikolalysenko/almost-equal#readme
// Definitions by: Curtis Maddalozzo <https://github.com/cmaddalozzo>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
declare function almostEqual(value: number, other: number, absoluteTolerance?: number, relativeTolerance?: number): boolean;
declare namespace almostEqual {
const FLT_EPSILON: number;
const DBL_EPSILON: number;
}
export = almostEqual;
+23
View File
@@ -0,0 +1,23 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"strictFunctionTypes": true,
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"almost-equal-tests.ts"
]
}
+4 -4
View File
@@ -2,7 +2,7 @@
// Project: https://github.com/goatslacker/alt
// Definitions by: Michael Shearer <https://github.com/Shearerbeard>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.6
// TypeScript Version: 2.8
///<reference types="react"/>
@@ -54,12 +54,12 @@ declare namespace AltJS {
export type Source = {[name:string]: () => SourceModel<any>};
export interface SourceModel<S> {
local(state:any, ...args: any[]):any;
local?(state:any, ...args: any[]):any;
remote(state:any, ...args: any[]):Promise<S>;
shouldFetch?(fetchFn:(...args:Array<any>) => boolean):void;
loading?:(args:any) => void;
success?:(state:S) => void;
error?:(args:any) => void;
success:(state:S) => void;
error:(args:any) => void;
interceptResponse?(response:any, action:Action<any>, ...args:Array<any>):any;
}
+1
View File
@@ -17,6 +17,7 @@
"max-line-length": false,
"member-access": false,
"new-parens": false,
"no-angle-bracket-type-assertion": false,
"no-any-union": false,
"no-boolean-literal-compare": false,
"no-conditional-assignment": false,
+22
View File
@@ -0,0 +1,22 @@
const aMap = new AMap.Map('id', {
resizeEnable: true,
animateEnable: true
});
aMap.setCenter(new AMap.LngLat(0, 0));
AMap.plugin(['someplugin'], () => {
console.log('plugin loaded');
});
AMap.convertFrom([116.3, 39.9], 'gps', (status, result) => {
if (result.info === 'ok') {
const _ = result.locations;
}
});
new AMap.Marker({
map: aMap,
title: '',
position: new AMap.LngLat(0, 0),
});
+1392
View File
File diff suppressed because it is too large Load Diff
+24
View File
@@ -0,0 +1,24 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6",
"dom"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"amap-js-sdk-tests.ts"
]
}
+1
View File
@@ -0,0 +1 @@
{ "extends": "dtslint/dt.json" }
+1 -1
View File
@@ -32,7 +32,7 @@ new Stream({
highWaterMark: 1,
decodeStrings: true,
objectMode: true,
destroy: (error?: Error) => {
destroy: (error: Error | null) => {
return 'handle error';
},
final: (callback: (error?: Error) => void) => {
+86 -59
View File
@@ -1,85 +1,112 @@
// Tests for Amplitude SDK TypeScript definitions
import amplitude = require('amplitude-js');
module Amplitude.Tests {
function all() {
amplitude.init('YOUR_API_KEY_HERE', null, {
// optional configuration options
var client: amplitude.AmplitudeClient = new amplitude.AmplitudeClient();
var identify: amplitude.Identify = new amplitude.Identify();
var revenue: amplitude.Revenue = new amplitude.Revenue();
client = amplitude.getInstance();
client = amplitude.getInstance('some name');
amplitude.__VERSION__ === '1.2.3';
amplitude.options.logLevel = 'WARN';
amplitude.init('API_KEY', 'USER_ID', {
saveEvents: true,
includeUtm: true,
includeReferrer: true,
batchEvents: true,
eventUploadThreshold: 50
});
amplitude.init('YOUR_API_KEY_HERE', 'USER_ID_HERE', null, () => {});
}, function () { });
amplitude.init('API_KEY', 'USER_ID', { includeReferrer: true, includeUtm: true });
amplitude.init('API_KEY', 'USER_ID');
amplitude.init('API_KEY');
amplitude.logEvent('EVENT_IDENTIFIER_HERE');
amplitude.setUserId('USER_ID_HERE');
amplitude.init('YOUR_API_KEY_HERE', 'USER_ID_HERE');
amplitude.setUserId(null); // not string 'null'
amplitude.setVersionName('VERSION_NAME_HERE');
amplitude.regenerateDeviceId();
amplitude.setDeviceId('CUSTOM_DEVICE_ID');
amplitude.logEvent('EVENT_IDENTIFIER_HERE', {
'color': 'blue',
'age': 20,
'key': 'value'
});
amplitude.logEvent('Clicked Homepage Button', { 'finished_flow': false, 'clicks': 15 });
amplitude.logEvent('EVENT_IDENTIFIER_HERE', { 'color': 'blue', 'age': 20, 'key': 'value' });
amplitude.logEvent("EVENT_IDENTIFIER_HERE", null, (httpCode, response) => { });
amplitude.logEventWithGroups('initialize_game', { 'key': 'value' }, { 'sport': 'soccer' });
amplitude.setDeviceId('45f0954f-eb79-4463-ac8a-233a6f45a8f0');
amplitude.setDomain('.amplitude.com');
amplitude.setGroup('orgId', '15');
amplitude.setGroup('orgId', ['15', '16']);
amplitude.setUserId('joe@gmail.com');
amplitude.setUserProperties({ 'gender': 'female', 'sign_up_complete': true })
amplitude.setVersionName('1.12.3');
amplitude.isNewSession();
amplitude.getSessionId() === 123;
let identify = new amplitude.Identify().set('gender', 'female').set('age', 20);
amplitude.identify(identify);
amplitude.logRevenue(3.99, 1, 'product_1234');
amplitude.logRevenueV2(revenue);
identify = new amplitude.Identify().setOnce('sign_up_date', '08/24/2015');
amplitude.identify(identify);
identify = new amplitude.Identify().setOnce('sign_up_date', '09/14/2015');
amplitude.identify(identify);
client.init('API_KEY', 'USER_ID', {
saveEvents: true,
includeUtm: true,
includeReferrer: true,
batchEvents: true,
eventUploadThreshold: 50
}, function () { });
client.init('API_KEY', 'USER_ID', { includeReferrer: true, includeUtm: true });
client.init('API_KEY', 'USER_ID');
client.init('API_KEY');
identify = new amplitude.Identify().unset('gender').unset('age');
amplitude.identify(identify);
client.logEvent('Clicked Homepage Button', { 'finished_flow': false, 'clicks': 15 });
client.logEvent('EVENT_IDENTIFIER_HERE', { 'color': 'blue', 'age': 20, 'key': 'value' });
client.logEvent("EVENT_IDENTIFIER_HERE", null, (httpCode, response) => { });
client.logEventWithGroups('initialize_game', { 'key': 'value' }, { 'sport': 'soccer' });
client.logEventWithTimestamp('EVENT_IDENTIFIER_HERE', { 'key': 'value' }, 1505430378000, (httpCode, response) => { });
client.setDeviceId('45f0954f-eb79-4463-ac8a-233a6f45a8f0');
client.setDomain('.amplitude.com');
client.setUserId('joe@gmail.com');
client.setOptOut(true);
client.setGroup('type', 'name');
client.setGroup('type', ['name', 'name2']);
client.setUserProperties({ 'gender': 'female', 'sign_up_complete': true });
client.setGlobalUserProperties({ 'gender': 'female', 'sign_up_complete': true });
client.setVersionName('1.12.3');
client.setSessionId(1505430378000);
client.options.logLevel = 'WARN';
client.getSessionId() === 123;
client.isNewSession() === true;
client.regenerateDeviceId();
client.clearUserProperties();
client.identify(identify);
client.logRevenue(3.99, 1, 'product_1234');
client.logRevenueV2(revenue);
identify = new amplitude.Identify().set('colors', ['rose', 'gold']).add('karma', 1).setOnce('sign_up_date', '2016-03-31');
identify = new amplitude.Identify().add('karma', 1).add('friends', 1);
amplitude.identify(identify);
identify = new amplitude.Identify().append('ab-tests', 'new-user-test').append('some_list', [1, 2, 3, 4, 'values']);
amplitude.identify(identify);
identify = new amplitude.Identify().prepend('ab-tests', 'new-user-test').prepend('some_list', [1, 2, 3, 4, 'values']);
amplitude.identify(identify);
identify = new amplitude.Identify()
.set('karma', 10)
.add('karma', 1)
.unset('karma');
amplitude.identify(identify);
identify = new amplitude.Identify().set('karma', 10).add('karma', 1).unset('karma');
identify = new amplitude.Identify().append('ab-tests', 'new-user-tests');
identify.append('some_list', [1, 2, 3, 4, 'values']);
identify = new amplitude.Identify().prepend('ab-tests', 'new-user-tests');
identify.prepend('some_list', [1, 2, 3, 4, 'values']);
identify = new amplitude.Identify().set('user_type', 'beta');
identify.set('name', { 'first': 'John', 'last': 'Doe' });
identify = new amplitude.Identify().setOnce('sign_up_date', '2016-04-01');
identify = new amplitude.Identify().unset('user_type').unset('age');
identify = new amplitude.Identify()
.set('colors', ['rose', 'gold'])
.append('ab-tests', 'campaign_a')
.append('existing_list', [4, 5]);
amplitude.identify(identify);
amplitude.setUserProperties({
gender: 'female',
age: 20
});
amplitude.clearUserProperties();
amplitude.setOptOut(true);
amplitude.setOptOut(false);
amplitude.setGroup('orgId', '15');
amplitude.setGroup('sport', ['soccer', 'tennis']);
// TODO: Implement those.
/*
var revenue = new amplitude.Revenue().setProductId('com.company.productId').setPrice(3.99).setQuantity(3);
amplitude.logRevenueV2(revenue);
amplitude.logEventWithGroups('initialize_game', { 'key': 'value' }, { 'sport': 'soccer' });
*/
revenue = new amplitude.Revenue().setProductId('productIdentifier').setPrice(10.99);
revenue = new amplitude.Revenue().setProductId('productIdentifier').setPrice(10.99).setEventProperties({ 'city': 'San Francisco' });
revenue = new amplitude.Revenue().setProductId('productIdentifier').setPrice(10.99).setQuantity(5);
revenue = new amplitude.Revenue().setProductId('productIdentifier').setPrice(10.99).setRevenueType('purchase');
}
}

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