@singularsystems/neo-core 1.0.0-alpha.3 → 1.0.0-beta.0

package/dist/JsonSchema/ClassMetadata.js

@@ -1,53 +1,53 @@
-import { TypeMetadata } from './TypeMetadata';
-import { PropertyMetadata } from './PropertyMetadata';
-var ClassMetadata = /** @class */ (function () {
-    function ClassMetadata(name) {
-        this.name = name;
-        /**
-         * All properties.
-         */
-        this.properties = [];
-        /**
-         * Properties excluding child objects and lists.
-         */
-        this.simpleProperties = [];
-        /**
-         * Properties containing child object types.
-         */
-        this.childObjectProperties = [];
-        /**
-         * Properties containing child list types.
-         */
-        this.childListProperties = [];
-    }
-    ClassMetadata.prototype.loadMetaData = function (schema, cache) {
-        for (var propertyKey in schema.properties) {
-            var propertySchema = schema.properties[propertyKey];
-            var propertyMetaData = new PropertyMetadata(propertyKey, TypeMetadata.create(propertySchema, cache));
-            propertyMetaData.title = propertySchema.title;
-            propertyMetaData.description = propertySchema.description;
-            if (propertyMetaData.type.basicType !== "unknown") {
-                this.properties.push(propertyMetaData);
-                if (propertyMetaData.type.basicType === "array") {
-                    this.childListProperties.push(propertyMetaData);
-                }
-                else if (propertyMetaData.type.basicType === "object") {
-                    this.childObjectProperties.push(propertyMetaData);
-                }
-                else {
-                    this.simpleProperties.push(propertyMetaData);
-                }
-            }
-        }
-    };
-    ClassMetadata.prototype.clone = function () {
-        var clone = new ClassMetadata(this.name);
-        clone.properties = this.properties;
-        clone.simpleProperties = this.simpleProperties;
-        clone.childObjectProperties = this.childObjectProperties;
-        clone.childListProperties = this.childListProperties;
-        return clone;
-    };
-    return ClassMetadata;
-}());
-export { ClassMetadata };
+import { TypeMetadata } from './TypeMetadata';
+import { PropertyMetadata } from './PropertyMetadata';
+var ClassMetadata = /** @class */ (function () {
+    function ClassMetadata(name) {
+        this.name = name;
+        /**
+         * All properties.
+         */
+        this.properties = [];
+        /**
+         * Properties excluding child objects and lists.
+         */
+        this.simpleProperties = [];
+        /**
+         * Properties containing child object types.
+         */
+        this.childObjectProperties = [];
+        /**
+         * Properties containing child list types.
+         */
+        this.childListProperties = [];
+    }
+    ClassMetadata.prototype.loadMetaData = function (schema, cache) {
+        for (var propertyKey in schema.properties) {
+            var propertySchema = schema.properties[propertyKey];
+            var propertyMetaData = new PropertyMetadata(propertyKey, TypeMetadata.create(propertySchema, cache));
+            propertyMetaData.title = propertySchema.title;
+            propertyMetaData.description = propertySchema.description;
+            if (propertyMetaData.type.basicType !== "unknown") {
+                this.properties.push(propertyMetaData);
+                if (propertyMetaData.type.basicType === "array") {
+                    this.childListProperties.push(propertyMetaData);
+                }
+                else if (propertyMetaData.type.basicType === "object") {
+                    this.childObjectProperties.push(propertyMetaData);
+                }
+                else {
+                    this.simpleProperties.push(propertyMetaData);
+                }
+            }
+        }
+    };
+    ClassMetadata.prototype.clone = function () {
+        var clone = new ClassMetadata(this.name);
+        clone.properties = this.properties;
+        clone.simpleProperties = this.simpleProperties;
+        clone.childObjectProperties = this.childObjectProperties;
+        clone.childListProperties = this.childListProperties;
+        return clone;
+    };
+    return ClassMetadata;
+}());
+export { ClassMetadata };

package/dist/JsonSchema/JsonData.d.ts

