@itwin/presentation-core-interop 2.0.0-alpha.3 → 2.0.0-alpha.5

package/lib/core-interop/Metadata.d.ts

@@ -1,16 +1,39 @@
-import { SchemaKey as CoreSchemaKey } from "@itwin/ecschema-metadata";
-import type { Schema as CoreSchema } from "@itwin/ecschema-metadata";
-import type { ECSchemaProvider } from "@itwin/presentation-shared";
+import { type EC, type ECSchemaProvider } from "@itwin/presentation-shared";
+import type { SchemaView as CoreSchemaView } from "@itwin/ecschema-metadata";
+import type { CoreECSqlReaderFactory } from "./QueryExecutor.js";
 /**
- * Defines input for `createECSchemaProvider`. Generally, this is an instance of [SchemaContext](https://www.itwinjs.org/reference/ecschema-metadata/context/schemacontext/)
- * class from `@itwin/ecschema-metadata` package.
+ * Subset of [SchemaView](https://www.itwinjs.org/reference/ecschema-metadata/context/schemaview/) API surface that
+ * is `@public` and can be used by `createECSchemaProvider` function.
+ *
  * @public
  */
-interface CoreSchemaContext {
-    getSchema(key: CoreSchemaKey): Promise<CoreSchema | undefined>;
-}
+type PublicCoreSchemaView = Pick<CoreSchemaView, "schemaToken" | "isOutdated" | "schemaCount" | "classCount" | "getSchema" | "getSchemaByAlias" | "getSchemas" | "findClass" | "findEnumeration" | "findKindOfQuantity" | "findPropertyCategory">;
+/**
+ * A function that optionally takes a list of schema names and returns a `SchemaView`, containing details about the
+ * requested schemas.
+ *
+ * If no schema names are provided, the function should return a `SchemaView` containing all available schemas.
+ *
+ * @public
+ */
+type CoreSchemaViewGetter = (props?: {
+    schemas?: string[];
+}) => Promise<PublicCoreSchemaView>;
+/**
+ * Accumulates schema names requested within the same frame and issues a single `getSchemaView` request for all of
+ * them in the next one, returning each caller the batch's result. Used both by `createECSchemaProvider` and by
+ * `createValueFormatter` (which resolves kind of quantity persistence units without needing the class hierarchy).
+ *
+ * @internal
+ */
+export declare function createBatchedSchemaViewGetter<TSchemaView>(imodel: {
+    getSchemaView: (props?: {
+        schemas?: string[];
+    }) => Promise<TSchemaView>;
+}): (schemaName: string) => Promise<TSchemaView>;
 /**
- * Creates an `ECSchemaProvider` for given [SchemaContext](https://www.itwinjs.org/reference/ecschema-metadata/context/schemacontext/).
+ * Creates an `ECSchemaProvider` for a given iModel with [SchemaView](https://www.itwinjs.org/reference/ecschema-metadata/context/schemaview/)
+ * getter and query reader factory.
  *
  * Usage example:
  *
@@ -19,12 +42,35 @@ interface CoreSchemaContext {
  * import { createECSchemaProvider } from "@itwin/presentation-core-interop";
  *
  * const imodel: IModelConnection = getIModel();
- * const schemaProvider = createECSchemaProvider(imodel.schemaContext);
+ * const schemaProvider = createECSchemaProvider(imodel);
  * // the created schema provider may be used in `@itwin/presentation-hierarchies` and other Presentation packages
  * ```
  *
  * @public
  */
