@itwin/ecschema-metadata 4.8.0-dev.3 → 4.8.0-dev.31

package/lib/esm/Constants.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @internal
+ */
+export declare class ECStringConstants {
+    static readonly RELATIONSHIP_END_SOURCE: string;
+    static readonly RELATIONSHIP_END_TARGET: string;
+    static readonly CONTAINERTYPE_SCHEMA: string;
+    static readonly CONTAINERTYPE_ENTITYCLASS: string;
+    static readonly CONTAINERTYPE_CUSTOMATTRIBUTECLASS: string;
+    static readonly CONTAINERTYPE_STRUCTCLASS: string;
+    static readonly CONTAINERTYPE_RELATIONSHIPCLASS: string;
+    static readonly CONTAINERTYPE_ANYCLASS: string;
+    static readonly CONTAINERTYPE_PRIMITIVEPROPERTY: string;
+    static readonly CONTAINERTYPE_STRUCTPROPERTY: string;
+    static readonly CONTAINERTYPE_PRIMITIVEARRAYPROPERTY: string;
+    static readonly CONTAINERTYPE_STRUCTARRAYPROPERTY: string;
+    static readonly CONTAINERTYPE_NAVIGATIONPROPERTY: string;
+    static readonly CONTAINERTYPE_ANYPROPERTY: string;
+    static readonly CONTAINERTYPE_SOURCERELATIONSHIPCONSTRAINT: string;
+    static readonly CONTAINERTYPE_TARGETRELATIONSHIPCONSTRAINT: string;
+    static readonly CONTAINERTYPE_ANYRELATIONSHIPCONSTRAINT: string;
+    static readonly CONTAINERTYPE_ANY: string;
+}
+//# sourceMappingURL=Constants.d.ts.map

package/lib/esm/Constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Constants.d.ts","sourceRoot":"","sources":["../../src/Constants.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,qBAAa,iBAAiB;IAE5B,gBAAuB,uBAAuB,EAAE,MAAM,CAAY;IAClE,gBAAuB,uBAAuB,EAAE,MAAM,CAAY;IAGlE,gBAAuB,oBAAoB,EAAE,MAAM,CAAY;IAC/D,gBAAuB,yBAAyB,EAAE,MAAM,CAAiB;IACzE,gBAAuB,kCAAkC,EAAE,MAAM,CAA0B;IAC3F,gBAAuB,yBAAyB,EAAE,MAAM,CAAiB;IACzE,gBAAuB,+BAA+B,EAAE,MAAM,CAAuB;IACrF,gBAAuB,sBAAsB,EAAE,MAAM,CAAc;IAEnE,gBAAuB,+BAA+B,EAAE,MAAM,CAAuB;IACrF,gBAAuB,4BAA4B,EAAE,MAAM,CAAoB;IAC/E,gBAAuB,oCAAoC,EAAE,MAAM,CAAmB;IACtF,gBAAuB,iCAAiC,EAAE,MAAM,CAAyB;IACzF,gBAAuB,gCAAgC,EAAE,MAAM,CAAwB;IACvF,gBAAuB,yBAAyB,EAAE,MAAM,CAAiB;IAEzE,gBAAuB,0CAA0C,EAAE,MAAM,CAAkC;IAC3G,gBAAuB,0CAA0C,EAAE,MAAM,CAAkC;IAC3G,gBAAuB,uCAAuC,EAAE,MAAM,CAA+B;IAErG,gBAAuB,iBAAiB,EAAE,MAAM,CAAS;CAC1D"}

package/lib/esm/Constants.js