@@ -1,16 +1,16 @@
-import { RootType } from "./JsonSchemaTypes";
-import { TypeMetadata } from "./TypeMetadata";
-export interface IRawJsonDataWithSchema {
-    data: any;
-    jsonSchema: RootType | TypeMetadata;
-}
-export declare class JsonDataWithSchema implements IRawJsonDataWithSchema {
-    constructor(dataWithSchema: IRawJsonDataWithSchema, dereference?: boolean);
-    data: any;
-    jsonSchema: TypeMetadata;
-    /**
-     * Selects the first list as the new root.
-     * Returns the current instance if the root is already a list.
-     */
-    selectFirstList(): JsonDataWithSchema;
-}
+import { RootType } from "./JsonSchemaTypes";
+import { TypeMetadata } from "./TypeMetadata";
+export interface IRawJsonDataWithSchema {
+    data: any;
+    jsonSchema: RootType | TypeMetadata;
+}
+export declare class JsonDataWithSchema implements IRawJsonDataWithSchema {
+    constructor(dataWithSchema: IRawJsonDataWithSchema, dereference?: boolean);
+    data: any;
+    jsonSchema: TypeMetadata;
+    /**
+     * Selects the first list as the new root.
+     * Returns the current instance if the root is already a list.
+     */
+    selectFirstList(): JsonDataWithSchema;
+}

package/dist/JsonSchema/JsonData.js