-export declare function createECSchemaProvider(schemaContext: CoreSchemaContext): ECSchemaProvider;
+export declare function createECSchemaProvider(imodel: {
+    getSchemaView: CoreSchemaViewGetter;
+} & CoreECSqlReaderFactory): ECSchemaProvider;
+interface SchemaViewProviderContext {
+    schemaView: PublicCoreSchemaView;
+    classHierarchyResolver: ECClassHierarchyResolver;
+    schema: EC.Schema;
+    /** Shared cache of built `EC.Class` objects keyed by full class name, to avoid rebuilding them on every access. */
+    classCache: Map<string, EC.Class>;
+}
+export declare function createECSchemaFromSchemaView(svSchema: CoreSchemaView.Schema, context: Omit<SchemaViewProviderContext, "schema">): EC.Schema;
+export declare function createECClassFromSchemaView(svClass: CoreSchemaView.Class, context: SchemaViewProviderContext): EC.Class;
+export declare function createECPropertyFromSchemaView(svProp: CoreSchemaView.Property, ecClass: EC.Class, context: SchemaViewProviderContext): EC.Property;
+/** @internal */
+export interface ECClassHierarchyResolver {
+    /** Check if the derived class derives from the candidate base class. */
+    classDerivesFrom(derivedClassFullName: EC.FullClassNameDotNotation, candidateBaseClassFullName: EC.FullClassNameDotNotation): boolean;
+    /** Get names of all derived classes of the specified class. */
+    getDerivedClassNames(classFullName: EC.FullClassNameDotNotation, options?: {
+        onlyDirect?: boolean;
+    }): EC.FullClassNameDotNotation[];
+}
+/** @internal */
+export declare function createECClassHierarchyResolver(imodel: CoreECSqlReaderFactory): Promise<ECClassHierarchyResolver>;
 export {};
 //# sourceMappingURL=Metadata.d.ts.map

