@itwin/presentation-core-interop 0.1.2 → 0.2.1

package/src/core-interop/Formatting.ts

@@ -1,194 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
- * See LICENSE.md in the project root for license terms and full copyright notice.
- *--------------------------------------------------------------------------------------------*/
-
-import { FormatProps, FormatterSpec, Format as QuantityFormat, UnitsProvider, UnitSystemKey } from "@itwin/core-quantity";
-import {
-  Format,
-  InvertedUnit,
-  KindOfQuantity,
-  OverrideFormat,
-  SchemaContext,
-  SchemaKey,
-  SchemaMatchType,
-  SchemaUnitProvider,
-  Unit,
-} from "@itwin/ecschema-metadata";
-import { createDefaultValueFormatter, IPrimitiveValueFormatter, parseFullClassName, TypedPrimitiveValue } from "@itwin/presentation-shared";
-
-/**
- * Props for `createValueFormatter` function.
- */
-interface CreateValueFormatterProps {
-  /**
-   * An instance of [SchemaContext](https://www.itwinjs.org/reference/ecschema-metadata/context/schemacontext/) for
-   * getting units information.
-   */
-  schemaContext: SchemaContext;
-
-  /**
-   * An optional unit system to use for formatting property values. If not provided, default presentation units are used. If a property
-   * doesn't have a default presentation unit, then persistence unit is used. Finally, if a property doesn't have a unit assigned at all,
-   * `baseFormatter` is used to format the property value.
-   */
-  unitSystem?: UnitSystemKey;
-
-  /**
-   * Base primitive value formatter for cases when a property doesn't have any units' information. Defaults to the result of `createDefaultValueFormatter`
-   * from `@itwin/presentation-hierarchies` package.
-   */
-  baseFormatter?: IPrimitiveValueFormatter;
-}
-
-/**
- * Creates an instance of `IPrimitiveValueFormatter` that knows how to format values of properties with assigned kind of quantity. In
- * case the property does not have an assigned kind of quantity, the base formatter is used.
- *
- * Usage example:
- *
- * ```ts
- * import { SchemaContext } from "@itwin/ecschema-metadata";
- * import { createValueFormatter } from "@itwin/presentation-core-interop";
- *
- * const schemaContext = new SchemaContext();
- * const formatter = createValueFormatter({ schemaContext, unitSystem: "metric" });
- * const formattedValue = await formatter({ type: "Double", value: 1.234, koqName: "MySchema.LengthKindOfQuantity" });
- * ```
- *
- * @beta
- */
-export function createValueFormatter(props: CreateValueFormatterProps): IPrimitiveValueFormatter {
-  const { schemaContext, unitSystem } = props;
-  const baseFormatter = props.baseFormatter ?? /* istanbul ignore next */ createDefaultValueFormatter();
-  const unitsProvider = new SchemaUnitProvider(schemaContext);
-  return async function (value: TypedPrimitiveValue): Promise<string> {
-    if (value.type === "Double" && !!value.koqName) {
-      const koq = await getKindOfQuantity(schemaContext, value.koqName);
-      const spec = await getFormatterSpec(unitsProvider, koq, unitSystem);
-      if (spec) {
-        return spec.applyFormatting(value.value);
-      }
-    }
-    return baseFormatter(value);
-  };
-}
-
-async function getKindOfQuantity(schemas: SchemaContext, fullName: string) {
-  const { schemaName, className: koqName } = parseFullClassName(fullName);
-  const schema = await schemas.getSchema(new SchemaKey(schemaName), SchemaMatchType.Latest);
-  if (!schema) {
-    throw new Error(`Invalid schema "${schemaName}" specified in KoQ full name "${fullName}"`);
-  }
-  const koq = await schema.getItem<KindOfQuantity>(koqName);
-  if (!koq) {
-    throw new Error(`Invalid kind of quantity "${koqName}" specified in KoQ full name "${fullName}" - it does not exist in schema "${schemaName}"`);
-  }
-  return koq;
-}
-
-async function getFormatterSpec(unitsProvider: UnitsProvider, koq: KindOfQuantity, unitSystem?: UnitSystemKey) {
-  const formattingProps = await getFormattingProps(koq, unitSystem);
-  if (!formattingProps) {
-    return undefined;
-  }
-  const { formatProps, persistenceUnitName } = formattingProps;
-  const persistenceUnit = await unitsProvider.findUnitByName(persistenceUnitName);
-  const format = await QuantityFormat.createFromJSON("", unitsProvider, formatProps);
-  return FormatterSpec.create("", format, unitsProvider, persistenceUnit);
-}
-
-interface FormattingProps {
-  formatProps: FormatProps;
-  persistenceUnitName: string;
-}
-
-async function getFormattingProps(koq: KindOfQuantity, unitSystem?: UnitSystemKey): Promise<FormattingProps | undefined> {
-  const persistenceUnit = await koq.persistenceUnit;
-  // istanbul ignore if
-  if (!persistenceUnit) {
-    return undefined;
-  }
-  const formatProps = await getKoqFormatProps(koq, persistenceUnit, unitSystem);
-  if (!formatProps) {
-    return undefined;
-  }
-  return { formatProps, persistenceUnitName: persistenceUnit.fullName };
-}
-
-async function getKoqFormatProps(koq: KindOfQuantity, persistenceUnit: Unit | InvertedUnit, unitSystem?: UnitSystemKey) {
-  const unitSystems = getUnitSystemGroupNames(unitSystem);
-  // use one of KOQ presentation format that matches requested unit system
-  const presentationFormat = await getKoqPresentationFormat(koq, unitSystems);
-  if (presentationFormat) {
-    return getFormatProps(presentationFormat);
-  }
-
-  // use persistence unit format if it matches requested unit system and matching presentation format was not found
-  const persistenceUnitSystem = await persistenceUnit.unitSystem;
-  if (persistenceUnitSystem && unitSystems.includes(persistenceUnitSystem.name.toUpperCase())) {
-    return getPersistenceUnitFormatProps(persistenceUnit);
-  }
-
-  // use default presentation format if persistence unit does not match requested unit system
-  if (koq.defaultPresentationFormat) {
-    return getFormatProps(koq.defaultPresentationFormat);
-  }
-
-  return undefined;
-}
-
-async function getKoqPresentationFormat(koq: KindOfQuantity, unitSystems: string[]) {
-  const presentationFormats = koq.presentationFormats;
-  for (const system of unitSystems) {
-    for (const format of presentationFormats) {
-      const unit = format.units && format.units[0][0];
-      // istanbul ignore if
-      if (!unit) {
-        continue;
-      }
-      const currentUnitSystem = await unit.unitSystem;
-      if (currentUnitSystem && currentUnitSystem.name.toUpperCase() === system) {
-        return format;
-      }
-    }
-  }
-  return undefined;
-}
-
-function getFormatProps(format: Format | OverrideFormat): FormatProps {
-  return format instanceof OverrideFormat ? format.getFormatProps() : format.toJSON();
-}
-
-function getPersistenceUnitFormatProps(persistenceUnit: Unit | InvertedUnit): FormatProps {
-  // Same as Format "DefaultRealU" in Formats ecschema
-  return {
-    formatTraits: ["keepSingleZero", "keepDecimalPoint", "showUnitLabel"],
-    precision: 6,
-    type: "Decimal",
-    uomSeparator: " ",
-    decimalSeparator: ".",
-    composite: {
-      units: [
-        {
-          name: persistenceUnit.fullName,
-          label: persistenceUnit.label,
-        },
-      ],
-    },
-  };
-}
-
-function getUnitSystemGroupNames(unitSystem?: UnitSystemKey) {
-  switch (unitSystem) {
-    case "imperial":
-      return ["IMPERIAL", "USCUSTOM", "INTERNATIONAL", "FINANCE"];
-    case "metric":
-      return ["SI", "METRIC", "INTERNATIONAL", "FINANCE"];
-    case "usCustomary":
-      return ["USCUSTOM", "INTERNATIONAL", "FINANCE"];
-    case "usSurvey":
-      return ["USSURVEY", "USCUSTOM", "INTERNATIONAL", "FINANCE"];
-  }
-  return [];
-}