@@ -1,97 +1,97 @@
-import { TypeMetadata } from "./TypeMetadata";
-var JsonDataWithSchema = /** @class */ (function () {
-    function JsonDataWithSchema(dataWithSchema, dereference) {
-        if (dereference === void 0) { dereference = true; }
-        if (dereference) {
-            JsonDereferencer.dereference(dataWithSchema.data);
-        }
-        this.data = dataWithSchema.data;
-        if (dataWithSchema.jsonSchema.basicType) {
-            this.jsonSchema = dataWithSchema.jsonSchema;
-        }
-        else {
-            this.jsonSchema = TypeMetadata.create(dataWithSchema.jsonSchema);
-        }
-    }
-    /**
-     * Selects the first list as the new root.
-     * Returns the current instance if the root is already a list.
-     */
-    JsonDataWithSchema.prototype.selectFirstList = function () {
-        if (this.jsonSchema.customType) {
-            if (this.jsonSchema.basicType === "object") {
-                var childListProperty = this.jsonSchema.customType.childListProperties[0];
-                if (childListProperty) {
-                    return new JsonDataWithSchema({
-                        data: this.data[childListProperty.propertyName],
-                        jsonSchema: childListProperty.type
-                    }, false);
-                }
-            }
-            else if (this.jsonSchema.basicType === "array") {
-                return this;
-            }
-        }
-        throw Error("Root type has no child lists, or is not a complex object.");
-    };
-    return JsonDataWithSchema;
-}());
-export { JsonDataWithSchema };
-/**
- * Iterates object graphs with { $ref } pointer objects, and replaces them with the referenced object instances.
- */
-var JsonDereferencer = /** @class */ (function () {
-    function JsonDereferencer() {
-        this.refs = {};
-    }
-    /**
-     * Iterates object graphs with { $ref } pointer objects, and replaces them with the referenced object instances.
-     */
-    JsonDereferencer.dereference = function (data) {
-        var dereferencer = new JsonDereferencer();
-        dereferencer.dereference(data);
-    };
-    JsonDereferencer.prototype.dereference = function (data) {
-        this.dereferenceInternal(data, function () { throw Error("Top level item cannot be a $ref object"); });
-    };
-    JsonDereferencer.prototype.dereferenceInternal = function (data, replace) {
-        if (data !== null && data !== undefined) {
-            if (data instanceof Array) {
-                this.dereferenceArray(data);
-            }
-            else if (data instanceof Object && !(data instanceof Date)) {
-                this.dereferenceObject(data, replace);
-            }
-        }
-    };
-    JsonDereferencer.prototype.dereferenceArray = function (list) {
-        var _loop_1 = function (i) {
-            this_1.dereferenceObject(list[i], function (dereferenced) { return list[i] = dereferenced; });
-        };
-        var this_1 = this;
-        for (var i = 0; i < list.length; i++) {
-            _loop_1(i);
-        }
-    };
-    JsonDereferencer.prototype.dereferenceObject = function (object, replace) {
-        if (object.hasOwnProperty("$id")) {
-            this.refs[object["$id"]] = object;
-        }
-        if (object.hasOwnProperty("$ref")) {
-            replace(this.refs[object["$ref"]]);
-        }
-        else {
-            var _loop_2 = function (propertyKey) {
-                if (object.hasOwnProperty(propertyKey)) {
-                    var value = object[propertyKey];
-                    this_2.dereferenceInternal(value, function (dereferenced) { return object[propertyKey] = dereferenced; });
-                }
-            };
-            var this_2 = this;
-            for (var propertyKey in object) {
-                _loop_2(propertyKey);
-            }
-        }
-    };
-    return JsonDereferencer;
-}());
+import { TypeMetadata } from "./TypeMetadata";
+var JsonDataWithSchema = /** @class */ (function () {
+    function JsonDataWithSchema(dataWithSchema, dereference) {
+        if (dereference === void 0) { dereference = true; }
+        if (dereference) {
+            JsonDereferencer.dereference(dataWithSchema.data);
+        }
+        this.data = dataWithSchema.data;
+        if (dataWithSchema.jsonSchema.basicType) {
+            this.jsonSchema = dataWithSchema.jsonSchema;
+        }
+        else {
+            this.jsonSchema = TypeMetadata.create(dataWithSchema.jsonSchema);
+        }
+    }
+    /**
+     * Selects the first list as the new root.
+     * Returns the current instance if the root is already a list.
+     */
+    JsonDataWithSchema.prototype.selectFirstList = function () {
+        if (this.jsonSchema.customType) {
+            if (this.jsonSchema.basicType === "object") {
+                var childListProperty = this.jsonSchema.customType.childListProperties[0];
+                if (childListProperty) {
+                    return new JsonDataWithSchema({
+                        data: this.data[childListProperty.propertyName],
+                        jsonSchema: childListProperty.type
+                    }, false);
+                }
+            }
+            else if (this.jsonSchema.basicType === "array") {
+                return this;
+            }
+        }
+        throw Error("Root type has no child lists, or is not a complex object.");
+    };
+    return JsonDataWithSchema;
+}());
+export { JsonDataWithSchema };
+/**
+ * Iterates object graphs with { $ref } pointer objects, and replaces them with the referenced object instances.
+ */
+var JsonDereferencer = /** @class */ (function () {
+    function JsonDereferencer() {
+        this.refs = {};
+    }
+    /**
+     * Iterates object graphs with { $ref } pointer objects, and replaces them with the referenced object instances.
+     */
+    JsonDereferencer.dereference = function (data) {
+        var dereferencer = new JsonDereferencer();
+        dereferencer.dereference(data);
+    };
+    JsonDereferencer.prototype.dereference = function (data) {
+        this.dereferenceInternal(data, function () { throw Error("Top level item cannot be a $ref object"); });
+    };
+    JsonDereferencer.prototype.dereferenceInternal = function (data, replace) {
+        if (data !== null && data !== undefined) {
+            if (data instanceof Array) {
+                this.dereferenceArray(data);
+            }
+            else if (data instanceof Object && !(data instanceof Date)) {
+                this.dereferenceObject(data, replace);
+            }
+        }
+    };
+    JsonDereferencer.prototype.dereferenceArray = function (list) {
+        var _loop_1 = function (i) {
+            this_1.dereferenceObject(list[i], function (dereferenced) { return list[i] = dereferenced; });
+        };
+        var this_1 = this;
+        for (var i = 0; i < list.length; i++) {
+            _loop_1(i);
+        }
+    };
+    JsonDereferencer.prototype.dereferenceObject = function (object, replace) {
+        if (object.hasOwnProperty("$id")) {
+            this.refs[object["$id"]] = object;
+        }
+        if (object.hasOwnProperty("$ref")) {
+            replace(this.refs[object["$ref"]]);
+        }
+        else {
+            var _loop_2 = function (propertyKey) {
+                if (object.hasOwnProperty(propertyKey)) {
+                    var value = object[propertyKey];
+                    this_2.dereferenceInternal(value, function (dereferenced) { return object[propertyKey] = dereferenced; });
+                }
+            };
+            var this_2 = this;
+            for (var propertyKey in object) {
+                _loop_2(propertyKey);
+            }
+        }
+    };
+    return JsonDereferencer;
+}());