package/lib/core-interop/Metadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Metadata.d.ts","sourceRoot":"","sources":["../../src/core-interop/Metadata.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAGtE,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EAAM,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEvE;;;;GAIG;AACH,UAAU,iBAAiB;IACzB,SAAS,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC;CAChE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,iBAAiB,GAAG,gBAAgB,CAkCzF"}
+{"version":3,"file":"Metadata.d.ts","sourceRoot":"","sources":["../../src/core-interop/Metadata.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,EAAE,EAAE,KAAK,gBAAgB,EAA0B,MAAM,4BAA4B,CAAC;AAEpG,OAAO,KAAK,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC7E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAEjE;;;;;GAKG;AACH,KAAK,oBAAoB,GAAG,IAAI,CAC9B,cAAc,EACZ,aAAa,GACb,YAAY,GACZ,aAAa,GACb,YAAY,GACZ,WAAW,GACX,kBAAkB,GAClB,YAAY,GACZ,WAAW,GACX,iBAAiB,GACjB,oBAAoB,GACpB,sBAAsB,CACzB,CAAC;AAEF;;;;;;;GAOG;AACH,KAAK,oBAAoB,GAAG,CAAC,KAAK,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,KAAK,OAAO,CAAC,oBAAoB,CAAC,CAAC;AAE9F;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,WAAW,EAAE,MAAM,EAAE;IACjE,aAAa,EAAE,CAAC,KAAK,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;CACzE,GAAG,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,CAqB/C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE;IAAE,aAAa,EAAE,oBAAoB,CAAA;CAAE,GAAG,sBAAsB,GACvE,gBAAgB,CA6ElB;AAED,UAAU,yBAAyB;IACjC,UAAU,EAAE,oBAAoB,CAAC;IACjC,sBAAsB,EAAE,wBAAwB,CAAC;IACjD,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC;IAClB,mHAAmH;IACnH,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;CACnC;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,cAAc,CAAC,MAAM,EAC/B,OAAO,EAAE,IAAI,CAAC,yBAAyB,EAAE,QAAQ,CAAC,GACjD,EAAE,CAAC,MAAM,CAwBX;AAkBD,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,cAAc,CAAC,KAAK,EAC7B,OAAO,EAAE,yBAAyB,GACjC,EAAE,CAAC,KAAK,CA8EV;AAiDD,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,cAAc,CAAC,QAAQ,EAC/B,OAAO,EAAE,EAAE,CAAC,KAAK,EACjB,OAAO,EAAE,yBAAyB,GACjC,EAAE,CAAC,QAAQ,CAsIb;AAmED,gBAAgB;AAChB,MAAM,WAAW,wBAAwB;IACvC,wEAAwE;IACxE,gBAAgB,CACd,oBAAoB,EAAE,EAAE,CAAC,wBAAwB,EACjD,0BAA0B,EAAE,EAAE,CAAC,wBAAwB,GACtD,OAAO,CAAC;IACX,+DAA+D;IAC/D,oBAAoB,CAClB,aAAa,EAAE,EAAE,CAAC,wBAAwB,EAC1C,OAAO,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAE,GACjC,EAAE,CAAC,wBAAwB,EAAE,CAAC;CAClC;AAED,gBAAgB;AAChB,wBAAsB,8BAA8B,CAClD,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAAC,wBAAwB,CAAC,CAgEnC"}

package/lib/core-interop/Metadata.js

@@ -2,10 +2,31 @@
  * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
-import { SchemaKey as CoreSchemaKey } from "@itwin/ecschema-metadata";
-import { createECSchema } from "./MetadataInternal.js";
+import { bufferTime, filter, firstValueFrom, map, mergeMap, share, Subject } from "rxjs";
+import { SchemaViewPrimitiveType, StrengthDirection } from "@itwin/ecschema-metadata";
+import { normalizeFullClassName } from "@itwin/presentation-shared";
 /**
- * Creates an `ECSchemaProvider` for given [SchemaContext](https://www.itwinjs.org/reference/ecschema-metadata/context/schemacontext/).
+ * Accumulates schema names requested within the same frame and issues a single `getSchemaView` request for all of
+ * them in the next one, returning each caller the batch's result. Used both by `createECSchemaProvider` and by
+ * `createValueFormatter` (which resolves kind of quantity persistence units without needing the class hierarchy).
+ *
+ * @internal
+ */
+export function createBatchedSchemaViewGetter(imodel) {
+    const schemaNameSubject = new Subject();
+    const schemaViewBatches = schemaNameSubject.pipe(bufferTime(0), filter((schemaNames) => schemaNames.length > 0), mergeMap(async (schemaNames) => {
+        const schemas = new Set(schemaNames);
+        return { schemas, schemaView: await imodel.getSchemaView({ schemas: [...schemas] }) };
+    }), share());
+    return async function getSchemaView(schemaName) {
+        const schemaView = firstValueFrom(schemaViewBatches.pipe(filter((batch) => batch.schemas.has(schemaName)), map((batch) => batch.schemaView)));
+        schemaNameSubject.next(schemaName);
+        return schemaView;
+    };
+}
+/**
+ * Creates an `ECSchemaProvider` for a given iModel with [SchemaView](https://www.itwinjs.org/reference/ecschema-metadata/context/schemaview/)
+ * getter and query reader factory.
  *
  * Usage example:
  *
@@ -14,46 +35,474 @@ import { createECSchema } from "./MetadataInternal.js";
  * import { createECSchemaProvider } from "@itwin/presentation-core-interop";
  *
  * const imodel: IModelConnection = getIModel();
- * const schemaProvider = createECSchemaProvider(imodel.schemaContext);
+ * const schemaProvider = createECSchemaProvider(imodel);
  * // the created schema provider may be used in `@itwin/presentation-hierarchies` and other Presentation packages
  * ```
  *
  * @public
  */
-export function createECSchemaProvider(schemaContext) {
-    const schemaRequestsCache = new Map();
-    async function getSchemaUnprotected(schemaName) {
-        const coreSchema = await schemaContext.getSchema(new CoreSchemaKey(schemaName));
-        return coreSchema ? createECSchema(coreSchema) : undefined;
-    }
-    async function getSchemaProtected(schemaName, handledExistingSchemaErrors) {
-        // workaround for https://github.com/iTwin/itwinjs-core/issues/6542
-        try {
-            return await getSchemaUnprotected(schemaName);
+export function createECSchemaProvider(imodel) {
+    const getSchemaView = createBatchedSchemaViewGetter(imodel);
+    // Ensures we only create a single `ECClassHierarchyResolver` for the iModel, which is used to resolve derived classes for all schemas.
+    // Cache the promise (not the resolved value) so concurrent `getSchema` calls share one `createECClassHierarchyResolver` invocation.
+    let cachedClassHierarchyResolverPromise;
+    // Set once the resolver promise settles. Allows `classDerivesFrom` to answer synchronously after the hierarchy is loaded.
+    let cachedClassHierarchyResolver;
+    function getClassHierarchyResolver() {
+        if (cachedClassHierarchyResolver) {
+            return cachedClassHierarchyResolver;
         }
-        catch (e) {
-            /* v8 ignore else -- @preserve */
-            if (e instanceof Error) {
-                if (e.message.includes("already exists within this cache") && !handledExistingSchemaErrors.has(schemaName)) {
-                    handledExistingSchemaErrors.add(schemaName);
-                    return getSchemaProtected(schemaName, handledExistingSchemaErrors);
-                }
-                if (e.message.includes("schema not found")) {
-                    return undefined;
-                }
+        cachedClassHierarchyResolverPromise ??= createECClassHierarchyResolver(imodel).then((resolver) => {
+            cachedClassHierarchyResolver = resolver;
+            return resolver;
+        });
+        return cachedClassHierarchyResolverPromise;
+    }
+    async function getSchemaProviderContext(schemaName) {
+        const [classHierarchyResolver, schemaView] = await Promise.all([
+            getClassHierarchyResolver(),
+            getSchemaView(schemaName),
+        ]);
+        return { classHierarchyResolver, schemaView };
+    }
+    // Cache the resolved schema by name so repeated `getSchema`/`getClass` calls reuse it instead of issuing a new
+    // `getSchemaView` request each time. The cached promise doubles as an in-flight guard: concurrent
+    // first-time requests for the same schema share it (and its underlying `getSchemaView` request) instead of each
+    // building the schema. The entry is retained until the schema view it was built from is marked outdated by the host
+    // (a newer view has replaced it), at which point the next access refreshes it.
+    const schemaCache = new Map();
+    async function fetchSchema(name) {
+        // Cache built `EC.Class` objects (by full name) for this schema, so repeated accesses (e.g. the
+        // `EC.Property.class` getter, invoked once per grouped node) reuse a single class instead of rebuilding it from
+        // the schema view every time. Scoped to the fetch so a later refetch (when the view is outdated) starts fresh.
+        const classCache = new Map();
+        const entry = (async () => {
+            const { classHierarchyResolver, schemaView } = await getSchemaProviderContext(name);
+            const svSchema = schemaView.getSchema(name);
+            const schema = svSchema
+                ? createECSchemaFromSchemaView(svSchema, { schemaView, classHierarchyResolver, classCache })
+                : undefined;
+            return { schemaView, schema };
+        })();
+        schemaCache.set(name, entry);
+        // Drop rejected entries so a transient failure doesn't get cached permanently.
+        /* v8 ignore next 4 -- defensive cleanup for rejected cache entries while a newer entry may have already replaced this one */
+        entry.catch(() => {
+            if (schemaCache.get(name) === entry) {
+                schemaCache.delete(name);
             }
-            throw e;
-        }
+        });
+        return entry;
     }
     return {
         async getSchema(name) {
-            let promise = schemaRequestsCache.get(name);
-            if (!promise) {
-                promise = getSchemaProtected(name, new Set());
-                schemaRequestsCache.set(name, promise);
+            const cached = schemaCache.get(name);
+            const entry = await (cached ?? fetchSchema(name));
+            return entry.schemaView.isOutdated ? (await fetchSchema(name)).schema : entry.schema;
+        },
+        classDerivesFrom(derivedClassFullName, candidateBaseClassFullName) {
+            // A class always derives from itself. This matches the semantics of the deprecated `ECClassHierarchyInspector`.
+            if (derivedClassFullName === candidateBaseClassFullName) {
+                return true;
+            }
+            const resolver = getClassHierarchyResolver();
+            return resolver instanceof Promise
+                ? resolver.then((r) => r.classDerivesFrom(derivedClassFullName, candidateBaseClassFullName))
+                : resolver.classDerivesFrom(derivedClassFullName, candidateBaseClassFullName);
+        },
+    };
+}
+export function createECSchemaFromSchemaView(svSchema, context) {
+    const ecSchema = {
+        name: svSchema.name,
+        description: svSchema.description,
+        version: { read: svSchema.readVersion, write: svSchema.writeVersion, minor: svSchema.minorVersion },
+        isHidden: svSchema.isHidden,
+        getClass(name) {
+            const svClass = svSchema.getClass(name);
+            return svClass ? getECClassFromSchemaView(svClass, { ...context, schema: ecSchema }) : undefined;
+        },
+        getEnumeration(name) {
+            const svEnum = svSchema.getEnumeration(name);
+            return svEnum ? createECEnumerationFromSchemaView(svEnum, ecSchema) : undefined;
+        },
+        getKindOfQuantity(name) {
+            const svKoq = svSchema.getKindOfQuantity(name);
+            return svKoq ? createECKoqFromSchemaView(svKoq, ecSchema) : undefined;
+        },
+        getPropertyCategory(name) {
+            const svCategory = svSchema.getPropertyCategory(name);
+            return svCategory ? createECPropertyCategoryFromSchemaView(svCategory, ecSchema) : undefined;
+        },
+    };
+    return ecSchema;
+}
+/**
+ * Cache-aware entry point for building an `EC.Class` from a schema view class: returns a previously built class for
+ * the same full name, otherwise builds one via `createECClassFromSchemaView` and stores it in the context's cache.
+ */
+function getECClassFromSchemaView(svClass, context) {
+    // Key by the schema view's raw full name: it is a stable identifier for the class, so we avoid normalizing it on
+    // every (hot) cache hit. `createECClassFromSchemaView` normalizes once, on a miss, for the `EC.Class.fullName` field.
+    const cached = context.classCache.get(svClass.fullName);
+    if (cached) {
+        return cached;
+    }
+    const ecClass = createECClassFromSchemaView(svClass, context);
+    context.classCache.set(svClass.fullName, ecClass);
+    return ecClass;
+}
+export function createECClassFromSchemaView(svClass, context) {
+    const { classHierarchyResolver, schema } = context;
+    const fullName = normalizeFullClassName(svClass.fullName);
+    const ecClass = {
+        schema,
+        fullName,
+        name: svClass.name,
+        label: svClass.label,
+        description: svClass.description,
+        isHidden: svClass.isHidden,
+        isEntityClass() {
+            return svClass.isEntity();
+        },
+        isRelationshipClass() {
+            return svClass.isRelationship();
+        },
+        isStructClass() {
+            return svClass.isStruct();
+        },
+        isMixin() {
+            return svClass.isMixin();
+        },
+        get baseClass() {
+            return svClass.baseClass
+                ? getECClassFromSchemaView(svClass.baseClass, {
+                    ...context,
+                    schema: useOrCreateSchema(svClass.baseClass.schema, context),
+                })
+                : undefined;
+        },
+        is(classOrClassName, schemaName) {
+            if (typeof classOrClassName === "string") {
+                return svClass.is(`${schemaName}.${classOrClassName}`);
             }
-            return promise;
+            return svClass.is(classOrClassName.fullName);
+        },
+        getProperty(name) {
+            const svProp = svClass.getProperty(name);
+            return svProp ? createECPropertyFromSchemaView(svProp, ecClass, context) : undefined;
+        },
+        getProperties() {
+            return svClass.getProperties().map((p) => createECPropertyFromSchemaView(p, ecClass, context));
         },
+        getOwnProperties() {
+            return svClass.getOwnProperties().map((p) => createECPropertyFromSchemaView(p, ecClass, context));
+        },
+        getDerivedClassNames(props) {
+            return classHierarchyResolver.getDerivedClassNames(fullName, props);
+        },
+    };
+    if (svClass.isEntity()) {
+        const ecEntity = {
+            ...ecClass,
+            getMixins() {
+                return svClass.mixins.map((m) => getECClassFromSchemaView(m, { ...context, schema: useOrCreateSchema(m.schema, context) }));
+            },
+        };
+        return ecEntity;
+    }
+    if (svClass.isRelationship()) {
+        const ecRel = {
+            ...ecClass,
+            direction: svClass.strengthDirection === StrengthDirection.Forward ? "Forward" : "Backward",
+            source: svClass.source
+                ? createECRelConstraintFromSchemaView(svClass.source, context)
+                : createEmptyRelConstraint(),
+            target: svClass.target
+                ? createECRelConstraintFromSchemaView(svClass.target, context)
+                : createEmptyRelConstraint(),
+        };
+        return ecRel;
+    }
+    return ecClass;
+}
+function useOrCreateSchema(svSchema, context) {
+    const { schema: currentSchema, ...schemalessContext } = context;
+    if (svSchema.name === currentSchema.name) {
+        return currentSchema;
+    }
+    return createECSchemaFromSchemaView(svSchema, schemalessContext);
+}
+function createEmptyRelConstraint() {
+    return {
+        multiplicity: { lowerLimit: 0, upperLimit: 0 },
+        polymorphic: false,
+        constraintClasses: [],
+        abstractConstraint: undefined,
     };
 }
+function createECRelConstraintFromSchemaView(svConstraint, context) {
+    return {
+        multiplicity: {
+            lowerLimit: svConstraint.multiplicityLower,
+            // `SchemaView` reports an unbounded upper limit as `0`.
+            upperLimit: svConstraint.multiplicityUpper === 0 ? "unbounded" : svConstraint.multiplicityUpper,
+        },
+        polymorphic: svConstraint.polymorphic,
+        get constraintClasses() {
+            return svConstraint.constraintClasses.map((c) => getECClassFromSchemaView(c, { ...context, schema: useOrCreateSchema(c.schema, context) }));
+        },
+        get abstractConstraint() {
+            // `SchemaView` only exposes an explicitly-defined abstract constraint. To match EC semantics (and the
+            // standard `RelationshipConstraint` implementation), fall back to the sole constraint class when there's exactly one.
+            const svClass = svConstraint.abstractConstraint ??
+                (svConstraint.constraintClasses.length === 1 ? svConstraint.constraintClasses[0] : undefined);
+            if (!svClass) {
+                return undefined;
+            }
+            return getECClassFromSchemaView(svClass, { ...context, schema: useOrCreateSchema(svClass.schema, context) });
+        },
+    };
+}
+export function createECPropertyFromSchemaView(svProp, ecClass, context) {
+    const base = {
+        // `svProp.declaringClass` is the class that declared or contributed this property (a base class for an
+        // inherited property, or a mixin for a mixin-contributed one). It's `undefined` only for view properties,
+        // in which case we fall back to the class the property was enumerated from.
+        get class() {
+            return svProp.declaringClass
+                ? getECClassFromSchemaView(svProp.declaringClass, {
+                    ...context,
+                    schema: useOrCreateSchema(svProp.declaringClass.schema, context),
+                })
+                : ecClass;
+        },
+        name: svProp.name,
+        description: svProp.description,
+        label: svProp.label,
+        isHidden: svProp.isHidden,
+        get category() {
+            return svProp.category
+                ? createECPropertyCategoryFromSchemaView(svProp.category, useOrCreateSchema(svProp.category.schema, context))
+                : undefined;
+        },
+        isArray() {
+            return svProp.isArray();
+        },
+        isStruct() {
+            return false;
+        },
+        isPrimitive() {
+            return false;
+        },
+        isEnumeration() {
+            return false;
+        },
+        isNavigation() {
+            return false;
+        },
+    };
+    if (svProp.isNavigation()) {
+        return {
+            ...base,
+            isNavigation() {
+                return true;
+            },
+            get direction() {
+                return svProp.direction === StrengthDirection.Forward ? "Forward" : "Backward";
+            },
+            get relationshipClass() {
+                return getECClassFromSchemaView(svProp.relationshipClass, {
+                    ...context,
+                    schema: useOrCreateSchema(svProp.relationshipClass.schema, context),
+                });
+            },
+        };
+    }
+    // Check enumeration before primitive (enum is a facet of primitive in CoreSchemaView, but separate in EC)
+    if (svProp.isEnumeration()) {
+        const arrayFields = svProp.isArray()
+            ? { minOccurs: svProp.arrayMinOccurs ?? 0, maxOccurs: svProp.arrayMaxOccurs }
+            : undefined;
+        return {
+            ...base,
+            ...arrayFields,
+            isEnumeration() {
+                return true;
+            },
+            isArray() {
+                return svProp.isArray();
+            },
+            get extendedTypeName() {
+                return svProp.extendedTypeName;
+            },
+            get enumeration() {
+                return svProp.enumeration
+                    ? createECEnumerationFromSchemaView(svProp.enumeration, useOrCreateSchema(svProp.enumeration.schema, context))
+                    : undefined;
+            },
+        };
+    }
+    if (svProp.isPrimitive()) {
+        const arrayFields = svProp.isArray()
+            ? { minOccurs: svProp.arrayMinOccurs ?? 0, maxOccurs: svProp.arrayMaxOccurs }
+            : undefined;
+        return {
+            ...base,
+            ...arrayFields,
+            isPrimitive() {
+                return true;
+            },
+            isArray() {
+                return svProp.isArray();
+            },
+            get primitiveType() {
+                return mapSchemaViewPrimitiveType(svProp.primitiveType);
+            },
+            get extendedTypeName() {
+                return svProp.extendedTypeName;
+            },
+            get kindOfQuantity() {
+                return svProp.kindOfQuantity
+                    ? createECKoqFromSchemaView(svProp.kindOfQuantity, useOrCreateSchema(svProp.kindOfQuantity.schema, context))
+                    : undefined;
+            },
+        };
+    }
+    if (svProp.isStruct()) {
+        const arrayFields = svProp.isArray()
+            ? { minOccurs: svProp.arrayMinOccurs ?? 0, maxOccurs: svProp.arrayMaxOccurs }
+            : undefined;
+        return {
+            ...base,
+            ...arrayFields,
+            isStruct() {
+                return true;
+            },
+            isArray() {
+                return svProp.isArray();
+            },
+            get structClass() {
+                return getECClassFromSchemaView(svProp.structClass, {
+                    ...context,
+                    schema: useOrCreateSchema(svProp.structClass.schema, context),
+                });
+            },
+        };
+    }
+    throw new Error(`Unexpected property type for ${svProp.declaringClass ? svProp.declaringClass.fullName : "<ECCView>"}.${svProp.name}`);
+}
+function mapSchemaViewPrimitiveType(svType) {
+    switch (svType) {
+        case SchemaViewPrimitiveType.Binary:
+            return "Binary";
+        case SchemaViewPrimitiveType.Boolean:
+            return "Boolean";
+        case SchemaViewPrimitiveType.DateTime:
+            return "DateTime";
+        case SchemaViewPrimitiveType.Double:
+            return "Double";
+        case SchemaViewPrimitiveType.IGeometry:
+            return "IGeometry";
+        case SchemaViewPrimitiveType.Integer:
+            return "Integer";
+        case SchemaViewPrimitiveType.Long:
+            return "Long";
+        case SchemaViewPrimitiveType.Point2d:
+            return "Point2d";
+        case SchemaViewPrimitiveType.Point3d:
+            return "Point3d";
+        case SchemaViewPrimitiveType.String:
+            return "String";
+    }
+    throw new Error(`Uninitialized CoreSchemaView primitive type: ${svType}`);
+}
+function createECEnumerationFromSchemaView(svEnum, schema) {
+    return {
+        schema,
+        fullName: normalizeFullClassName(svEnum.fullName),
+        name: svEnum.name,
+        label: svEnum.label,
+        description: svEnum.description,
+        type: svEnum.primitiveType === SchemaViewPrimitiveType.Integer ? "Number" : "String",
+        isStrict: svEnum.isStrict,
+        enumerators: [...svEnum.getEnumerators()].map((e) => ({ name: e.name, label: e.label, value: e.value })),
+    };
+}
+function createECKoqFromSchemaView(svKoq, schema) {
+    return {
+        schema,
+        fullName: normalizeFullClassName(svKoq.fullName),
+        name: svKoq.name,
+        label: svKoq.label,
+        description: svKoq.description,
+        relativeError: svKoq.relativeError,
+        persistenceUnit: svKoq.persistenceUnit,
+    };
+}
+function createECPropertyCategoryFromSchemaView(svCategory, schema) {
+    return {
+        schema,
+        fullName: normalizeFullClassName(svCategory.fullName),
+        name: svCategory.name,
+        label: svCategory.label,
+        description: svCategory.description,
+        priority: svCategory.priority,
+    };
+}
+/** @internal */
+export async function createECClassHierarchyResolver(imodel) {
+    const baseToDerivedMap = new Map();
+    const derivedToBaseMap = new Map();
+    const ecsql = `
+    SELECT
+      ec_classname(rel.SourceECInstanceId, 's.c'),
+      ec_classname(rel.TargetECInstanceId, 's.c')
+    FROM meta.ClassHasBaseClasses rel
+  `;
+    const reader = imodel.createQueryReader(ecsql);
+    for await (const row of reader) {
+        const derivedClass = row[0];
+        const baseClass = row[1];
+        let baseToDerivedEntry = baseToDerivedMap.get(baseClass);
+        if (!baseToDerivedEntry) {
+            baseToDerivedEntry = new Set();
+            baseToDerivedMap.set(baseClass, baseToDerivedEntry);
+        }
+        baseToDerivedEntry.add(derivedClass);
+        let derivedToBaseEntry = derivedToBaseMap.get(derivedClass);
+        if (!derivedToBaseEntry) {
+            derivedToBaseEntry = new Set();
+            derivedToBaseMap.set(derivedClass, derivedToBaseEntry);
+        }
+        derivedToBaseEntry.add(baseClass);
+    }
+    /**
+     * TODO: We don't really need this in schema provider, but maybe this function should become part of it? Would allow us to drop
+     * ECClassHierarchyInspector, whose implementation currently has to load schemas (this one doesn't).
+     */
+    function classDerivesFrom(derivedClassFullName, candidateBaseClassFullName) {
+        const baseClasses = derivedToBaseMap.get(derivedClassFullName);
+        return baseClasses
+            ? baseClasses.has(candidateBaseClassFullName) ||
+                baseClasses.values().some((baseClass) => classDerivesFrom(baseClass, candidateBaseClassFullName))
+            : false;
+    }
+    function getDerivedClassNames(classFullName, options) {
+        const derivedClasses = baseToDerivedMap.get(classFullName);
+        if (!derivedClasses) {
+            return [];
+        }
+        if (options?.onlyDirect) {
+            return [...derivedClasses];
+        }
+        const allDerivedClasses = new Set();
+        for (const derivedClass of derivedClasses) {
+            allDerivedClasses.add(derivedClass);
+            getDerivedClassNames(derivedClass, options).forEach((subDerivedClass) => allDerivedClasses.add(subDerivedClass));
+        }
+        return Array.from(allDerivedClasses);
+    }
+    return { classDerivesFrom, getDerivedClassNames };
+}
 //# sourceMappingURL=Metadata.js.map