package/src/core-interop/Logging.ts

@@ -1,58 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
- * See LICENSE.md in the project root for license terms and full copyright notice.
- *--------------------------------------------------------------------------------------------*/
-
-import { LogLevel as CoreLogLevel } from "@itwin/core-bentley";
-import { ILogger, LogLevel } from "@itwin/presentation-shared";
-
-/**
- * Defines input for `createLogger`. Generally, this is the [Logger](https://www.itwinjs.org/reference/core-bentley/logging/logger/)
- * class from `@itwin/core-bentley` package.
- */
-interface ICoreLogger {
-  isEnabled(category: string, level: CoreLogLevel): boolean;
-  logError(category: string, message: string): void;
-  logWarning(category: string, message: string): void;
-  logInfo(category: string, message: string): void;
-  logTrace(category: string, message: string): void;
-}
-
-/**
- * Creates a presentation `ILogger` instance that forwards all logging calls to the
- * [Logger](https://www.itwinjs.org/reference/core-bentley/logging/logger/) API.
- *
- * Usage example:
- *
- * ```ts
- * import { Logger } from "@itwin/core-bentley";
- * import { createLogger } from "@itwin/presentation-core-interop";
- * import { setLogger } from "@itwin/presentation-hierarchies";
- *
- * setLogger(createLogger(Logger));
- * ```
- *
- * @beta
- */
-export function createLogger(coreLogger: ICoreLogger): ILogger {
-  return {
-    isEnabled: (category, level) => coreLogger.isEnabled(category, getCoreLogLevel(level)),
-    logError: (category, msg) => coreLogger.logError(category, msg),
-    logWarning: (category, msg) => coreLogger.logWarning(category, msg),
-    logInfo: (category, msg) => coreLogger.logInfo(category, msg),
-    logTrace: (category, msg) => coreLogger.logTrace(category, msg),
-  };
-}
-
-function getCoreLogLevel(level: LogLevel): CoreLogLevel {
-  switch (level) {
-    case "error":
-      return CoreLogLevel.Error;
-    case "warning":
-      return CoreLogLevel.Warning;
-    case "info":
-      return CoreLogLevel.Info;
-    case "trace":
-      return CoreLogLevel.Trace;
-  }
-}