package/dist/JsonSchema/JsonSchemaTypes.d.ts

@@ -1,37 +1,37 @@
-export interface IJsonSchemaDescriptorType {
-    title?: string;
-    description?: string;
-}
-export interface IJsonSchemaType extends IJsonSchemaDescriptorType {
-    type: string | string[];
-}
-export interface IJsonSimpleType extends IJsonSchemaType {
-    format?: string;
-}
-export interface IJsonArrayType extends IJsonSchemaType {
-    items: IJsonReferenceType | IJsonSimpleType;
-}
-export interface IJsonReferenceType extends IJsonSchemaDescriptorType {
-    $ref: string;
-}
-export interface IJsonUnionType extends IJsonSchemaDescriptorType {
-    oneOf: (IJsonSchemaType | IJsonReferenceType)[];
-}
-export interface IJsonCombinedType extends IJsonSchemaDescriptorType {
-    allOf: (IJsonSchemaType | IJsonReferenceType)[];
-}
-export interface IJsonObjectType extends IJsonSchemaType {
-    properties: {
-        [index: string]: AllTypes;
-    };
-    required?: string[];
-}
-declare type AllTypes = IJsonSimpleType | IJsonArrayType | IJsonObjectType | IJsonReferenceType | IJsonUnionType | IJsonCombinedType;
-export interface IJsonSchema {
-    definitions: {
-        [index: string]: AllTypes;
-    };
-}
-export declare type RootType = IJsonSchema & AllTypes;
-export declare type BasicType = "string" | "number" | "integer" | "date" | "boolean" | "array" | "object" | "unknown";
-export {};
+export interface IJsonSchemaDescriptorType {
+    title?: string;
+    description?: string;
+}
+export interface IJsonSchemaType extends IJsonSchemaDescriptorType {
+    type: string | string[];
+}
+export interface IJsonSimpleType extends IJsonSchemaType {
+    format?: string;
+}
+export interface IJsonArrayType extends IJsonSchemaType {
+    items: IJsonReferenceType | IJsonSimpleType;
+}
+export interface IJsonReferenceType extends IJsonSchemaDescriptorType {
+    $ref: string;
+}
+export interface IJsonUnionType extends IJsonSchemaDescriptorType {
+    oneOf: (IJsonSchemaType | IJsonReferenceType)[];
+}
+export interface IJsonCombinedType extends IJsonSchemaDescriptorType {
+    allOf: (IJsonSchemaType | IJsonReferenceType)[];
+}
+export interface IJsonObjectType extends IJsonSchemaType {
+    properties: {
+        [index: string]: AllTypes;
+    };
+    required?: string[];
+}
+type AllTypes = IJsonSimpleType | IJsonArrayType | IJsonObjectType | IJsonReferenceType | IJsonUnionType | IJsonCombinedType;
+export interface IJsonSchema {
+    definitions: {
+        [index: string]: AllTypes;
+    };
+}
+export type RootType = IJsonSchema & AllTypes;
+export type BasicType = "string" | "number" | "integer" | "date" | "boolean" | "array" | "object" | "unknown";
+export {};

package/dist/JsonSchema/JsonSchemaTypes.js

@@ -1 +1 @@
-export {};
+export {};

package/dist/JsonSchema/PropertyMetadata.d.ts

@@ -1,8 +1,8 @@
-import { TypeMetadata } from './TypeMetadata';
-export declare class PropertyMetadata {
-    propertyName: string;
-    type: TypeMetadata;
-    constructor(propertyName: string, type: TypeMetadata);
-    title?: string;
-    description?: string;
-}
+import { TypeMetadata } from './TypeMetadata';
+export declare class PropertyMetadata {
+    propertyName: string;
+    type: TypeMetadata;
+    constructor(propertyName: string, type: TypeMetadata);
+    title?: string;
+    description?: string;
+}

