@itwin/ecschema-editing 4.0.0-dev.6 → 4.0.0-dev.61

package/lib/cjs/Editing/Structs.js

@@ -1,58 +1,58 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Editing
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Structs = void 0;
-const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-const ECClasses_1 = require("./ECClasses");
-/**
- * @alpha A class extending ECClasses allowing you to create schema items of type StructClass.
- */
-class Structs extends ECClasses_1.ECClasses {
-    constructor(_schemaEditor) {
-        super(_schemaEditor);
-    }
-    async create(schemaKey, name, displayLabel, baseClass) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        const newClass = (await schema.createStructClass(name));
-        if (newClass === undefined)
-            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
-        if (baseClass !== undefined) {
-            const baseClassItem = await schema.lookupItem(baseClass);
-            if (baseClassItem === undefined)
-                return { errorMessage: `Unable to locate base class ${baseClass.fullName} in schema ${schema.fullName}.` };
-            if (baseClassItem.schemaItemType !== ecschema_metadata_1.SchemaItemType.StructClass)
-                return { errorMessage: `${baseClassItem.fullName} is not of type Struct Class.` };
-            newClass.baseClass = new ecschema_metadata_1.DelayedPromiseWithProps(baseClass, async () => baseClassItem);
-        }
-        if (displayLabel)
-            newClass.setDisplayLabel(displayLabel);
-        return { itemKey: newClass.key };
-    }
-    /**
-     *  Creates a StructClass through a StructClassProps.
-     * @param schemaKey a SchemaKey of the Schema that will house the new object.
-     * @param structProps a json object that will be used to populate the new StructClass. Needs a name value passed in.
-     */
-    async createFromProps(schemaKey, structProps) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        if (structProps.name === undefined)
-            return { errorMessage: `No name was supplied within props.` };
-        const newClass = (await schema.createStructClass(structProps.name));
-        if (newClass === undefined)
-            return { errorMessage: `Failed to create class ${structProps.name} in schema ${schemaKey.toString(true)}.` };
-        await newClass.fromJSON(structProps);
-        return { itemKey: newClass.key };
-    }
-}
-exports.Structs = Structs;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Editing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Structs = void 0;
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+const ECClasses_1 = require("./ECClasses");
+/**
+ * @alpha A class extending ECClasses allowing you to create schema items of type StructClass.
+ */
+class Structs extends ECClasses_1.ECClasses {
+    constructor(_schemaEditor) {
+        super(_schemaEditor);
+    }
+    async create(schemaKey, name, displayLabel, baseClass) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        const newClass = (await schema.createStructClass(name));
+        if (newClass === undefined)
+            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
+        if (baseClass !== undefined) {
+            const baseClassItem = await schema.lookupItem(baseClass);
+            if (baseClassItem === undefined)
+                return { errorMessage: `Unable to locate base class ${baseClass.fullName} in schema ${schema.fullName}.` };
+            if (baseClassItem.schemaItemType !== ecschema_metadata_1.SchemaItemType.StructClass)
+                return { errorMessage: `${baseClassItem.fullName} is not of type Struct Class.` };
+            newClass.baseClass = new ecschema_metadata_1.DelayedPromiseWithProps(baseClass, async () => baseClassItem);
+        }
+        if (displayLabel)
+            newClass.setDisplayLabel(displayLabel);
+        return { itemKey: newClass.key };
+    }
+    /**
+     *  Creates a StructClass through a StructClassProps.
+     * @param schemaKey a SchemaKey of the Schema that will house the new object.
+     * @param structProps a json object that will be used to populate the new StructClass. Needs a name value passed in.
+     */
+    async createFromProps(schemaKey, structProps) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        if (structProps.name === undefined)
+            return { errorMessage: `No name was supplied within props.` };
+        const newClass = (await schema.createStructClass(structProps.name));
+        if (newClass === undefined)
+            return { errorMessage: `Failed to create class ${structProps.name} in schema ${schemaKey.toString(true)}.` };
+        await newClass.fromJSON(structProps);
+        return { itemKey: newClass.key };
+    }
+}
+exports.Structs = Structs;
 //# sourceMappingURL=Structs.js.map

package/lib/cjs/Editing/UnitSystems.d.ts

@@ -1,16 +1,16 @@
-/** @packageDocumentation
- * @module Editing
- */
-import { SchemaKey, UnitSystemProps } from "@itwin/ecschema-metadata";
-import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
-/**
- * @alpha
- * A class allowing you to create schema items of type UnitSystems.
- */
-export declare class UnitSystems {
-    protected _schemaEditor: SchemaContextEditor;
-    constructor(_schemaEditor: SchemaContextEditor);
-    create(schemaKey: SchemaKey, name: string, displayLabel?: string): Promise<SchemaItemEditResults>;
-    createFromProps(schemaKey: SchemaKey, unitSystemProps: UnitSystemProps): Promise<SchemaItemEditResults>;
-}
+/** @packageDocumentation
+ * @module Editing
+ */
+import { SchemaKey, UnitSystemProps } from "@itwin/ecschema-metadata";
+import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
+/**
+ * @alpha
+ * A class allowing you to create schema items of type UnitSystems.
+ */
+export declare class UnitSystems {
+    protected _schemaEditor: SchemaContextEditor;
+    constructor(_schemaEditor: SchemaContextEditor);
+    create(schemaKey: SchemaKey, name: string, displayLabel?: string): Promise<SchemaItemEditResults>;
+    createFromProps(schemaKey: SchemaKey, unitSystemProps: UnitSystemProps): Promise<SchemaItemEditResults>;
+}
 //# sourceMappingURL=UnitSystems.d.ts.map

