@itwin/ecschema-metadata 3.4.0-dev.9 → 3.5.0-dev.5

package/lib/cjs/Context.js

@@ -1,205 +1,205 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaContext = exports.SchemaCache = exports.SchemaMap = void 0;
-const ECObjects_1 = require("./ECObjects");
-const Exception_1 = require("./Exception");
-/**
- * @beta
- */
-class SchemaMap extends Array {
-}
-exports.SchemaMap = SchemaMap;
-/**
- * @beta
- */
-class SchemaCache {
-    constructor() {
-        this._schema = new SchemaMap();
-    }
-    get count() { return this._schema.length; }
-    /**
-     * Adds a schema to the cache. Does not allow for duplicate schemas, checks using SchemaMatchType.Latest.
-     * @param schema The schema to add to the cache.
-     */
-    async addSchema(schema) {
-        if (await this.getSchema(schema.schemaKey))
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateSchema, `The schema, ${schema.schemaKey.toString()}, already exists within this cache.`);
-        this._schema.push(schema);
-    }
-    /**
-     * Adds a schema to the cache. Does not allow for duplicate schemas, checks using SchemaMatchType.Latest.
-     * @param schema The schema to add to the cache.
-     */
-    addSchemaSync(schema) {
-        if (this.getSchemaSync(schema.schemaKey))
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateSchema, `The schema, ${schema.schemaKey.toString()}, already exists within this cache.`);
-        this._schema.push(schema);
-    }
-    /**
-     * Gets the schema which matches the provided SchemaKey.
-     * @param schemaKey The SchemaKey describing the schema to get from the cache.
-     * @param matchType The match type to use when locating the schema
-     */
-    async getSchema(schemaKey, matchType = ECObjects_1.SchemaMatchType.Latest) {
-        if (this.count === 0)
-            return undefined;
-        const findFunc = (schema) => {
-            return schema.schemaKey.matches(schemaKey, matchType);
-        };
-        const foundSchema = this._schema.find(findFunc);
-        if (!foundSchema)
-            return undefined;
-        return foundSchema;
-    }
-    /**
-     *
-     * @param schemaKey
-     * @param matchType
-     */
-    getSchemaSync(schemaKey, matchType = ECObjects_1.SchemaMatchType.Latest) {
-        if (this.count === 0)
-            return undefined;
-        const findFunc = (schema) => {
-            return schema.schemaKey.matches(schemaKey, matchType);
-        };
-        const foundSchema = this._schema.find(findFunc);
-        if (!foundSchema)
-            return foundSchema;
-        return foundSchema;
-    }
-    /**
-     * Generator function that can iterate through each schema in _schema SchemaMap and items for each Schema
-     */
-    *getSchemaItems() {
-        for (const schema of this._schema) {
-            for (const schemaItem of schema.getItems()) {
-                yield schemaItem;
-            }
-        }
-    }
-    /**
-     * Gets all the schemas from the schema cache.
-     * @returns An array of Schema objects.
-     */
-    getAllSchemas() {
-        return this._schema;
-    }
-}
-exports.SchemaCache = SchemaCache;
-/**
- * The SchemaContext, context object is used to facilitate schema and schema item location.
- *
- * The context controls the lifetime of each schema that it knows about. It has to be explicitly removed from the context to delete a schema object.
- *
- * The context is made up of a group of Schema Locators.
- * @beta
- */
-class SchemaContext {
-    constructor() {
-        this._locaters = [];
-        this._knownSchemas = new SchemaCache();
-        this._locaters.push(this._knownSchemas);
-    }
-    addLocater(locater) {
-        this._locaters.push(locater);
-    }
-    /**
-     * Adds the schema to this context
-     * @param schema The schema to add to this context
-     */
-    async addSchema(schema) {
-        this.addSchemaSync(schema);
-    }
-    /**
-     * Adds the schema to this context
-     * @param schema The schema to add to this context
-     */
-    addSchemaSync(schema) {
-        this._knownSchemas.addSchemaSync(schema);
-    }
-    /**
-     * Adds the given SchemaItem to the the SchemaContext by locating the schema, with the best match of SchemaMatchType.Exact, and
-     * @param schemaItem The SchemaItem to add
-     */
-    async addSchemaItem(schemaItem) {
-        const schema = await this.getSchema(schemaItem.key.schemaKey, ECObjects_1.SchemaMatchType.Exact);
-        if (!schema)
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.UnableToLocateSchema, `Unable to add the schema item ${schemaItem.name} to the schema ${schemaItem.key.schemaKey.toString()} because the schema could not be located.`);
-        schema.addItem(schemaItem);
-    }
-    /**
-     *
-     * @param schemaKey
-     */
-    async getSchema(schemaKey, matchType = ECObjects_1.SchemaMatchType.Latest) {
-        // the first locater is _knownSchemas, so we don't have to check the cache explicitly here
-        for (const locater of this._locaters) {
-            const schema = await locater.getSchema(schemaKey, matchType, this);
-            if (undefined !== schema)
-                return schema;
-        }
-        return undefined;
-    }
-    /**
-     *
-     * @param schemaKey
-     */
-    getSchemaSync(schemaKey, matchType = ECObjects_1.SchemaMatchType.Latest) {
-        // the first locater is _knownSchemas, so we don't have to check the cache explicitly here
-        for (const locater of this._locaters) {
-            const schema = locater.getSchemaSync(schemaKey, matchType, this);
-            if (undefined !== schema)
-                return schema;
-        }
-        return undefined;
-    }
-    /**
-     * Attempts to get a Schema from the context's cache.
-     * @param schemaKey The SchemaKey to identify the Schema.
-     * @param matchType The SchemaMatch type to use. Default is SchemaMatchType.Latest.
-     * @internal
-     */
-    async getCachedSchema(schemaKey, matchType = ECObjects_1.SchemaMatchType.Latest) {
-        return this.getCachedSchemaSync(schemaKey, matchType);
-    }
-    /**
-     * Attempts to get a Schema from the context's cache.
-     * @param schemaKey The SchemaKey to identify the Schema.
-     * @param matchType The SchemaMatch type to use. Default is SchemaMatchType.Latest.
-     * @internal
-     */
-    getCachedSchemaSync(schemaKey, matchType = ECObjects_1.SchemaMatchType.Latest) {
-        const schema = this._knownSchemas.getSchemaSync(schemaKey, matchType);
-        return schema;
-    }
-    async getSchemaItem(schemaItemKey) {
-        const schema = await this.getSchema(schemaItemKey.schemaKey, ECObjects_1.SchemaMatchType.Latest);
-        if (undefined === schema)
-            return undefined;
-        return schema.getItem(schemaItemKey.name);
-    }
-    getSchemaItemSync(schemaItemKey) {
-        const schema = this.getSchemaSync(schemaItemKey.schemaKey, ECObjects_1.SchemaMatchType.Latest);
-        if (undefined === schema)
-            return undefined;
-        return schema.getItemSync(schemaItemKey.name);
-    }
-    getSchemaItems() {
-        return this._knownSchemas.getSchemaItems();
-    }
-    /**
-     * Gets all the Schemas known by the context. This includes schemas added to the
-     * context using [[SchemaContext.addSchema]]. This does not include schemas that
-     * can be located by an ISchemaLocater instance added to the context.
-     * @returns An array of Schema objects.
-     */
-    getKnownSchemas() {
-        return this._knownSchemas.getAllSchemas();
-    }
-}
-exports.SchemaContext = SchemaContext;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaContext = exports.SchemaCache = exports.SchemaMap = void 0;
+const ECObjects_1 = require("./ECObjects");
+const Exception_1 = require("./Exception");
+/**
+ * @beta
+ */
+class SchemaMap extends Array {
+}
+exports.SchemaMap = SchemaMap;
+/**
+ * @beta
+ */
+class SchemaCache {
+    constructor() {
+        this._schema = new SchemaMap();
+    }
+    get count() { return this._schema.length; }
+    /**
+     * Adds a schema to the cache. Does not allow for duplicate schemas, checks using SchemaMatchType.Latest.
+     * @param schema The schema to add to the cache.
+     */
+    async addSchema(schema) {
+        if (await this.getSchema(schema.schemaKey))
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateSchema, `The schema, ${schema.schemaKey.toString()}, already exists within this cache.`);
+        this._schema.push(schema);
+    }
+    /**
+     * Adds a schema to the cache. Does not allow for duplicate schemas, checks using SchemaMatchType.Latest.
+     * @param schema The schema to add to the cache.
+     */
+    addSchemaSync(schema) {
+        if (this.getSchemaSync(schema.schemaKey))
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.DuplicateSchema, `The schema, ${schema.schemaKey.toString()}, already exists within this cache.`);
+        this._schema.push(schema);
+    }
+    /**
+     * Gets the schema which matches the provided SchemaKey.
+     * @param schemaKey The SchemaKey describing the schema to get from the cache.
+     * @param matchType The match type to use when locating the schema
+     */
+    async getSchema(schemaKey, matchType = ECObjects_1.SchemaMatchType.Latest) {
+        if (this.count === 0)
+            return undefined;
+        const findFunc = (schema) => {
+            return schema.schemaKey.matches(schemaKey, matchType);
+        };
+        const foundSchema = this._schema.find(findFunc);
+        if (!foundSchema)
+            return undefined;
+        return foundSchema;
+    }
+    /**
+     *
+     * @param schemaKey
+     * @param matchType
+     */
+    getSchemaSync(schemaKey, matchType = ECObjects_1.SchemaMatchType.Latest) {
+        if (this.count === 0)
+            return undefined;
+        const findFunc = (schema) => {
+            return schema.schemaKey.matches(schemaKey, matchType);
+        };
+        const foundSchema = this._schema.find(findFunc);
+        if (!foundSchema)
+            return foundSchema;
+        return foundSchema;
+    }
+    /**
+     * Generator function that can iterate through each schema in _schema SchemaMap and items for each Schema
+     */
+    *getSchemaItems() {
+        for (const schema of this._schema) {
+            for (const schemaItem of schema.getItems()) {
+                yield schemaItem;
+            }
+        }
+    }
+    /**
+     * Gets all the schemas from the schema cache.
+     * @returns An array of Schema objects.
+     */
+    getAllSchemas() {
+        return this._schema;
+    }
+}
+exports.SchemaCache = SchemaCache;
+/**
+ * The SchemaContext, context object is used to facilitate schema and schema item location.
+ *
+ * The context controls the lifetime of each schema that it knows about. It has to be explicitly removed from the context to delete a schema object.
+ *
+ * The context is made up of a group of Schema Locators.
+ * @beta
+ */
+class SchemaContext {
+    constructor() {
+        this._locaters = [];
+        this._knownSchemas = new SchemaCache();
+        this._locaters.push(this._knownSchemas);
+    }
+    addLocater(locater) {
+        this._locaters.push(locater);
+    }
+    /**
+     * Adds the schema to this context
+     * @param schema The schema to add to this context
+     */
+    async addSchema(schema) {
+        this.addSchemaSync(schema);
+    }
+    /**
+     * Adds the schema to this context
+     * @param schema The schema to add to this context
+     */
+    addSchemaSync(schema) {
+        this._knownSchemas.addSchemaSync(schema);
+    }
+    /**
+     * Adds the given SchemaItem to the the SchemaContext by locating the schema, with the best match of SchemaMatchType.Exact, and
+     * @param schemaItem The SchemaItem to add
+     */
+    async addSchemaItem(schemaItem) {
+        const schema = await this.getSchema(schemaItem.key.schemaKey, ECObjects_1.SchemaMatchType.Exact);
+        if (!schema)
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.UnableToLocateSchema, `Unable to add the schema item ${schemaItem.name} to the schema ${schemaItem.key.schemaKey.toString()} because the schema could not be located.`);
+        schema.addItem(schemaItem);
+    }
+    /**
+     *
+     * @param schemaKey
+     */
+    async getSchema(schemaKey, matchType = ECObjects_1.SchemaMatchType.Latest) {
+        // the first locater is _knownSchemas, so we don't have to check the cache explicitly here
+        for (const locater of this._locaters) {
+            const schema = await locater.getSchema(schemaKey, matchType, this);
+            if (undefined !== schema)
+                return schema;
+        }
+        return undefined;
+    }
+    /**
+     *
+     * @param schemaKey
+     */
+    getSchemaSync(schemaKey, matchType = ECObjects_1.SchemaMatchType.Latest) {
+        // the first locater is _knownSchemas, so we don't have to check the cache explicitly here
+        for (const locater of this._locaters) {
+            const schema = locater.getSchemaSync(schemaKey, matchType, this);
+            if (undefined !== schema)
+                return schema;
+        }
+        return undefined;
+    }
+    /**
+     * Attempts to get a Schema from the context's cache.
+     * @param schemaKey The SchemaKey to identify the Schema.
+     * @param matchType The SchemaMatch type to use. Default is SchemaMatchType.Latest.
+     * @internal
+     */
+    async getCachedSchema(schemaKey, matchType = ECObjects_1.SchemaMatchType.Latest) {
+        return this.getCachedSchemaSync(schemaKey, matchType);
+    }
+    /**
+     * Attempts to get a Schema from the context's cache.
+     * @param schemaKey The SchemaKey to identify the Schema.
+     * @param matchType The SchemaMatch type to use. Default is SchemaMatchType.Latest.
+     * @internal
+     */
+    getCachedSchemaSync(schemaKey, matchType = ECObjects_1.SchemaMatchType.Latest) {
+        const schema = this._knownSchemas.getSchemaSync(schemaKey, matchType);
+        return schema;
+    }
+    async getSchemaItem(schemaItemKey) {
+        const schema = await this.getSchema(schemaItemKey.schemaKey, ECObjects_1.SchemaMatchType.Latest);
+        if (undefined === schema)
+            return undefined;
+        return schema.getItem(schemaItemKey.name);
+    }
+    getSchemaItemSync(schemaItemKey) {
+        const schema = this.getSchemaSync(schemaItemKey.schemaKey, ECObjects_1.SchemaMatchType.Latest);
+        if (undefined === schema)
+            return undefined;
+        return schema.getItemSync(schemaItemKey.name);
+    }
+    getSchemaItems() {
+        return this._knownSchemas.getSchemaItems();
+    }
+    /**
+     * Gets all the Schemas known by the context. This includes schemas added to the
+     * context using [[SchemaContext.addSchema]]. This does not include schemas that
+     * can be located by an ISchemaLocater instance added to the context.
+     * @returns An array of Schema objects.
+     */
+    getKnownSchemas() {
+        return this._knownSchemas.getAllSchemas();
+    }
+}
+exports.SchemaContext = SchemaContext;
 //# sourceMappingURL=Context.js.map