package/src/core-interop/Metadata.ts

@@ -1,62 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
- * See LICENSE.md in the project root for license terms and full copyright notice.
- *--------------------------------------------------------------------------------------------*/
-
-import { Schema as CoreSchema, SchemaKey as CoreSchemaKey } from "@itwin/ecschema-metadata";
-import { ECSchemaProvider } from "@itwin/presentation-shared";
-import { createECSchema } from "./MetadataInternal";
-
-/**
- * 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.
- */
-interface CoreSchemaContext {
-  getSchema(key: CoreSchemaKey): Promise<CoreSchema | undefined>;
-}
-
-/**
- * Creates an `ECSchemaProvider` for given [SchemaContext](https://www.itwinjs.org/reference/ecschema-metadata/context/schemacontext/).
- *
- * Usage example:
- *
- * ```ts
- * import { SchemaContext } from "@itwin/ecschema-metadata";
- * import { createECSchemaProvider } from "@itwin/presentation-core-interop";
- *
- * const schemaContext = new SchemaContext();
- * const schemaProvider = createECSchemaProvider(schemas);
- * // the created schema provider may be used in `@itwin/presentation-hierarchies` and other Presentation packages
- * ```
- *
- * @beta
- */
-export function createECSchemaProvider(schemaContext: CoreSchemaContext): ECSchemaProvider {
-  async function getSchemaUnprotected(schemaName: string) {
-    const coreSchema = await schemaContext.getSchema(new CoreSchemaKey(schemaName));
-    return coreSchema ? createECSchema(coreSchema) : undefined;
-  }
-  async function getSchemaProtected(schemaName: string, handledExistingSchemaErrors: Set<string>) {
-    // workaround for https://github.com/iTwin/itwinjs-core/issues/6542
-    try {
-      return await getSchemaUnprotected(schemaName);
-    } catch (e) {
-      // istanbul ignore else
-      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;
-        }
-      }
-      throw e;
-    }
-  }
-  return {
-    async getSchema(name) {
-      return getSchemaProtected(name, new Set());
-    },
-  };
-}