package/lib/cjs/Editing/UnitSystems.js

@@ -1,42 +1,42 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Editing
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnitSystems = void 0;
-/**
- * @alpha
- * A class allowing you to create schema items of type UnitSystems.
- */
-class UnitSystems {
-    constructor(_schemaEditor) {
-        this._schemaEditor = _schemaEditor;
-    }
-    async create(schemaKey, name, displayLabel) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        const newUnitSystem = (await schema.createUnitSystem(name));
-        if (displayLabel)
-            newUnitSystem.setDisplayLabel(displayLabel);
-        return { itemKey: newUnitSystem.key };
-    }
-    async createFromProps(schemaKey, unitSystemProps) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        if (unitSystemProps.name === undefined)
-            return { errorMessage: `No name was supplied within props.` };
-        const newUnitSystem = (await schema.createUnitSystem(unitSystemProps.name));
-        if (newUnitSystem === undefined)
-            return { errorMessage: `Failed to create class ${unitSystemProps.name} in schema ${schemaKey.toString(true)}.` };
-        await newUnitSystem.fromJSON(unitSystemProps);
-        return { itemKey: newUnitSystem.key };
-    }
-}
-exports.UnitSystems = UnitSystems;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Editing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnitSystems = void 0;
+/**
+ * @alpha
+ * A class allowing you to create schema items of type UnitSystems.
+ */
+class UnitSystems {
+    constructor(_schemaEditor) {
+        this._schemaEditor = _schemaEditor;
+    }
+    async create(schemaKey, name, displayLabel) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        const newUnitSystem = (await schema.createUnitSystem(name));
+        if (displayLabel)
+            newUnitSystem.setDisplayLabel(displayLabel);
+        return { itemKey: newUnitSystem.key };
+    }
+    async createFromProps(schemaKey, unitSystemProps) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        if (unitSystemProps.name === undefined)
+            return { errorMessage: `No name was supplied within props.` };
+        const newUnitSystem = (await schema.createUnitSystem(unitSystemProps.name));
+        if (newUnitSystem === undefined)
+            return { errorMessage: `Failed to create class ${unitSystemProps.name} in schema ${schemaKey.toString(true)}.` };
+        await newUnitSystem.fromJSON(unitSystemProps);
+        return { itemKey: newUnitSystem.key };
+    }
+}
+exports.UnitSystems = UnitSystems;
 //# sourceMappingURL=UnitSystems.js.map

package/lib/cjs/Editing/Units.d.ts

@@ -1,16 +1,16 @@
-/** @packageDocumentation
- * @module Editing
- */
-import { SchemaItemKey, SchemaKey, UnitProps } from "@itwin/ecschema-metadata";
-import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
-/**
- * @alpha
- * A class allowing you to create schema items of type Unit.
- */
-export declare class Units {
-    protected _schemaEditor: SchemaContextEditor;
-    constructor(_schemaEditor: SchemaContextEditor);
-    create(schemaKey: SchemaKey, name: string, definition: string, phenomenon: SchemaItemKey, unitSystem: SchemaItemKey, displayLabel?: string): Promise<SchemaItemEditResults>;
-    createFromProps(schemaKey: SchemaKey, unitProps: UnitProps): Promise<SchemaItemEditResults>;
-}
+/** @packageDocumentation
+ * @module Editing
+ */
+import { SchemaItemKey, SchemaKey, UnitProps } from "@itwin/ecschema-metadata";
+import { SchemaContextEditor, SchemaItemEditResults } from "./Editor";
+/**
+ * @alpha
+ * A class allowing you to create schema items of type Unit.
+ */
+export declare class Units {
+    protected _schemaEditor: SchemaContextEditor;
+    constructor(_schemaEditor: SchemaContextEditor);
+    create(schemaKey: SchemaKey, name: string, definition: string, phenomenon: SchemaItemKey, unitSystem: SchemaItemKey, displayLabel?: string): Promise<SchemaItemEditResults>;
+    createFromProps(schemaKey: SchemaKey, unitProps: UnitProps): Promise<SchemaItemEditResults>;
+}
 //# sourceMappingURL=Units.d.ts.map

package/lib/cjs/Editing/Units.js