@@ -0,0 +1,30 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/**
+ * @internal
+ */
+export class ECStringConstants {
+}
+// Relationship End
+ECStringConstants.RELATIONSHIP_END_SOURCE = "Source";
+ECStringConstants.RELATIONSHIP_END_TARGET = "Target";
+// Container Type
+ECStringConstants.CONTAINERTYPE_SCHEMA = "Schema";
+ECStringConstants.CONTAINERTYPE_ENTITYCLASS = "EntityClass";
+ECStringConstants.CONTAINERTYPE_CUSTOMATTRIBUTECLASS = "CustomAttributeClass";
+ECStringConstants.CONTAINERTYPE_STRUCTCLASS = "StructClass";
+ECStringConstants.CONTAINERTYPE_RELATIONSHIPCLASS = "RelationshipClass";
+ECStringConstants.CONTAINERTYPE_ANYCLASS = "AnyClass";
+ECStringConstants.CONTAINERTYPE_PRIMITIVEPROPERTY = "PrimitiveProperty";
+ECStringConstants.CONTAINERTYPE_STRUCTPROPERTY = "StructProperty";
+ECStringConstants.CONTAINERTYPE_PRIMITIVEARRAYPROPERTY = "ArrayProperty";
+ECStringConstants.CONTAINERTYPE_STRUCTARRAYPROPERTY = "StructArrayProperty";
+ECStringConstants.CONTAINERTYPE_NAVIGATIONPROPERTY = "NavigationProperty";
+ECStringConstants.CONTAINERTYPE_ANYPROPERTY = "AnyProperty";
+ECStringConstants.CONTAINERTYPE_SOURCERELATIONSHIPCONSTRAINT = "SourceRelationshipConstraint";
+ECStringConstants.CONTAINERTYPE_TARGETRELATIONSHIPCONSTRAINT = "TargetRelationshipConstraint";
+ECStringConstants.CONTAINERTYPE_ANYRELATIONSHIPCONSTRAINT = "AnyRelationshipConstraint";
+ECStringConstants.CONTAINERTYPE_ANY = "Any";
+//# sourceMappingURL=Constants.js.map

