From d4254ba49bc07c7b24ecfc2928741e9730cd7117 Mon Sep 17 00:00:00 2001 From: Rob Eisenberg Date: Tue, 3 May 2016 15:06:17 -0400 Subject: [PATCH] chore(all): prepare release 0.8.0 This is a breaking change release. See the forthcoming blog post today. --- aurelia-validation/aurelia-validation.d.ts | 23 + doc/CHANGELOG.md | 8 + doc/api.json | 3580 +++++++++++++++++++- package.json | 2 +- 4 files changed, 3611 insertions(+), 2 deletions(-) create mode 100644 aurelia-validation/aurelia-validation.d.ts diff --git a/aurelia-validation/aurelia-validation.d.ts b/aurelia-validation/aurelia-validation.d.ts new file mode 100644 index 00000000..d73fa5e9 --- /dev/null +++ b/aurelia-validation/aurelia-validation.d.ts @@ -0,0 +1,23 @@ +declare module 'aurelia-validation' { + export const validationMetadataKey: any; + export class ValidationEngine { + static getValidationReporter(instance: any): any; + } + export class ValidationError { + message: any; + object: any; + propertyName: any; + value: any; + } + export class ValidationReporter { + add(object: any): any; + remove(object: any): any; + subscribe(callback: any): any; + publish(errors: any): any; + destroyObserver(observer: any): any; + } + export class Validator { + validate(object: any, prop: any): any; + getProperties(): any; + } +} \ No newline at end of file diff --git a/doc/CHANGELOG.md b/doc/CHANGELOG.md index aa71d4b4..fbdf49d4 100644 --- a/doc/CHANGELOG.md +++ b/doc/CHANGELOG.md @@ -1,3 +1,11 @@ +## 0.8.0 (2016-05-03) + + +#### Bug Fixes + +* **package.json:** fix dependencies ([3415f243](https://github.com/aurelia/validation/commit/3415f243b158682bbcb0b45adaac2838a536fb33)) + + ### 1.0.0-beta.1.0.0 (2016-01-29) diff --git a/doc/api.json b/doc/api.json index 6de3c0a9..f01b0a44 100644 --- a/doc/api.json +++ b/doc/api.json @@ -1 +1,3579 @@ -{"classes":[],"methods":[],"properties":[],"events":[]} \ No newline at end of file +{ + "id": 2, + "name": "\"aurelia-dependency-injection\"", + "kind": 2, + "kindString": "Module", + "flags": {}, + "children": [ + { + "id": 41, + "name": "All", + "kind": 128, + "kindString": "Class", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Used to allow functions/classes to specify resolution of all matches to a key." + }, + "children": [ + { + "id": 42, + "name": "constructor", + "kind": 512, + "kindString": "Constructor", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Creates an instance of the All class." + }, + "signatures": [ + { + "id": 43, + "name": "new All", + "kind": 16384, + "kindString": "Constructor signature", + "flags": {}, + "comment": { + "shortText": "Creates an instance of the All class." + }, + "parameters": [ + { + "id": 44, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "shortText": "The key to lazily resolve all matches for.\n" + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "reference", + "name": "All", + "id": 41, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + }, + { + "id": 45, + "name": "get", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 46, + "name": "get", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Called by the container to resolve all matching dependencies as an array of instances.", + "returns": "Returns an array of all matching instances.\n" + }, + "parameters": [ + { + "id": 47, + "name": "container", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The container to resolve from." + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ], + "type": { + "type": "instrinct", + "isArray": true, + "name": "any" + } + } + ] + }, + { + "id": 48, + "name": "of", + "kind": 2048, + "kindString": "Method", + "flags": { + "isStatic": true, + "isExported": true + }, + "signatures": [ + { + "id": 49, + "name": "of", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Creates an All Resolver for the supplied key.", + "returns": "Returns an instance of All for the key.\n" + }, + "parameters": [ + { + "id": 50, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key to resolve all instances for." + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "reference", + "name": "All", + "id": 41, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + } + ], + "groups": [ + { + "title": "Constructors", + "kind": 512, + "children": [ + 42 + ] + }, + { + "title": "Methods", + "kind": 2048, + "children": [ + 45, + 48 + ] + } + ] + }, + { + "id": 137, + "name": "Container", + "kind": 128, + "kindString": "Class", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "A lightweight, extensible dependency injection container." + }, + "children": [ + { + "id": 141, + "name": "constructor", + "kind": 512, + "kindString": "Constructor", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Creates an instance of Container." + }, + "signatures": [ + { + "id": 142, + "name": "new Container", + "kind": 16384, + "kindString": "Constructor signature", + "flags": {}, + "comment": { + "shortText": "Creates an instance of Container." + }, + "parameters": [ + { + "id": 143, + "name": "configuration", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "comment": { + "shortText": "Provides some configuration for the new Container instance.\n" + }, + "type": { + "type": "reference", + "name": "ContainerConfiguration", + "id": 26, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ], + "type": { + "type": "reference", + "name": "Container", + "id": 137, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + }, + { + "id": 139, + "name": "parent", + "kind": 1024, + "kindString": "Property", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "The parent container in the DI hierarchy." + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137, + "moduleName": "\"aurelia-dependency-injection\"" + } + }, + { + "id": 140, + "name": "root", + "kind": 1024, + "kindString": "Property", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "The root container in the DI hierarchy." + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137, + "moduleName": "\"aurelia-dependency-injection\"" + } + }, + { + "id": 138, + "name": "instance", + "kind": 1024, + "kindString": "Property", + "flags": { + "isStatic": true, + "isExported": true + }, + "comment": { + "shortText": "The global root Container instance. Available if makeGlobal() has been called. Aurelia Framework calls makeGlobal()." + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137, + "moduleName": "\"aurelia-dependency-injection\"" + } + }, + { + "id": 181, + "name": "autoRegister", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 182, + "name": "autoRegister", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Registers a type (constructor function) by inspecting its registration annotations. If none are found, then the default singleton registration is used." + }, + "parameters": [ + { + "id": 183, + "name": "fn", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The constructor function to use when the dependency needs to be instantiated." + }, + "type": { + "type": "instrinct", + "name": "any" + } + }, + { + "id": 184, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "comment": { + "text": "The key that identifies the dependency at resolution time; usually a constructor function.\n" + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "reference", + "name": "Resolver", + "id": 3, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + }, + { + "id": 185, + "name": "autoRegisterAll", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 186, + "name": "autoRegisterAll", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Registers an array of types (constructor functions) by inspecting their registration annotations. If none are found, then the default singleton registration is used." + }, + "parameters": [ + { + "id": 187, + "name": "fns", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The constructor function to use when the dependency needs to be instantiated.\n" + }, + "type": { + "type": "instrinct", + "isArray": true, + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "name": "void" + } + } + ] + }, + { + "id": 201, + "name": "createChild", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 202, + "name": "createChild", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Creates a new dependency injection container whose parent is the current container.", + "returns": "Returns a new container instance parented to this.\n" + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + }, + { + "id": 195, + "name": "get", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 196, + "name": "get", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Resolves a single instance based on the provided key.", + "returns": "Returns the resolved instance.\n" + }, + "parameters": [ + { + "id": 197, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key that identifies the object to resolve." + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + }, + { + "id": 198, + "name": "getAll", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 199, + "name": "getAll", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Resolves all instance registered under the provided key.", + "returns": "Returns an array of the resolved instances.\n" + }, + "parameters": [ + { + "id": 200, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key that identifies the objects to resolve." + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "isArray": true, + "name": "any" + } + } + ] + }, + { + "id": 191, + "name": "hasResolver", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 192, + "name": "hasResolver", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Inspects the container to determine if a particular key has been registred.", + "returns": "Returns true if the key has been registred; false otherwise.\n" + }, + "parameters": [ + { + "id": 193, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key that identifies the dependency at resolution time; usually a constructor function." + }, + "type": { + "type": "instrinct", + "name": "any" + } + }, + { + "id": 194, + "name": "checkParent", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "comment": { + "text": "Indicates whether or not to check the parent container hierarchy." + }, + "type": { + "type": "instrinct", + "name": "boolean" + } + } + ], + "type": { + "type": "instrinct", + "name": "boolean" + } + } + ] + }, + { + "id": 203, + "name": "invoke", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 204, + "name": "invoke", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Invokes a function, recursively resolving its dependencies.", + "returns": "Returns the instance resulting from calling the function.\n" + }, + "parameters": [ + { + "id": 205, + "name": "fn", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The function to invoke with the auto-resolved dependencies." + }, + "type": { + "type": "reference", + "name": "Function" + } + }, + { + "id": 206, + "name": "dynamicDependencies", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "comment": { + "text": "Additional function dependencies to use during invocation." + }, + "type": { + "type": "instrinct", + "isArray": true, + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + }, + { + "id": 144, + "name": "makeGlobal", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 145, + "name": "makeGlobal", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Makes this container instance globally reachable through Container.instance." + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + }, + { + "id": 173, + "name": "registerAlias", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 174, + "name": "registerAlias", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Registers an additional key that serves as an alias to the original DI key." + }, + "parameters": [ + { + "id": 175, + "name": "originalKey", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key that originally identified the dependency; usually a constructor function." + }, + "type": { + "type": "instrinct", + "name": "any" + } + }, + { + "id": 176, + "name": "aliasKey", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "An alternate key which can also be used to resolve the same dependency as the original.\n" + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "name": "void" + } + } + ] + }, + { + "id": 164, + "name": "registerHandler", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 165, + "name": "registerHandler", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Registers a custom resolution function such that the container calls this function for each request to obtain the instance." + }, + "parameters": [ + { + "id": 166, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key that identifies the dependency at resolution time; usually a constructor function." + }, + "type": { + "type": "instrinct", + "name": "any" + } + }, + { + "id": 167, + "name": "handler", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The resolution function to use when the dependency is needed.\n" + }, + "type": { + "type": "reflection", + "declaration": { + "id": 168, + "name": "__type", + "kind": 65536, + "kindString": "Type literal", + "flags": {}, + "signatures": [ + { + "id": 169, + "name": "__call", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "parameters": [ + { + "id": 170, + "name": "container", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137 + } + }, + { + "id": 171, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "type": { + "type": "instrinct", + "name": "any" + } + }, + { + "id": 172, + "name": "resolver", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "type": { + "type": "reference", + "name": "Resolver", + "id": 3 + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + } + } + } + ], + "type": { + "type": "instrinct", + "name": "void" + } + } + ] + }, + { + "id": 152, + "name": "registerInstance", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 153, + "name": "registerInstance", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Registers an existing object instance with the container." + }, + "parameters": [ + { + "id": 154, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key that identifies the dependency at resolution time; usually a constructor function." + }, + "type": { + "type": "instrinct", + "name": "any" + } + }, + { + "id": 155, + "name": "instance", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "comment": { + "text": "The instance that will be resolved when the key is matched.\n" + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "name": "void" + } + } + ] + }, + { + "id": 177, + "name": "registerResolver", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 178, + "name": "registerResolver", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Registers a custom resolution function such that the container calls this function for each request to obtain the instance." + }, + "parameters": [ + { + "id": 179, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key that identifies the dependency at resolution time; usually a constructor function." + }, + "type": { + "type": "instrinct", + "name": "any" + } + }, + { + "id": 180, + "name": "resolver", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The resolver to use when the dependency is needed.\n" + }, + "type": { + "type": "reference", + "name": "Resolver", + "id": 3, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ], + "type": { + "type": "instrinct", + "name": "void" + } + } + ] + }, + { + "id": 156, + "name": "registerSingleton", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 157, + "name": "registerSingleton", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Registers a type (constructor function) such that the container always returns the same instance for each request." + }, + "parameters": [ + { + "id": 158, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key that identifies the dependency at resolution time; usually a constructor function." + }, + "type": { + "type": "instrinct", + "name": "any" + } + }, + { + "id": 159, + "name": "fn", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "type": { + "type": "reference", + "name": "Function" + } + } + ], + "type": { + "type": "instrinct", + "name": "void" + } + } + ] + }, + { + "id": 160, + "name": "registerTransient", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 161, + "name": "registerTransient", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Registers a type (constructor function) such that the container returns a new instance for each request." + }, + "parameters": [ + { + "id": 162, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key that identifies the dependency at resolution time; usually a constructor function." + }, + "type": { + "type": "instrinct", + "name": "any" + } + }, + { + "id": 163, + "name": "fn", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "type": { + "type": "reference", + "name": "Function" + } + } + ], + "type": { + "type": "instrinct", + "name": "void" + } + } + ] + }, + { + "id": 146, + "name": "setHandlerCreatedCallback", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 147, + "name": "setHandlerCreatedCallback", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Sets an invocation handler creation callback that will be called when new InvocationsHandlers are created (called once per Function)." + }, + "parameters": [ + { + "id": 148, + "name": "onHandlerCreated", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The callback to be called when an InvocationsHandler is created.\n" + }, + "type": { + "type": "reflection", + "declaration": { + "id": 149, + "name": "__type", + "kind": 65536, + "kindString": "Type literal", + "flags": {}, + "signatures": [ + { + "id": 150, + "name": "__call", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "parameters": [ + { + "id": 151, + "name": "handler", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "type": { + "type": "reference", + "name": "InvocationHandler", + "id": 124 + } + } + ], + "type": { + "type": "reference", + "name": "InvocationHandler", + "id": 124 + } + } + ] + } + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + }, + { + "id": 188, + "name": "unregister", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 189, + "name": "unregister", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Unregisters based on key." + }, + "parameters": [ + { + "id": 190, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key that identifies the dependency at resolution time; usually a constructor function.\n" + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "name": "void" + } + } + ] + } + ], + "groups": [ + { + "title": "Constructors", + "kind": 512, + "children": [ + 141 + ] + }, + { + "title": "Properties", + "kind": 1024, + "children": [ + 139, + 140, + 138 + ] + }, + { + "title": "Methods", + "kind": 2048, + "children": [ + 181, + 185, + 201, + 195, + 198, + 191, + 203, + 144, + 173, + 164, + 152, + 177, + 156, + 160, + 146, + 188 + ] + } + ] + }, + { + "id": 82, + "name": "Factory", + "kind": 128, + "kindString": "Class", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Used to allow injecting dependencies but also passing data to the constructor." + }, + "children": [ + { + "id": 83, + "name": "constructor", + "kind": 512, + "kindString": "Constructor", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Creates an instance of the Factory class." + }, + "signatures": [ + { + "id": 84, + "name": "new Factory", + "kind": 16384, + "kindString": "Constructor signature", + "flags": {}, + "comment": { + "shortText": "Creates an instance of the Factory class." + }, + "parameters": [ + { + "id": 85, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "shortText": "The key to resolve from the parent container.\n" + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "reference", + "name": "Factory", + "id": 82, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + }, + { + "id": 86, + "name": "get", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 87, + "name": "get", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Called by the container to pass the dependencies to the constructor.", + "returns": "Returns a function that can be invoked to resolve dependencies later, and the rest of the parameters.\n" + }, + "parameters": [ + { + "id": 88, + "name": "container", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The container to invoke the constructor with dependencies and other parameters." + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + }, + { + "id": 89, + "name": "of", + "kind": 2048, + "kindString": "Method", + "flags": { + "isStatic": true, + "isExported": true + }, + "signatures": [ + { + "id": 90, + "name": "of", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Creates a Factory Resolver for the supplied key.", + "returns": "Returns an instance of Factory for the key.\n" + }, + "parameters": [ + { + "id": 91, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key to resolve." + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "reference", + "name": "Factory", + "id": 82, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + } + ], + "groups": [ + { + "title": "Constructors", + "kind": 512, + "children": [ + 83 + ] + }, + { + "title": "Methods", + "kind": 2048, + "children": [ + 86, + 89 + ] + } + ] + }, + { + "id": 92, + "name": "FactoryInvoker", + "kind": 128, + "kindString": "Class", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "An Invoker that is used to invoke a factory method." + }, + "children": [ + { + "id": 93, + "name": "instance", + "kind": 1024, + "kindString": "Property", + "flags": { + "isStatic": true, + "isExported": true + }, + "comment": { + "shortText": "The singleton instance of the FactoryInvoker." + }, + "type": { + "type": "reference", + "name": "FactoryInvoker", + "id": 92, + "moduleName": "\"aurelia-dependency-injection\"" + } + }, + { + "id": 94, + "name": "invoke", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 95, + "name": "invoke", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Invokes the function with the provided dependencies.", + "returns": "The result of the function invocation.\n" + }, + "parameters": [ + { + "id": 96, + "name": "container", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The calling container." + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137, + "moduleName": "\"aurelia-dependency-injection\"" + } + }, + { + "id": 97, + "name": "fn", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The constructor or factory function." + }, + "type": { + "type": "reference", + "name": "Function" + } + }, + { + "id": 98, + "name": "dependencies", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The dependencies of the function call." + }, + "type": { + "type": "instrinct", + "isArray": true, + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + }, + { + "id": 99, + "name": "invokeWithDynamicDependencies", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 100, + "name": "invokeWithDynamicDependencies", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Invokes the function with the provided dependencies.", + "returns": "The result of the function invocation.\n" + }, + "parameters": [ + { + "id": 101, + "name": "container", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The calling container." + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137, + "moduleName": "\"aurelia-dependency-injection\"" + } + }, + { + "id": 102, + "name": "fn", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The constructor or factory function." + }, + "type": { + "type": "reference", + "name": "Function" + } + }, + { + "id": 103, + "name": "staticDependencies", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The static dependencies of the function." + }, + "type": { + "type": "instrinct", + "isArray": true, + "name": "any" + } + }, + { + "id": 104, + "name": "dynamicDependencies", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "Additional dependencies to use during invocation." + }, + "type": { + "type": "instrinct", + "isArray": true, + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + } + ], + "groups": [ + { + "title": "Properties", + "kind": 1024, + "children": [ + 93 + ] + }, + { + "title": "Methods", + "kind": 2048, + "children": [ + 94, + 99 + ] + } + ] + }, + { + "id": 124, + "name": "InvocationHandler", + "kind": 128, + "kindString": "Class", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Stores the information needed to invoke a function." + }, + "children": [ + { + "id": 128, + "name": "constructor", + "kind": 512, + "kindString": "Constructor", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Instantiates an InvocationDescription." + }, + "signatures": [ + { + "id": 129, + "name": "new InvocationHandler", + "kind": 16384, + "kindString": "Constructor signature", + "flags": {}, + "comment": { + "shortText": "Instantiates an InvocationDescription." + }, + "parameters": [ + { + "id": 130, + "name": "fn", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "shortText": "The Function described by this description object." + }, + "type": { + "type": "reference", + "name": "Function" + } + }, + { + "id": 131, + "name": "invoker", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "shortText": "The strategy for invoking the function." + }, + "type": { + "type": "reference", + "name": "Invoker", + "id": 8, + "moduleName": "\"aurelia-dependency-injection\"" + } + }, + { + "id": 132, + "name": "dependencies", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "shortText": "The static dependencies of the function call.\n" + }, + "type": { + "type": "instrinct", + "isArray": true, + "name": "any" + } + } + ], + "type": { + "type": "reference", + "name": "InvocationHandler", + "id": 124, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + }, + { + "id": 127, + "name": "dependencies", + "kind": 1024, + "kindString": "Property", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "The statically known dependencies of this function invocation." + }, + "type": { + "type": "instrinct", + "isArray": true, + "name": "any" + } + }, + { + "id": 125, + "name": "fn", + "kind": 1024, + "kindString": "Property", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "The function to be invoked by this handler." + }, + "type": { + "type": "reference", + "name": "Function" + } + }, + { + "id": 126, + "name": "invoker", + "kind": 1024, + "kindString": "Property", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "The invoker implementation that will be used to actually invoke the function." + }, + "type": { + "type": "reference", + "name": "Invoker", + "id": 8, + "moduleName": "\"aurelia-dependency-injection\"" + } + }, + { + "id": 133, + "name": "invoke", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 134, + "name": "invoke", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Invokes the function.", + "returns": "The result of the function invocation.\n" + }, + "parameters": [ + { + "id": 135, + "name": "container", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The calling container." + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137, + "moduleName": "\"aurelia-dependency-injection\"" + } + }, + { + "id": 136, + "name": "dynamicDependencies", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "comment": { + "text": "Additional dependencies to use during invocation." + }, + "type": { + "type": "instrinct", + "isArray": true, + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + } + ], + "groups": [ + { + "title": "Constructors", + "kind": 512, + "children": [ + 128 + ] + }, + { + "title": "Properties", + "kind": 1024, + "children": [ + 127, + 125, + 126 + ] + }, + { + "title": "Methods", + "kind": 2048, + "children": [ + 133 + ] + } + ] + }, + { + "id": 31, + "name": "Lazy", + "kind": 128, + "kindString": "Class", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Used to allow functions/classes to specify lazy resolution logic." + }, + "children": [ + { + "id": 32, + "name": "constructor", + "kind": 512, + "kindString": "Constructor", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Creates an instance of the Lazy class." + }, + "signatures": [ + { + "id": 33, + "name": "new Lazy", + "kind": 16384, + "kindString": "Constructor signature", + "flags": {}, + "comment": { + "shortText": "Creates an instance of the Lazy class." + }, + "parameters": [ + { + "id": 34, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "shortText": "The key to lazily resolve.\n" + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "reference", + "name": "Lazy", + "id": 31, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + }, + { + "id": 35, + "name": "get", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 36, + "name": "get", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Called by the container to lazily resolve the dependency into a lazy locator function.", + "returns": "Returns a function which can be invoked at a later time to obtain the actual dependency.\n" + }, + "parameters": [ + { + "id": 37, + "name": "container", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The container to resolve from." + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + }, + { + "id": 38, + "name": "of", + "kind": 2048, + "kindString": "Method", + "flags": { + "isStatic": true, + "isExported": true + }, + "signatures": [ + { + "id": 39, + "name": "of", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Creates a Lazy Resolver for the supplied key.", + "returns": "Returns an instance of Lazy for the key.\n" + }, + "parameters": [ + { + "id": 40, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key to lazily resolve." + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "reference", + "name": "Lazy", + "id": 31, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + } + ], + "groups": [ + { + "title": "Constructors", + "kind": 512, + "children": [ + 32 + ] + }, + { + "title": "Methods", + "kind": 2048, + "children": [ + 35, + 38 + ] + } + ] + }, + { + "id": 51, + "name": "Optional", + "kind": 128, + "kindString": "Class", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Used to allow functions/classes to specify an optional dependency, which will be resolved only if already registred with the container." + }, + "children": [ + { + "id": 52, + "name": "constructor", + "kind": 512, + "kindString": "Constructor", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Creates an instance of the Optional class." + }, + "signatures": [ + { + "id": 53, + "name": "new Optional", + "kind": 16384, + "kindString": "Constructor signature", + "flags": {}, + "comment": { + "shortText": "Creates an instance of the Optional class." + }, + "parameters": [ + { + "id": 54, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "shortText": "The key to optionally resolve for." + }, + "type": { + "type": "instrinct", + "name": "any" + } + }, + { + "id": 55, + "name": "checkParent", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "comment": { + "shortText": "Indicates whether or not the parent container hierarchy should be checked.\n" + }, + "type": { + "type": "instrinct", + "name": "boolean" + } + } + ], + "type": { + "type": "reference", + "name": "Optional", + "id": 51, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + }, + { + "id": 56, + "name": "get", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 57, + "name": "get", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Called by the container to provide optional resolution of the key.", + "returns": "Returns the instance if found; otherwise null.\n" + }, + "parameters": [ + { + "id": 58, + "name": "container", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The container to resolve from." + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + }, + { + "id": 59, + "name": "of", + "kind": 2048, + "kindString": "Method", + "flags": { + "isStatic": true, + "isExported": true + }, + "signatures": [ + { + "id": 60, + "name": "of", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Creates an Optional Resolver for the supplied key.", + "returns": "Returns an instance of Optional for the key.\n" + }, + "parameters": [ + { + "id": 61, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key to optionally resolve for." + }, + "type": { + "type": "instrinct", + "name": "any" + } + }, + { + "id": 62, + "name": "checkParent", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "type": { + "type": "instrinct", + "name": "boolean" + } + } + ], + "type": { + "type": "reference", + "name": "Optional", + "id": 51, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + } + ], + "groups": [ + { + "title": "Constructors", + "kind": 512, + "children": [ + 52 + ] + }, + { + "title": "Methods", + "kind": 2048, + "children": [ + 56, + 59 + ] + } + ] + }, + { + "id": 63, + "name": "Parent", + "kind": 128, + "kindString": "Class", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Used to inject the dependency from the parent container instead of the current one." + }, + "children": [ + { + "id": 64, + "name": "constructor", + "kind": 512, + "kindString": "Constructor", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Creates an instance of the Parent class." + }, + "signatures": [ + { + "id": 65, + "name": "new Parent", + "kind": 16384, + "kindString": "Constructor signature", + "flags": {}, + "comment": { + "shortText": "Creates an instance of the Parent class." + }, + "parameters": [ + { + "id": 66, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "shortText": "The key to resolve from the parent container.\n" + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "reference", + "name": "Parent", + "id": 63, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + }, + { + "id": 67, + "name": "get", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 68, + "name": "get", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Called by the container to load the dependency from the parent container", + "returns": "Returns the matching instance from the parent container\n" + }, + "parameters": [ + { + "id": 69, + "name": "container", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The container to resolve the parent from." + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + }, + { + "id": 70, + "name": "of", + "kind": 2048, + "kindString": "Method", + "flags": { + "isStatic": true, + "isExported": true + }, + "signatures": [ + { + "id": 71, + "name": "of", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Creates a Parent Resolver for the supplied key.", + "returns": "Returns an instance of Parent for the key.\n" + }, + "parameters": [ + { + "id": 72, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key to resolve." + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "reference", + "name": "Parent", + "id": 63, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + } + ], + "groups": [ + { + "title": "Constructors", + "kind": 512, + "children": [ + 64 + ] + }, + { + "title": "Methods", + "kind": 2048, + "children": [ + 67, + 70 + ] + } + ] + }, + { + "id": 114, + "name": "SingletonRegistration", + "kind": 128, + "kindString": "Class", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Used to allow functions/classes to indicate that they should be registered as singletons with the container." + }, + "children": [ + { + "id": 115, + "name": "constructor", + "kind": 512, + "kindString": "Constructor", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Creates an instance of SingletonRegistration." + }, + "signatures": [ + { + "id": 116, + "name": "new SingletonRegistration", + "kind": 16384, + "kindString": "Constructor signature", + "flags": {}, + "comment": { + "shortText": "Creates an instance of SingletonRegistration." + }, + "parameters": [ + { + "id": 117, + "name": "keyOrRegisterInChild", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "type": { + "type": "instrinct", + "name": "any" + } + }, + { + "id": 118, + "name": "registerInChild", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "type": { + "type": "instrinct", + "name": "boolean" + } + } + ], + "type": { + "type": "reference", + "name": "SingletonRegistration", + "id": 114, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + }, + { + "id": 119, + "name": "registerResolver", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 120, + "name": "registerResolver", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Called by the container to register the resolver.", + "returns": "The resolver that was registered.\n" + }, + "parameters": [ + { + "id": 121, + "name": "container", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The container the resolver is being registered with." + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137, + "moduleName": "\"aurelia-dependency-injection\"" + } + }, + { + "id": 122, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key the resolver should be registered as." + }, + "type": { + "type": "instrinct", + "name": "any" + } + }, + { + "id": 123, + "name": "fn", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The function to create the resolver for." + }, + "type": { + "type": "reference", + "name": "Function" + } + } + ], + "type": { + "type": "reference", + "name": "Resolver", + "id": 3, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + } + ], + "groups": [ + { + "title": "Constructors", + "kind": 512, + "children": [ + 115 + ] + }, + { + "title": "Methods", + "kind": 2048, + "children": [ + 119 + ] + } + ] + }, + { + "id": 73, + "name": "StrategyResolver", + "kind": 128, + "kindString": "Class", + "flags": { + "isExported": true + }, + "children": [ + { + "id": 74, + "name": "constructor", + "kind": 512, + "kindString": "Constructor", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Creates an instance of the StrategyResolver class." + }, + "signatures": [ + { + "id": 75, + "name": "new StrategyResolver", + "kind": 16384, + "kindString": "Constructor signature", + "flags": {}, + "comment": { + "shortText": "Creates an instance of the StrategyResolver class." + }, + "parameters": [ + { + "id": 76, + "name": "strategy", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "shortText": "The type of resolution strategy." + }, + "type": { + "type": "instrinct", + "name": "any" + } + }, + { + "id": 77, + "name": "state", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "shortText": "The state associated with the resolution strategy.\n" + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "reference", + "name": "StrategyResolver", + "id": 73, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + }, + { + "id": 78, + "name": "get", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 79, + "name": "get", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Called by the container to allow custom resolution of dependencies for a function/class.", + "returns": "Returns the resolved object.\n" + }, + "parameters": [ + { + "id": 80, + "name": "container", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The container to resolve from." + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137, + "moduleName": "\"aurelia-dependency-injection\"" + } + }, + { + "id": 81, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key that the resolver was registered as." + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + } + ], + "groups": [ + { + "title": "Constructors", + "kind": 512, + "children": [ + 74 + ] + }, + { + "title": "Methods", + "kind": 2048, + "children": [ + 78 + ] + } + ] + }, + { + "id": 105, + "name": "TransientRegistration", + "kind": 128, + "kindString": "Class", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Used to allow functions/classes to indicate that they should be registered as transients with the container." + }, + "children": [ + { + "id": 106, + "name": "constructor", + "kind": 512, + "kindString": "Constructor", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Creates an instance of TransientRegistration." + }, + "signatures": [ + { + "id": 107, + "name": "new TransientRegistration", + "kind": 16384, + "kindString": "Constructor signature", + "flags": {}, + "comment": { + "shortText": "Creates an instance of TransientRegistration." + }, + "parameters": [ + { + "id": 108, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "comment": { + "shortText": "The key to register as.\n" + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "reference", + "name": "TransientRegistration", + "id": 105, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + }, + { + "id": 109, + "name": "registerResolver", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 110, + "name": "registerResolver", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Called by the container to register the resolver.", + "returns": "The resolver that was registered.\n" + }, + "parameters": [ + { + "id": 111, + "name": "container", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The container the resolver is being registered with." + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137, + "moduleName": "\"aurelia-dependency-injection\"" + } + }, + { + "id": 112, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key the resolver should be registered as." + }, + "type": { + "type": "instrinct", + "name": "any" + } + }, + { + "id": 113, + "name": "fn", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The function to create the resolver for." + }, + "type": { + "type": "reference", + "name": "Function" + } + } + ], + "type": { + "type": "reference", + "name": "Resolver", + "id": 3, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ] + } + ], + "groups": [ + { + "title": "Constructors", + "kind": 512, + "children": [ + 106 + ] + }, + { + "title": "Methods", + "kind": 2048, + "children": [ + 109 + ] + } + ] + }, + { + "id": 26, + "name": "ContainerConfiguration", + "kind": 256, + "kindString": "Interface", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Used to configure a Container instance." + }, + "children": [ + { + "id": 27, + "name": "onHandlerCreated", + "kind": 1024, + "kindString": "Property", + "flags": { + "isExported": true, + "isOptional": true + }, + "comment": { + "shortText": "An optional callback which will be called when any function needs an InvocationHandler created (called once per Function)." + }, + "type": { + "type": "reflection", + "declaration": { + "id": 28, + "name": "__type", + "kind": 65536, + "kindString": "Type literal", + "flags": {}, + "signatures": [ + { + "id": 29, + "name": "__call", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "parameters": [ + { + "id": 30, + "name": "handler", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "type": { + "type": "reference", + "name": "InvocationHandler", + "id": 124 + } + } + ], + "type": { + "type": "reference", + "name": "InvocationHandler", + "id": 124 + } + } + ] + } + } + } + ], + "groups": [ + { + "title": "Properties", + "kind": 1024, + "children": [ + 27 + ] + } + ] + }, + { + "id": 8, + "name": "Invoker", + "kind": 256, + "kindString": "Interface", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "A strategy for invoking a function, resulting in an object instance." + }, + "children": [ + { + "id": 9, + "name": "invoke", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 10, + "name": "invoke", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Invokes the function with the provided dependencies.", + "returns": "The result of the function invocation.\n" + }, + "parameters": [ + { + "id": 11, + "name": "container", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "type": { + "type": "reference", + "name": "Container", + "id": 137 + } + }, + { + "id": 12, + "name": "fn", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The constructor or factory function." + }, + "type": { + "type": "reference", + "name": "Function" + } + }, + { + "id": 13, + "name": "dependencies", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The dependencies of the function call." + }, + "type": { + "type": "instrinct", + "isArray": true, + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + }, + { + "id": 14, + "name": "invokeWithDynamicDependencies", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 15, + "name": "invokeWithDynamicDependencies", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Invokes the function with the provided dependencies.", + "returns": "The result of the function invocation.\n" + }, + "parameters": [ + { + "id": 16, + "name": "container", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "type": { + "type": "reference", + "name": "Container", + "id": 137 + } + }, + { + "id": 17, + "name": "fn", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The constructor or factory function." + }, + "type": { + "type": "reference", + "name": "Function" + } + }, + { + "id": 18, + "name": "staticDependencies", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The static dependencies of the function." + }, + "type": { + "type": "instrinct", + "isArray": true, + "name": "any" + } + }, + { + "id": 19, + "name": "dynamicDependencies", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "Additional dependencies to use during invocation." + }, + "type": { + "type": "instrinct", + "isArray": true, + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + } + ], + "groups": [ + { + "title": "Methods", + "kind": 2048, + "children": [ + 9, + 14 + ] + } + ] + }, + { + "id": 20, + "name": "Registration", + "kind": 256, + "kindString": "Interface", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Customizes how a particular function is resolved by the Container." + }, + "children": [ + { + "id": 21, + "name": "registerResolver", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 22, + "name": "registerResolver", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Called by the container to register the resolver.", + "returns": "The resolver that was registered.\n" + }, + "parameters": [ + { + "id": 23, + "name": "container", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The container the resolver is being registered with." + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137 + } + }, + { + "id": 24, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key the resolver should be registered as." + }, + "type": { + "type": "instrinct", + "name": "any" + } + }, + { + "id": 25, + "name": "fn", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The function to create the resolver for." + }, + "type": { + "type": "reference", + "name": "Function" + } + } + ], + "type": { + "type": "reference", + "name": "Resolver", + "id": 3 + } + } + ] + } + ], + "groups": [ + { + "title": "Methods", + "kind": 2048, + "children": [ + 21 + ] + } + ] + }, + { + "id": 3, + "name": "Resolver", + "kind": 256, + "kindString": "Interface", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Used to allow functions/classes to specify custom dependency resolution logic." + }, + "children": [ + { + "id": 4, + "name": "get", + "kind": 2048, + "kindString": "Method", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 5, + "name": "get", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Called by the container to allow custom resolution of dependencies for a function/class.", + "returns": "Returns the resolved object.\n" + }, + "parameters": [ + { + "id": 6, + "name": "container", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The container to resolve from." + }, + "type": { + "type": "reference", + "name": "Container", + "id": 137 + } + }, + { + "id": 7, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "comment": { + "text": "The key that the resolver was registered as." + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + } + ], + "groups": [ + { + "title": "Methods", + "kind": 2048, + "children": [ + 4 + ] + } + ] + }, + { + "id": 207, + "name": "resolver", + "kind": 32, + "kindString": "Variable", + "flags": { + "isExported": true + }, + "comment": { + "shortText": "Decorator: Indicates that the decorated class/object is a custom resolver." + }, + "type": { + "type": "reference", + "name": "Function" + } + }, + { + "id": 224, + "name": "autoinject", + "kind": 64, + "kindString": "Function", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 225, + "name": "autoinject", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Decorator: Directs the TypeScript transpiler to write-out type metadata for the decorated class." + }, + "parameters": [ + { + "id": 226, + "name": "potentialTarget", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + }, + { + "id": 211, + "name": "factory", + "kind": 64, + "kindString": "Function", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 212, + "name": "factory", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Decorator: Specifies that the decorated item should be called as a factory function, rather than a constructor." + }, + "parameters": [ + { + "id": 213, + "name": "potentialTarget", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + }, + { + "id": 227, + "name": "inject", + "kind": 64, + "kindString": "Function", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 228, + "name": "inject", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Decorator: Specifies the dependencies that should be injected by the DI Container into the decoratored class/function." + }, + "parameters": [ + { + "id": 229, + "name": "rest", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isRest": true + }, + "type": { + "type": "instrinct", + "isArray": true, + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + }, + { + "id": 208, + "name": "invoker", + "kind": 64, + "kindString": "Function", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 209, + "name": "invoker", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Decorator: Specifies a custom Invoker for the decorated item." + }, + "parameters": [ + { + "id": 210, + "name": "value", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "type": { + "type": "reference", + "name": "Invoker", + "id": 8, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + }, + { + "id": 214, + "name": "registration", + "kind": 64, + "kindString": "Function", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 215, + "name": "registration", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Decorator: Specifies a custom registration strategy for the decorated class/function." + }, + "parameters": [ + { + "id": 216, + "name": "value", + "kind": 32768, + "kindString": "Parameter", + "flags": {}, + "type": { + "type": "reference", + "name": "Registration", + "id": 20, + "moduleName": "\"aurelia-dependency-injection\"" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + }, + { + "id": 220, + "name": "singleton", + "kind": 64, + "kindString": "Function", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 221, + "name": "singleton", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Decorator: Specifies to register the decorated item with a \"singleton\" lieftime." + }, + "parameters": [ + { + "id": 222, + "name": "keyOrRegisterInChild", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "type": { + "type": "instrinct", + "name": "any" + } + }, + { + "id": 223, + "name": "registerInChild", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "type": { + "type": "instrinct", + "name": "boolean" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + }, + { + "id": 217, + "name": "transient", + "kind": 64, + "kindString": "Function", + "flags": { + "isExported": true + }, + "signatures": [ + { + "id": 218, + "name": "transient", + "kind": 4096, + "kindString": "Call signature", + "flags": {}, + "comment": { + "shortText": "Decorator: Specifies to register the decorated item with a \"transient\" lifetime." + }, + "parameters": [ + { + "id": 219, + "name": "key", + "kind": 32768, + "kindString": "Parameter", + "flags": { + "isOptional": true + }, + "type": { + "type": "instrinct", + "name": "any" + } + } + ], + "type": { + "type": "instrinct", + "name": "any" + } + } + ] + } + ], + "groups": [ + { + "title": "Classes", + "kind": 128, + "children": [ + 41, + 137, + 82, + 92, + 124, + 31, + 51, + 63, + 114, + 73, + 105 + ] + }, + { + "title": "Interfaces", + "kind": 256, + "children": [ + 26, + 8, + 20, + 3 + ] + }, + { + "title": "Variables", + "kind": 32, + "children": [ + 207 + ] + }, + { + "title": "Functions", + "kind": 64, + "children": [ + 224, + 211, + 227, + 208, + 214, + 220, + 217 + ] + } + ] +} \ No newline at end of file diff --git a/package.json b/package.json index 3e2d07d9..03bb9058 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "aurelia-validation", - "version": "0.7.0", + "version": "0.8.0", "description": "This is a validation interface for hooking in to Aurelia's binding and templating engines.", "keywords": [ "aurelia",