package/dist/JsonSchema/PropertyMetadata.js

@@ -1,8 +1,8 @@
-var PropertyMetadata = /** @class */ (function () {
-    function PropertyMetadata(propertyName, type) {
-        this.propertyName = propertyName;
-        this.type = type;
-    }
-    return PropertyMetadata;
-}());
-export { PropertyMetadata };
+var PropertyMetadata = /** @class */ (function () {
+    function PropertyMetadata(propertyName, type) {
+        this.propertyName = propertyName;
+        this.type = type;
+    }
+    return PropertyMetadata;
+}());
+export { PropertyMetadata };

package/dist/JsonSchema/TypeCache.d.ts

@@ -1,16 +1,16 @@
-import { TypeMetadata } from './TypeMetadata';
-import { RootType } from './JsonSchemaTypes';
-export interface ITypeCacheInternal {
-    getOrAddType(name: string): TypeMetadata;
-}
-export declare class TypeCache {
-    private schema;
-    private _objects;
-    private _root;
-    constructor(schema: RootType);
-    get root(): TypeMetadata;
-    get objects(): {
-        [index: string]: TypeMetadata;
-    };
-    private getOrAddType;
-}
+import { TypeMetadata } from './TypeMetadata';
+import { RootType } from './JsonSchemaTypes';
+export interface ITypeCacheInternal {
+    getOrAddType(name: string): TypeMetadata;
+}
+export declare class TypeCache {
+    private schema;
+    private _objects;
+    private _root;
+    constructor(schema: RootType);
+    get root(): TypeMetadata;
+    get objects(): {
+        [index: string]: TypeMetadata;
+    };
+    private getOrAddType;
+}

package/dist/JsonSchema/TypeCache.js

@@ -1,44 +1,44 @@
-import { TypeMetadata } from './TypeMetadata';
-var TypeCache = /** @class */ (function () {
-    function TypeCache(schema) {
-        this.schema = schema;
-        this._objects = {};
-        this._root = new TypeMetadata();
-        this._root.parse(schema, this);
-    }
-    Object.defineProperty(TypeCache.prototype, "root", {
-        get: function () {
-            return this._root;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(TypeCache.prototype, "objects", {
-        get: function () {
-            return this._objects;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    TypeCache.prototype.getOrAddType = function (name) {
-        if (name.startsWith("#/definitions/")) {
-            name = name.replace("#/definitions/", "");
-            var type = this._objects[name];
-            if (!type) {
-                // Look for this type in the definitions
-                type = new TypeMetadata();
-                this._objects[name] = type;
-                type.parse(this.schema.definitions[name], this);
-                if (type.customType) {
-                    type.customType.name = name;
-                }
-            }
-            return type;
-        }
-        else {
-            throw Error("Unknown type name.");
-        }
-    };
-    return TypeCache;
-}());
-export { TypeCache };
+import { TypeMetadata } from './TypeMetadata';
+var TypeCache = /** @class */ (function () {
+    function TypeCache(schema) {
+        this.schema = schema;
+        this._objects = {};
+        this._root = new TypeMetadata();
+        this._root.parse(schema, this);
+    }
+    Object.defineProperty(TypeCache.prototype, "root", {
+        get: function () {
+            return this._root;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TypeCache.prototype, "objects", {
+        get: function () {
+            return this._objects;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TypeCache.prototype.getOrAddType = function (name) {
+        if (name.startsWith("#/definitions/")) {
+            name = name.replace("#/definitions/", "");
+            var type = this._objects[name];
+            if (!type) {
+                // Look for this type in the definitions
+                type = new TypeMetadata();
+                this._objects[name] = type;
+                type.parse(this.schema.definitions[name], this);
+                if (type.customType) {
+                    type.customType.name = name;
+                }
+            }
+            return type;
+        }
+        else {
+            throw Error("Unknown type name.");
+        }
+    };
+    return TypeCache;
+}());
+export { TypeCache };