package/lib/esm/Constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Constants.js","sourceRoot":"","sources":["../../src/Constants.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAE/F;;GAEG;AACH,MAAM,OAAO,iBAAiB;;AAC5B,mBAAmB;AACI,yCAAuB,GAAW,QAAQ,CAAC;AAC3C,yCAAuB,GAAW,QAAQ,CAAC;AAElE,iBAAiB;AACM,sCAAoB,GAAW,QAAQ,CAAC;AACxC,2CAAyB,GAAW,aAAa,CAAC;AAClD,oDAAkC,GAAW,sBAAsB,CAAC;AACpE,2CAAyB,GAAW,aAAa,CAAC;AAClD,iDAA+B,GAAW,mBAAmB,CAAC;AAC9D,wCAAsB,GAAW,UAAU,CAAC;AAE5C,iDAA+B,GAAW,mBAAmB,CAAC;AAC9D,8CAA4B,GAAW,gBAAgB,CAAC;AACxD,sDAAoC,GAAW,eAAe,CAAC;AAC/D,mDAAiC,GAAW,qBAAqB,CAAC;AAClE,kDAAgC,GAAW,oBAAoB,CAAC;AAChE,2CAAyB,GAAW,aAAa,CAAC;AAElD,4DAA0C,GAAW,8BAA8B,CAAC;AACpF,4DAA0C,GAAW,8BAA8B,CAAC;AACpF,yDAAuC,GAAW,2BAA2B,CAAC;AAE9E,mCAAiB,GAAW,KAAK,CAAC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n\n/**\n * @internal\n */\nexport class ECStringConstants {\n  // Relationship End\n  public static readonly RELATIONSHIP_END_SOURCE: string = \"Source\";\n  public static readonly RELATIONSHIP_END_TARGET: string = \"Target\";\n\n  // Container Type\n  public static readonly CONTAINERTYPE_SCHEMA: string = \"Schema\";\n  public static readonly CONTAINERTYPE_ENTITYCLASS: string = \"EntityClass\";\n  public static readonly CONTAINERTYPE_CUSTOMATTRIBUTECLASS: string = \"CustomAttributeClass\";\n  public static readonly CONTAINERTYPE_STRUCTCLASS: string = \"StructClass\";\n  public static readonly CONTAINERTYPE_RELATIONSHIPCLASS: string = \"RelationshipClass\";\n  public static readonly CONTAINERTYPE_ANYCLASS: string = \"AnyClass\";\n\n  public static readonly CONTAINERTYPE_PRIMITIVEPROPERTY: string = \"PrimitiveProperty\";\n  public static readonly CONTAINERTYPE_STRUCTPROPERTY: string = \"StructProperty\";\n  public static readonly CONTAINERTYPE_PRIMITIVEARRAYPROPERTY: string = \"ArrayProperty\";\n  public static readonly CONTAINERTYPE_STRUCTARRAYPROPERTY: string = \"StructArrayProperty\";\n  public static readonly CONTAINERTYPE_NAVIGATIONPROPERTY: string = \"NavigationProperty\";\n  public static readonly CONTAINERTYPE_ANYPROPERTY: string = \"AnyProperty\";\n\n  public static readonly CONTAINERTYPE_SOURCERELATIONSHIPCONSTRAINT: string = \"SourceRelationshipConstraint\";\n  public static readonly CONTAINERTYPE_TARGETRELATIONSHIPCONSTRAINT: string = \"TargetRelationshipConstraint\";\n  public static readonly CONTAINERTYPE_ANYRELATIONSHIPCONSTRAINT: string = \"AnyRelationshipConstraint\";\n\n  public static readonly CONTAINERTYPE_ANY: string = \"Any\";\n}\n"]}

package/lib/esm/Context.d.ts

@@ -0,0 +1,219 @@
+import { SchemaMatchType } from "./ECObjects";
+import { SchemaInfo } from "./Interfaces";
+import { Schema } from "./Metadata/Schema";
+import { SchemaItem } from "./Metadata/SchemaItem";
+import { SchemaItemKey, SchemaKey } from "./SchemaKey";
+/**
+ * The interface defines what is needed to be an `ISchemaLocater`.
+ * A Schema Locater loads the requested schema if it can or returns undefined.
+ * Schema Locaters should always load the schema on each request and should not hold a cache of schemas.
+ * Schema locaters should never be used directly to load a schema, they should be added to a `SchemaContext`
+ * and the context should be used to load schemas.  The `SchemaContext` caches schemas and manages schema life time.
+ * @beta
+ */
+export interface ISchemaLocater {
+    /**
+     * Attempts to get a schema from the locater. Yields undefined if no matching schema is found.
+     * For schemas that may have references, construct and call through a SchemaContext instead.
+     * @param schemaKey key to look up
+     * @param matchType how to match key against candidate schemas
+     * @param context context for loading schema references
+     */
+    getSchema<T extends Schema>(schemaKey: Readonly<SchemaKey>, matchType: SchemaMatchType, context: SchemaContext): Promise<T | undefined>;
+    /**
+    * Gets the schema info which matches the provided SchemaKey.  The schema info may be returned before the schema is fully loaded.
+    * May return the entire Schema so long as it is completely loaded as it satisfies the SchemaInfo interface.
+    * @param schemaKey The SchemaKey describing the schema to get from the cache.
+    * @param matchType The match type to use when locating the schema
+    */
+    getSchemaInfo(schemaKey: Readonly<SchemaKey>, matchType: SchemaMatchType, context: SchemaContext): Promise<SchemaInfo | undefined>;
+    /**
+     * Attempts to get a schema from the locater. Yields undefined if no matching schema is found.
+     * For schemas that may have references, construct and call through a SchemaContext instead.
+     * @param schemaKey key to look up
+     * @param matchType how to match key against candidate schemas
+     * @param context context for loading schema references
+     */
+    getSchemaSync<T extends Schema>(schemaKey: Readonly<SchemaKey>, matchType: SchemaMatchType, context: SchemaContext): T | undefined;
+}
+/**
+ * @beta
+ */
+export interface ISchemaItemLocater {
+    getSchemaItem<T extends SchemaItem>(schemaItemKey: SchemaItemKey): Promise<T | undefined>;
+}
+/**
+ * @internal
+ */
+export declare class SchemaCache implements ISchemaLocater {
+    private _schema;
+    constructor();
+    get count(): number;
+    private loadedSchemaExists;
+    private schemaPromiseExists;
+    private findEntry;
+    private removeSchemaPromise;
+    private removeEntry;
+    /**
+     * Returns true if the schema exists in either the schema cache or the promise cache.  SchemaMatchType.Latest used.
+     * @param schemaKey The key to search for.
+     */
+    schemaExists(schemaKey: Readonly<SchemaKey>): boolean;
+    /**
+     * Adds a promise to load the schema to the cache. Does not allow for duplicate schemas in the cache of schemas or cache of promises, checks using SchemaMatchType.Latest.
+     * When the promise completes the schema will be added to the schema cache and the promise will be removed from the promise cache
+     * @param schemaInfo An object with the schema key for the schema being loaded and it's references
+     * @param schema The partially loaded schema that the promise will fulfill
+     * @param schemaPromise The schema promise to add to the cache.
+     */
+    addSchemaPromise(schemaInfo: SchemaInfo, schema: Schema, schemaPromise: Promise<Schema>): Promise<void>;
+    /**
+     * 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.
+     */
+    addSchema<T extends Schema>(schema: T): Promise<void>;
+    /**
+     * 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<T extends Schema>(schema: T): void;
+    /**
+     * 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
+     */
+    getSchema<T extends Schema>(schemaKey: Readonly<SchemaKey>, matchType?: SchemaMatchType): Promise<T | undefined>;
+    /**
+      * Gets the schema info which matches the provided SchemaKey.  The schema info may be returned before the schema is fully loaded.
+      * @param schemaKey The SchemaKey describing the schema to get from the cache.
+      * @param matchType The match type to use when locating the schema
+      */
+    getSchemaInfo(schemaKey: Readonly<SchemaKey>, matchType?: SchemaMatchType): Promise<SchemaInfo | undefined>;
+    /**
+     * Gets the schema which matches the provided SchemaKey.  If the schema is partially loaded an exception will be thrown.
+     * @param schemaKey The SchemaKey describing the schema to get from the cache.
+     * @param matchType The match type to use when locating the schema
+     */
+    getSchemaSync<T extends Schema>(schemaKey: Readonly<SchemaKey>, matchType?: SchemaMatchType): T | undefined;
+    /**
+     * Generator function that can iterate through each schema in _schema SchemaMap and items for each Schema.
+     * Does not include schema items from schemas that are not completely loaded yet.
+     */
+    getSchemaItems(): IterableIterator<SchemaItem>;
+    /**
+     * Gets all the schemas from the schema cache.
+     * Does not include schemas from schemas that are not completely loaded yet.
+     * @returns An array of Schema objects.
+     */
+    getAllSchemas(): Schema[];
+}
+/**
+ * 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
+ */
+export declare class SchemaContext implements ISchemaItemLocater {
+    private _locaters;
+    private _knownSchemas;
+    constructor();
+    addLocater(locater: ISchemaLocater): void;
+    /**
+     * Adds the schema to this context.  Use addSchemaPromise instead when asynchronously loading schemas.
+     * @param schema The schema to add to this context
+     */
+    addSchema(schema: Schema): Promise<void>;
+    /**
+     * Adds the schema to this context
+     * @param schema The schema to add to this context
+     */
+    addSchemaSync(schema: Schema): void;
+    /**
+     * 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
+     * @deprecated in 4.0 use ecschema-editing package
+     */
+    addSchemaItem(schemaItem: SchemaItem): Promise<void>;
+    /**
+     * Returns true if the schema is already in the context.  SchemaMatchType.Latest is used to find a match.
+     * @param schemaKey
+     */
+    schemaExists(schemaKey: Readonly<SchemaKey>): boolean;
+    /**
+     * Adds a promise to load the schema to the cache. Does not allow for duplicate schemas in the cache of schemas or cache of promises, checks using SchemaMatchType.Latest.
+     * When the promise completes the schema will be added to the schema cache and the promise will be removed from the promise cache.
+     * Use this method over addSchema when asynchronously loading schemas
+     * @param schemaInfo An object with the schema key for the schema being loaded and it's references
+     * @param schema The partially loaded schema that the promise will fulfill
+     * @param schemaPromise The schema promise to add to the cache.
+     */
+    addSchemaPromise(schemaInfo: SchemaInfo, schema: Schema, schemaPromise: Promise<Schema>): Promise<void>;
+    /** Attempts to obtain a schema from this context that matches the specified criteria.
+     * @param schemaKey Identifies the schema to obtain.
+     * @param matchType Criteria by which to identify potentially matching schemas.
+     * @returns the schema matching the input criteria, or `undefined` if no such schema could be located.
+     */
+    getSchema<T extends Schema>(schemaKey: Readonly<SchemaKey>, matchType?: SchemaMatchType): Promise<T | undefined>;
+    /**
+     * Gets the schema info which matches the provided SchemaKey.  The schema info may be returned before the schema is fully loaded.
+     * The fully loaded schema can be gotten later from the context using [[getSchema]].
+     * @param schemaKey The SchemaKey describing the schema to get from the cache.
+     * @param matchType The match type to use when locating the schema
+     */
+    getSchemaInfo(schemaKey: Readonly<SchemaKey>, matchType: SchemaMatchType): Promise<SchemaInfo | undefined>;
+    /** Attempts to obtain a schema from this context that matches the specified criteria.
+     * Will return undefined if the schema is partially loaded.  Use [[getSchema]] to await until the schema is completely loaded.
+     * @param schemaKey Identifies the schema to obtain.
+     * @param matchType Criteria by which to identify potentially matching schemas.
+     * @returns the schema matching the input criteria, or `undefined` if no such schema could be located.
+     */
+    getSchemaSync<T extends Schema>(schemaKey: SchemaKey, matchType?: SchemaMatchType): T | undefined;
+    /**
+     * Attempts to get a Schema from the context's cache.
+     * Will await a partially loaded schema then return when it is completely loaded.
+     * @param schemaKey The SchemaKey to identify the Schema.
+     * @param matchType The SchemaMatch type to use. Default is SchemaMatchType.Latest.
+     * @internal
+     */
+    getCachedSchema<T extends Schema>(schemaKey: Readonly<SchemaKey>, matchType?: SchemaMatchType): Promise<T | undefined>;
+    /**
+     * Attempts to get a Schema from the context's cache.
+     * Will return undefined if the cached schema is partially loaded.  Use [[getCachedSchema]] to await until the schema is completely loaded.
+     * @param schemaKey The SchemaKey to identify the Schema.
+     * @param matchType The SchemaMatch type to use. Default is SchemaMatchType.Latest.
+     * @internal
+     */
+    getCachedSchemaSync<T extends Schema>(schemaKey: Readonly<SchemaKey>, matchType?: SchemaMatchType): T | undefined;
+    /**
+     * Gets the schema item from the specified schema if it exists in this [[SchemaContext]].
+     * Will await a partially loaded schema then look in it for the requested item
+     * @param schemaItemKey The SchemaItemKey identifying the item to return.  SchemaMatchType.Latest is used to match the schema.
+     * @returns The requested schema item
+     */
+    getSchemaItem<T extends SchemaItem>(schemaItemKey: SchemaItemKey): Promise<T | undefined>;
+    /**
+     * Gets the schema item from the specified schema if it exists in this [[SchemaContext]].
+     * Will skip a partially loaded schema and return undefined if the item belongs to that schema.  Use the async method to await partially loaded schemas.
+     * @param schemaItemKey The SchemaItemKey identifying the item to return.  SchemaMatchType.Latest is used to match the schema.
+     * @returns The requested schema item
+     */
+    getSchemaItemSync<T extends SchemaItem>(schemaItemKey: SchemaItemKey): T | undefined;
+    /**
+     * Iterates through the items of each schema known to 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.
+     * Does not include schema items from schemas that are not completely loaded yet.
+     */
+    getSchemaItems(): IterableIterator<SchemaItem>;
+    /**
+     * 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.  Does not
+     * include schemas that are partially loaded.
+     * @returns An array of Schema objects.
+     */
+    getKnownSchemas(): Schema[];
+}
+//# sourceMappingURL=Context.d.ts.map

package/lib/esm/Context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Context.d.ts","sourceRoot":"","sources":["../../src/Context.ts"],"names":[],"mappings":"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"}

package/lib/esm/Context.js

@@ -0,0 +1,321 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import { SchemaMatchType } from "./ECObjects";
+import { ECObjectsError, ECObjectsStatus } from "./Exception";
+/**
+ * @internal
+ */
+class SchemaMap extends Array {
+}
+/**
+ * @internal
+ */
+export class SchemaCache {
+    constructor() {
+        this._schema = new SchemaMap();
+    }
+    get count() { return this._schema.length; }
+    loadedSchemaExists(schemaKey) {
+        return undefined !== this._schema.find((entry) => entry.schemaInfo.schemaKey.matches(schemaKey, SchemaMatchType.Latest) && !entry.schemaPromise);
+    }
+    schemaPromiseExists(schemaKey) {
+        return undefined !== this._schema.find((entry) => entry.schemaInfo.schemaKey.matches(schemaKey, SchemaMatchType.Latest) && undefined !== entry.schemaPromise);
+    }
+    findEntry(schemaKey, matchType) {
+        return this._schema.find((entry) => entry.schemaInfo.schemaKey.matches(schemaKey, matchType));
+    }
+    removeSchemaPromise(schemaKey) {
+        const entry = this.findEntry(schemaKey, SchemaMatchType.Latest);
+        if (entry)
+            entry.schemaPromise = undefined;
+    }
+    removeEntry(schemaKey) {
+        this._schema = this._schema.filter((entry) => !entry.schemaInfo.schemaKey.matches(schemaKey));
+    }
+    /**
+     * Returns true if the schema exists in either the schema cache or the promise cache.  SchemaMatchType.Latest used.
+     * @param schemaKey The key to search for.
+     */
+    schemaExists(schemaKey) {
+        return this.loadedSchemaExists(schemaKey) || this.schemaPromiseExists(schemaKey);
+    }
+    /**
+     * Adds a promise to load the schema to the cache. Does not allow for duplicate schemas in the cache of schemas or cache of promises, checks using SchemaMatchType.Latest.
+     * When the promise completes the schema will be added to the schema cache and the promise will be removed from the promise cache
+     * @param schemaInfo An object with the schema key for the schema being loaded and it's references
+     * @param schema The partially loaded schema that the promise will fulfill
+     * @param schemaPromise The schema promise to add to the cache.
+     */
+    async addSchemaPromise(schemaInfo, schema, schemaPromise) {
+        if (this.schemaExists(schemaInfo.schemaKey))
+            throw new ECObjectsError(ECObjectsStatus.DuplicateSchema, `The schema, ${schemaInfo.schemaKey.toString()}, already exists within this cache.`);
+        this._schema.push({ schemaInfo, schema, schemaPromise });
+        // This promise is cached and will be awaited when the user requests the full schema.
+        // If the promise competes successfully before the user requests the schema it will be removed from the cache
+        // If it fails it will remain in the cache until the user awaits it and handles the error
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        schemaPromise.then(() => {
+            this.removeSchemaPromise(schemaInfo.schemaKey);
+        });
+    }
+    /**
+     * 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 (this.schemaExists(schema.schemaKey))
+            throw new ECObjectsError(ECObjectsStatus.DuplicateSchema, `The schema, ${schema.schemaKey.toString()}, already exists within this cache.`);
+        this._schema.push({ schemaInfo: schema, 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.schemaExists(schema.schemaKey))
+            throw new ECObjectsError(ECObjectsStatus.DuplicateSchema, `The schema, ${schema.schemaKey.toString()}, already exists within this cache.`);
+        this._schema.push({ schemaInfo: schema, 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 = SchemaMatchType.Latest) {
+        if (this.count === 0)
+            return undefined;
+        const entry = this.findEntry(schemaKey, matchType);
+        if (!entry)
+            return undefined;
+        if (entry.schemaPromise) {
+            try {
+                const schema = await entry.schemaPromise;
+                return schema;
+            }
+            catch (e) {
+                this.removeEntry(schemaKey);
+                throw e;
+            }
+        }
+        return entry.schema;
+    }
+    /**
+      * Gets the schema info which matches the provided SchemaKey.  The schema info may be returned before the schema is fully loaded.
+      * @param schemaKey The SchemaKey describing the schema to get from the cache.
+      * @param matchType The match type to use when locating the schema
+      */
+    async getSchemaInfo(schemaKey, matchType = SchemaMatchType.Latest) {
+        if (this.count === 0)
+            return undefined;
+        const entry = this.findEntry(schemaKey, matchType);
+        if (entry)
+            return entry.schemaInfo;
+        return undefined;
+    }
+    /**
+     * Gets the schema which matches the provided SchemaKey.  If the schema is partially loaded an exception will be thrown.
+     * @param schemaKey The SchemaKey describing the schema to get from the cache.
+     * @param matchType The match type to use when locating the schema
+     */
+    getSchemaSync(schemaKey, matchType = SchemaMatchType.Latest) {
+        if (this.count === 0)
+            return undefined;
+        const entry = this.findEntry(schemaKey, matchType);
+        if (entry) {
+            if (entry.schemaPromise) {
+                throw new ECObjectsError(ECObjectsStatus.UnableToLoadSchema, `The Schema ${schemaKey.toString()} is partially loaded so cannot be loaded synchronously.`);
+            }
+            return entry.schema;
+        }
+        return undefined;
+    }
+    /**
+     * Generator function that can iterate through each schema in _schema SchemaMap and items for each Schema.
+     * Does not include schema items from schemas that are not completely loaded yet.
+     */
+    *getSchemaItems() {
+        for (const entry of this._schema) {
+            for (const schemaItem of entry.schema.getItems()) {
+                yield schemaItem;
+            }
+        }
+    }
+    /**
+     * Gets all the schemas from the schema cache.
+     * Does not include schemas from schemas that are not completely loaded yet.
+     * @returns An array of Schema objects.
+     */
+    getAllSchemas() {
+        return this._schema.map((entry) => entry.schema);
+    }
+}
+/**
+ * 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
+ */
+export 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.  Use addSchemaPromise instead when asynchronously loading schemas.
+     * @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
+     * @deprecated in 4.0 use ecschema-editing package
+     */
+    async addSchemaItem(schemaItem) {
+        const schema = await this.getSchema(schemaItem.key.schemaKey, SchemaMatchType.Exact);
+        if (!schema)
+            throw new ECObjectsError(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);
+    }
+    /**
+     * Returns true if the schema is already in the context.  SchemaMatchType.Latest is used to find a match.
+     * @param schemaKey
+     */
+    schemaExists(schemaKey) {
+        return this._knownSchemas.schemaExists(schemaKey);
+    }
+    /**
+     * Adds a promise to load the schema to the cache. Does not allow for duplicate schemas in the cache of schemas or cache of promises, checks using SchemaMatchType.Latest.
+     * When the promise completes the schema will be added to the schema cache and the promise will be removed from the promise cache.
+     * Use this method over addSchema when asynchronously loading schemas
+     * @param schemaInfo An object with the schema key for the schema being loaded and it's references
+     * @param schema The partially loaded schema that the promise will fulfill
+     * @param schemaPromise The schema promise to add to the cache.
+     */
+    async addSchemaPromise(schemaInfo, schema, schemaPromise) {
+        return this._knownSchemas.addSchemaPromise(schemaInfo, schema, schemaPromise);
+    }
+    /** Attempts to obtain a schema from this context that matches the specified criteria.
+     * @param schemaKey Identifies the schema to obtain.
+     * @param matchType Criteria by which to identify potentially matching schemas.
+     * @returns the schema matching the input criteria, or `undefined` if no such schema could be located.
+     */
+    async getSchema(schemaKey, matchType = 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;
+    }
+    /**
+     * Gets the schema info which matches the provided SchemaKey.  The schema info may be returned before the schema is fully loaded.
+     * The fully loaded schema can be gotten later from the context using [[getSchema]].
+     * @param schemaKey The SchemaKey describing the schema to get from the cache.
+     * @param matchType The match type to use when locating the schema
+     */
+    async getSchemaInfo(schemaKey, matchType) {
+        for (const locater of this._locaters) {
+            const schemaInfo = await locater.getSchemaInfo(schemaKey, matchType, this);
+            if (undefined !== schemaInfo)
+                return schemaInfo;
+        }
+        return undefined;
+    }
+    /** Attempts to obtain a schema from this context that matches the specified criteria.
+     * Will return undefined if the schema is partially loaded.  Use [[getSchema]] to await until the schema is completely loaded.
+     * @param schemaKey Identifies the schema to obtain.
+     * @param matchType Criteria by which to identify potentially matching schemas.
+     * @returns the schema matching the input criteria, or `undefined` if no such schema could be located.
+     */
+    getSchemaSync(schemaKey, matchType = 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.
+     * Will await a partially loaded schema then return when it is completely loaded.
+     * @param schemaKey The SchemaKey to identify the Schema.
+     * @param matchType The SchemaMatch type to use. Default is SchemaMatchType.Latest.
+     * @internal
+     */
+    async getCachedSchema(schemaKey, matchType = SchemaMatchType.Latest) {
+        return this._knownSchemas.getSchema(schemaKey, matchType);
+    }
+    /**
+     * Attempts to get a Schema from the context's cache.
+     * Will return undefined if the cached schema is partially loaded.  Use [[getCachedSchema]] to await until the schema is completely loaded.
+     * @param schemaKey The SchemaKey to identify the Schema.
+     * @param matchType The SchemaMatch type to use. Default is SchemaMatchType.Latest.
+     * @internal
+     */
+    getCachedSchemaSync(schemaKey, matchType = SchemaMatchType.Latest) {
+        return this._knownSchemas.getSchemaSync(schemaKey, matchType);
+    }
+    /**
+     * Gets the schema item from the specified schema if it exists in this [[SchemaContext]].
+     * Will await a partially loaded schema then look in it for the requested item
+     * @param schemaItemKey The SchemaItemKey identifying the item to return.  SchemaMatchType.Latest is used to match the schema.
+     * @returns The requested schema item
+     */
+    async getSchemaItem(schemaItemKey) {
+        const schema = await this.getSchema(schemaItemKey.schemaKey, SchemaMatchType.Latest);
+        if (undefined === schema)
+            return undefined;
+        return schema.getItem(schemaItemKey.name);
+    }
+    /**
+     * Gets the schema item from the specified schema if it exists in this [[SchemaContext]].
+     * Will skip a partially loaded schema and return undefined if the item belongs to that schema.  Use the async method to await partially loaded schemas.
+     * @param schemaItemKey The SchemaItemKey identifying the item to return.  SchemaMatchType.Latest is used to match the schema.
+     * @returns The requested schema item
+     */
+    getSchemaItemSync(schemaItemKey) {
+        const schema = this.getSchemaSync(schemaItemKey.schemaKey, SchemaMatchType.Latest);
+        if (undefined === schema)
+            return undefined;
+        return schema.getItemSync(schemaItemKey.name);
+    }
+    /**
+     * Iterates through the items of each schema known to 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.
+     * Does not include schema items from schemas that are not completely loaded yet.
+     */
+    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.  Does not
+     * include schemas that are partially loaded.
+     * @returns An array of Schema objects.
+     */
+    getKnownSchemas() {
+        return this._knownSchemas.getAllSchemas();
+    }
+}
+//# sourceMappingURL=Context.js.map