@@ -1,59 +1,59 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Editing
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Units = void 0;
-const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
-/**
- * @alpha
- * A class allowing you to create schema items of type Unit.
- */
-class Units {
-    // TODO: Add more setters for all attributes.
-    constructor(_schemaEditor) {
-        this._schemaEditor = _schemaEditor;
-    }
-    async create(schemaKey, name, definition, phenomenon, unitSystem, displayLabel) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        const newUnit = (await schema.createUnit(name));
-        if (newUnit === undefined)
-            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
-        const phenomenonItem = await schema.lookupItem(phenomenon);
-        if (phenomenonItem === undefined)
-            return { errorMessage: `Unable to locate phenomenon ${phenomenon.fullName} in schema ${schema.fullName}.` };
-        if (phenomenonItem.schemaItemType !== ecschema_metadata_1.SchemaItemType.Phenomenon)
-            return { errorMessage: `${phenomenon.fullName} is not of type Phenomenon.` };
-        await newUnit.setPhenomenon(new ecschema_metadata_1.DelayedPromiseWithProps(phenomenon, async () => phenomenonItem));
-        const unitSystemItem = await schema.lookupItem(unitSystem);
-        if (unitSystemItem === undefined)
-            return { errorMessage: `Unable to locate unit system ${unitSystem.fullName} in schema ${schema.fullName}.` };
-        if (unitSystemItem.schemaItemType !== ecschema_metadata_1.SchemaItemType.UnitSystem)
-            return { errorMessage: `${unitSystem.fullName} is not of type UnitSystem.` };
-        await newUnit.setUnitSystem(new ecschema_metadata_1.DelayedPromiseWithProps(unitSystem, async () => unitSystemItem));
-        await newUnit.setDefinition(definition);
-        if (displayLabel)
-            newUnit.setDisplayLabel(displayLabel);
-        return { itemKey: newUnit.key };
-    }
-    async createFromProps(schemaKey, unitProps) {
-        const schema = await this._schemaEditor.getSchema(schemaKey);
-        if (schema === undefined)
-            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
-        if (unitProps.name === undefined)
-            return { errorMessage: `No name was supplied within props.` };
-        const newUnit = (await schema.createUnit(unitProps.name));
-        if (newUnit === undefined)
-            return { errorMessage: `Failed to create class ${unitProps.name} in schema ${schemaKey.toString(true)}.` };
-        await newUnit.fromJSON(unitProps);
-        return { itemKey: newUnit.key };
-    }
-}
-exports.Units = Units;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Editing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Units = void 0;
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+/**
+ * @alpha
+ * A class allowing you to create schema items of type Unit.
+ */
+class Units {
+    // TODO: Add more setters for all attributes.
+    constructor(_schemaEditor) {
+        this._schemaEditor = _schemaEditor;
+    }
+    async create(schemaKey, name, definition, phenomenon, unitSystem, displayLabel) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        const newUnit = (await schema.createUnit(name));
+        if (newUnit === undefined)
+            return { errorMessage: `Failed to create class ${name} in schema ${schemaKey.toString(true)}.` };
+        const phenomenonItem = await schema.lookupItem(phenomenon);
+        if (phenomenonItem === undefined)
+            return { errorMessage: `Unable to locate phenomenon ${phenomenon.fullName} in schema ${schema.fullName}.` };
+        if (phenomenonItem.schemaItemType !== ecschema_metadata_1.SchemaItemType.Phenomenon)
+            return { errorMessage: `${phenomenon.fullName} is not of type Phenomenon.` };
+        await newUnit.setPhenomenon(new ecschema_metadata_1.DelayedPromiseWithProps(phenomenon, async () => phenomenonItem));
+        const unitSystemItem = await schema.lookupItem(unitSystem);
+        if (unitSystemItem === undefined)
+            return { errorMessage: `Unable to locate unit system ${unitSystem.fullName} in schema ${schema.fullName}.` };
+        if (unitSystemItem.schemaItemType !== ecschema_metadata_1.SchemaItemType.UnitSystem)
+            return { errorMessage: `${unitSystem.fullName} is not of type UnitSystem.` };
+        await newUnit.setUnitSystem(new ecschema_metadata_1.DelayedPromiseWithProps(unitSystem, async () => unitSystemItem));
+        await newUnit.setDefinition(definition);
+        if (displayLabel)
+            newUnit.setDisplayLabel(displayLabel);
+        return { itemKey: newUnit.key };
+    }
+    async createFromProps(schemaKey, unitProps) {
+        const schema = await this._schemaEditor.getSchema(schemaKey);
+        if (schema === undefined)
+            return { errorMessage: `Schema Key ${schemaKey.toString(true)} not found in context` };
+        if (unitProps.name === undefined)
+            return { errorMessage: `No name was supplied within props.` };
+        const newUnit = (await schema.createUnit(unitProps.name));
+        if (newUnit === undefined)
+            return { errorMessage: `Failed to create class ${unitProps.name} in schema ${schemaKey.toString(true)}.` };
+        await newUnit.fromJSON(unitProps);
+        return { itemKey: newUnit.key };
+    }
+}
+exports.Units = Units;
 //# sourceMappingURL=Units.js.map