package/lib/cjs/DelayedPromise.d.ts

@@ -1,89 +1,89 @@
-/** @packageDocumentation
- * @module Utils
- */
-/**
- * Similar to a normal Promise, a DelayedPromise represents the eventual completion (or failure)
- * and resulting value of an asynchronous operation ***that has not yet started***.
- *
- * The asynchronous operation behind a DelayedPromise will start when any of the following occurs:
- *  - The DelayedPromise is `await`ed.
- *  - A callback is attached via `.then()` or `.catch(() => { })`.
- *  - The asynchronous operation is explicitly started via `.start()`
- *
- * Just as normal Promises will never return to their pending state once fulfilled or rejected,
- * a DelayedPromise will never re-execute its asynchronous operation more than **once**.
- *
- * Ultimately, a DelayedPromise is nothing more than some syntactic sugar that allows you to
- * represent an (asynchronously) lazily-loaded value as an instance property instead of a method.
- * You could also accomplish something similar by defining an async function as a property getter.
- * However, since a property defined as a DelayedPromise will not start simply by being accessed,
- * additional (non-lazily-loaded) "nested" properties can be added.
- *
- * [!alert text="*Remember:* Unlike regular Promises in JavaScript, DelayedPromises represent processes that **may not** already be happening." kind="warning"]
- * @beta
- */
-export declare class DelayedPromise<T> implements Promise<T> {
-    /**
-     * Constructs a DelayedPromise object.
-     * @param startCallback The asynchronous callback to execute when this DelayedPromise should be "started".
-     */
-    constructor(startCallback: () => Promise<T>);
-    readonly [Symbol.toStringTag]: "Promise";
-    /**
-     * Explicitly starts the asynchronous operation behind this DelayedPromise (if it hasn't started already).
-     */
-    start: () => Promise<T>;
-    /**
-     * Attaches callbacks for the resolution and/or rejection of the Promise.
-     * @param onfulfilled The callback to execute when the Promise is resolved.
-     * @param onrejected The callback to execute when the Promise is rejected.
-     * @return A Promise for the completion of which ever callback is executed.
-     */
-    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
-    /**
-     * Attaches a callback for only the rejection of the Promise.
-     * @param onrejected The callback to execute when the Promise is rejected.
-     * @return A Promise for the completion of the callback.
-     */
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
-    /**
-     * Attaches a callback for only the finally clause of the Promise.
-     * @param onrejected The callback to execute when the Promise is finalized.
-     * @return A Promise for the completion of the callback.
-     */
-    finally(onFinally?: (() => void) | undefined | null): Promise<T>;
-}
-/**
- * @beta
- */
-export interface NoDelayedPromiseMethods {
-    [propName: string]: any;
-    start?: never;
-    then?: never;
-    catch?: never;
-}
-/**
- * @beta
- */
-export interface DelayedPromiseWithPropsConstructor {
-    /**
-     * Constructs a DelayedPromiseWithProps object, which is at once both:
-     *  - A DelayedPromise object representing the eventual completion (or failure)
-     *    of an asynchronous operation returning a value of type `TPayload`
-     *  - _and_ a readonly "wrapper" around an instance of type `TProps`
-     *
-     * @param props An object with properties and methods that will be accessible
-     *              as if they were readonly properties of the DelayedPromiseWithProps object being constructed.
-     * @param startCallback The asynchronous callback to execute when as soon as this DelayedPromise should be "started".
-     */
-    new <TProps extends NoDelayedPromiseMethods, TPayload>(props: TProps, startCallback: () => Promise<TPayload>): Readonly<TProps> & DelayedPromise<TPayload>;
-}
-/**
- * @beta
- */
-export declare const DelayedPromiseWithProps: DelayedPromiseWithPropsConstructor;
-/** Define the type of a DelayedPromiseWithProps instance
- * @beta
- */
-export declare type DelayedPromiseWithProps<TProps, TPayload> = Readonly<TProps> & DelayedPromise<TPayload>;
+/** @packageDocumentation
+ * @module Utils
+ */
+/**
+ * Similar to a normal Promise, a DelayedPromise represents the eventual completion (or failure)
+ * and resulting value of an asynchronous operation ***that has not yet started***.
+ *
+ * The asynchronous operation behind a DelayedPromise will start when any of the following occurs:
+ *  - The DelayedPromise is `await`ed.
+ *  - A callback is attached via `.then()` or `.catch(() => { })`.
+ *  - The asynchronous operation is explicitly started via `.start()`
+ *
+ * Just as normal Promises will never return to their pending state once fulfilled or rejected,
+ * a DelayedPromise will never re-execute its asynchronous operation more than **once**.
+ *
+ * Ultimately, a DelayedPromise is nothing more than some syntactic sugar that allows you to
+ * represent an (asynchronously) lazily-loaded value as an instance property instead of a method.
+ * You could also accomplish something similar by defining an async function as a property getter.
+ * However, since a property defined as a DelayedPromise will not start simply by being accessed,
+ * additional (non-lazily-loaded) "nested" properties can be added.
+ *
+ * [!alert text="*Remember:* Unlike regular Promises in JavaScript, DelayedPromises represent processes that **may not** already be happening." kind="warning"]
+ * @beta
+ */
+export declare class DelayedPromise<T> implements Promise<T> {
+    /**
+     * Constructs a DelayedPromise object.
+     * @param startCallback The asynchronous callback to execute when this DelayedPromise should be "started".
+     */
+    constructor(startCallback: () => Promise<T>);
+    readonly [Symbol.toStringTag]: "Promise";
+    /**
+     * Explicitly starts the asynchronous operation behind this DelayedPromise (if it hasn't started already).
+     */
+    start: () => Promise<T>;
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @return A Promise for the completion of which ever callback is executed.
+     */
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @return A Promise for the completion of the callback.
+     */
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
+    /**
+     * Attaches a callback for only the finally clause of the Promise.
+     * @param onrejected The callback to execute when the Promise is finalized.
+     * @return A Promise for the completion of the callback.
+     */
+    finally(onFinally?: (() => void) | undefined | null): Promise<T>;
+}
+/**
+ * @beta
+ */
+export interface NoDelayedPromiseMethods {
+    [propName: string]: any;
+    start?: never;
+    then?: never;
+    catch?: never;
+}
+/**
+ * @beta
+ */
+export interface DelayedPromiseWithPropsConstructor {
+    /**
+     * Constructs a DelayedPromiseWithProps object, which is at once both:
+     *  - A DelayedPromise object representing the eventual completion (or failure)
+     *    of an asynchronous operation returning a value of type `TPayload`
+     *  - _and_ a readonly "wrapper" around an instance of type `TProps`
+     *
+     * @param props An object with properties and methods that will be accessible
+     *              as if they were readonly properties of the DelayedPromiseWithProps object being constructed.
+     * @param startCallback The asynchronous callback to execute when as soon as this DelayedPromise should be "started".
+     */
+    new <TProps extends NoDelayedPromiseMethods, TPayload>(props: TProps, startCallback: () => Promise<TPayload>): Readonly<TProps> & DelayedPromise<TPayload>;
+}
+/**
+ * @beta
+ */
+export declare const DelayedPromiseWithProps: DelayedPromiseWithPropsConstructor;
+/** Define the type of a DelayedPromiseWithProps instance
+ * @beta
+ */
+export declare type DelayedPromiseWithProps<TProps, TPayload> = Readonly<TProps> & DelayedPromise<TPayload>;
 //# sourceMappingURL=DelayedPromise.d.ts.map