@itwin/ecschema-metadata 4.0.0-dev.1 → 4.0.0-dev.100

package/lib/cjs/Deserialization/XmlSerializationUtils.js

@@ -1,175 +1,175 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.XmlSerializationUtils = void 0;
-const ECObjects_1 = require("../ECObjects");
-const Exception_1 = require("../Exception");
-/**
- * Namespace holding utility functions for serializing EC types to the EC XML format.
- * @internal
- */
-var XmlSerializationUtils;
-(function (XmlSerializationUtils) {
-    /**
-     * Serializes a CustomAttribute instance to the EC XML format.
-     * @param fullName The full name of the CustomAttribute (qualified by schema name).
-     * @param customAttribute The CustomAttribute instance to serialize.
-     * @param schemaDoc The Xml Document object holding the serialized EC Schema.
-     * @param schema The Schema object being serialized.
-     * @beta
-     */
-    async function writeCustomAttribute(fullName, customAttribute, schemaDoc, schema) {
-        const caClass = await schema.lookupItem(fullName);
-        if (!caClass)
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.ClassNotFound, `The class '${fullName}' could not be found in the current schema context.`);
-        const nameAndNamespace = await resolveCustomAttributeNamespace(fullName, schema);
-        const caElement = schemaDoc.createElement(nameAndNamespace[0]);
-        if (nameAndNamespace[1])
-            caElement.setAttribute("xmlns", nameAndNamespace[1]);
-        if (!caClass.properties)
-            return caElement;
-        for (const property of caClass.properties)
-            await writeInstanceProperty(property, customAttribute, caElement, schemaDoc);
-        return caElement;
-    }
-    XmlSerializationUtils.writeCustomAttribute = writeCustomAttribute;
-    /**
-     * Serializes an EC Property instance to the EC XML format.
-     * @param propertyClass The Property metadata object.
-     * @param instance The Property instance.
-     * @param instanceElement The XML Element that will contain the serialized property instance.
-     * @param schemaDoc The Xml Document object holding the serialized EC Schema.
-     * @beta
-     */
-    async function writeInstanceProperty(propertyClass, instance, instanceElement, schemaDoc) {
-        const propertyValue = instance[propertyClass.name];
-        if (propertyValue === undefined)
-            return;
-        const propertyElement = schemaDoc.createElement(propertyClass.name);
-        instanceElement.appendChild(propertyElement);
-        if (propertyClass.isArray()) {
-            await writeArrayProperty(propertyClass, propertyValue, propertyElement, schemaDoc);
-        }
-        else if (propertyClass.isPrimitive()) {
-            await writePrimitiveProperty(propertyClass, propertyValue, propertyElement);
-        }
-        else if (propertyClass.isStruct()) {
-            await writeStructProperty(propertyClass, propertyValue, propertyElement, schemaDoc);
-        }
-    }
-    XmlSerializationUtils.writeInstanceProperty = writeInstanceProperty;
-    /**
-     * Serializes an EC ArrayProperty instance to the EC XML format.
-     * @param propertyClass The Property metadata object.
-     * @param propertyValue An array holding the property values.
-     * @param arrayElement The XML Element that will contain the serialized property instance.
-     * @param schemaDoc The Xml Document object holding the serialized EC Schema.
-     * @beta
-     */
-    async function writeArrayProperty(propertyClass, propertyValue, arrayElement, schemaDoc) {
-        if (propertyClass.isPrimitive()) {
-            const typeString = (0, ECObjects_1.primitiveTypeToString)(propertyClass.primitiveType);
-            for (const value of propertyValue) {
-                const entryElement = schemaDoc.createElement(typeString);
-                await writePrimitiveProperty(propertyClass, value, entryElement);
-                arrayElement.appendChild(entryElement);
-            }
-        }
-        if (propertyClass.isStruct()) {
-            for (const value of propertyValue) {
-                const structElement = schemaDoc.createElement(propertyClass.structClass.name);
-                arrayElement.appendChild(structElement);
-                await writeStructProperty(propertyClass, value, structElement, schemaDoc);
-            }
-        }
-    }
-    XmlSerializationUtils.writeArrayProperty = writeArrayProperty;
-    /**
-     * Serializes an EC StructProperty instance to the EC XML format.
-     * @param propertyClass The Property metadata object.
-     * @param propertyValue The struct object holding the property values.
-     * @param structElement The XML Element that will contain the serialized property instance.
-     * @param schemaDoc The Xml Document object holding the serialized EC Schema.
-     * @beta
-     */
-    async function writeStructProperty(propertyClass, propertyValue, structElement, schemaDoc) {
-        const structClass = propertyClass.structClass;
-        if (!structClass.properties)
-            return;
-        for (const propertyMetadata of structClass.properties)
-            await writeInstanceProperty(propertyMetadata, propertyValue, structElement, schemaDoc);
-    }
-    XmlSerializationUtils.writeStructProperty = writeStructProperty;
-    /**
-     * Serializes an EC PrimitiveProperty instance to the EC XML format.
-     * @param propertyClass The Property metadata object.
-     * @param propertyValue The struct object holding the property values.
-     * @param propertyElement The XML Element that will contain the serialized property instance.
-     * @beta
-     */
-    async function writePrimitiveProperty(propertyClass, propertyValue, propertyElement) {
-        let primitiveType;
-        if (propertyClass.isEnumeration()) {
-            const enumeration = await propertyClass.enumeration;
-            if (!enumeration)
-                throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.ClassNotFound, `The enumeration on property class '${propertyClass.fullName}' could not be found in the current schema context.`);
-            if (enumeration.type === undefined)
-                throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidType, `The enumeration on property class '${propertyClass.fullName}' has an invalid primitive type.`);
-            primitiveType = enumeration.type;
-        }
-        else
-            primitiveType = propertyClass.primitiveType;
-        switch (primitiveType) {
-            case ECObjects_1.PrimitiveType.String:
-                propertyElement.textContent = propertyValue;
-                return;
-            case ECObjects_1.PrimitiveType.Boolean:
-                propertyElement.textContent = propertyValue ? "True" : "False";
-                return;
-            case ECObjects_1.PrimitiveType.Integer:
-            case ECObjects_1.PrimitiveType.Double:
-            case ECObjects_1.PrimitiveType.Long:
-                propertyElement.textContent = propertyValue.toString();
-                return;
-            case ECObjects_1.PrimitiveType.DateTime:
-                propertyElement.textContent = propertyValue.getTime().toString();
-                return;
-            case ECObjects_1.PrimitiveType.Point2d:
-                propertyElement.textContent = `${propertyValue.x},${propertyValue.y}`;
-                return;
-            case ECObjects_1.PrimitiveType.Point3d:
-                propertyElement.textContent = `${propertyValue.x},${propertyValue.y},${propertyValue.z}`;
-                return;
-            case ECObjects_1.PrimitiveType.IGeometry:
-            case ECObjects_1.PrimitiveType.Binary:
-                propertyElement.textContent = propertyValue;
-                return;
-            default:
-                throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidPrimitiveType, `The property '${propertyClass.fullName}' has an invalid primitive type.`);
-        }
-    }
-    XmlSerializationUtils.writePrimitiveProperty = writePrimitiveProperty;
-    function createXmlTypedName(currentSchema, typeSchema, typeName) {
-        if (currentSchema.schemaKey.matches(typeSchema.schemaKey))
-            return typeName;
-        // Alias is required in Spec. It could be undefined (technically), so
-        // throw until fixed.
-        if (typeSchema.alias === undefined)
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidSchemaAlias, `The schema '${typeSchema.name}' has an invalid alias.`);
-        return `${typeSchema.alias}:${typeName}`;
-    }
-    XmlSerializationUtils.createXmlTypedName = createXmlTypedName;
-    async function resolveCustomAttributeNamespace(caName, schema) {
-        const nameParts = caName.split(".");
-        if (nameParts.length === 1)
-            return [caName, undefined];
-        const attributeSchema = nameParts[0].toUpperCase() === schema.name.toUpperCase() ? schema : await schema.getReference(nameParts[0]);
-        if (!attributeSchema)
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.UnableToLocateSchema, `Unable to resolve the namespace for CustomAttribute '${caName}' because the referenced schema '${nameParts[0]}' could not be located.`);
-        return [nameParts[1], `${nameParts[0]}.${attributeSchema.schemaKey.version.toString()}`];
-    }
-})(XmlSerializationUtils = exports.XmlSerializationUtils || (exports.XmlSerializationUtils = {}));
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XmlSerializationUtils = void 0;
+const ECObjects_1 = require("../ECObjects");
+const Exception_1 = require("../Exception");
+/**
+ * Namespace holding utility functions for serializing EC types to the EC XML format.
+ * @internal
+ */
+var XmlSerializationUtils;
+(function (XmlSerializationUtils) {
+    /**
+     * Serializes a CustomAttribute instance to the EC XML format.
+     * @param fullName The full name of the CustomAttribute (qualified by schema name).
+     * @param customAttribute The CustomAttribute instance to serialize.
+     * @param schemaDoc The Xml Document object holding the serialized EC Schema.
+     * @param schema The Schema object being serialized.
+     * @beta
+     */
+    async function writeCustomAttribute(fullName, customAttribute, schemaDoc, schema) {
+        const caClass = await schema.lookupItem(fullName);
+        if (!caClass)
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.ClassNotFound, `The class '${fullName}' could not be found in the current schema context.`);
+        const nameAndNamespace = await resolveCustomAttributeNamespace(fullName, schema);
+        const caElement = schemaDoc.createElement(nameAndNamespace[0]);
+        if (nameAndNamespace[1])
+            caElement.setAttribute("xmlns", nameAndNamespace[1]);
+        if (!caClass.properties)
+            return caElement;
+        for (const property of caClass.properties)
+            await writeInstanceProperty(property, customAttribute, caElement, schemaDoc);
+        return caElement;
+    }
+    XmlSerializationUtils.writeCustomAttribute = writeCustomAttribute;
+    /**
+     * Serializes an EC Property instance to the EC XML format.
+     * @param propertyClass The Property metadata object.
+     * @param instance The Property instance.
+     * @param instanceElement The XML Element that will contain the serialized property instance.
+     * @param schemaDoc The Xml Document object holding the serialized EC Schema.
+     * @beta
+     */
+    async function writeInstanceProperty(propertyClass, instance, instanceElement, schemaDoc) {
+        const propertyValue = instance[propertyClass.name];
+        if (propertyValue === undefined)
+            return;
+        const propertyElement = schemaDoc.createElement(propertyClass.name);
+        instanceElement.appendChild(propertyElement);
+        if (propertyClass.isArray()) {
+            await writeArrayProperty(propertyClass, propertyValue, propertyElement, schemaDoc);
+        }
+        else if (propertyClass.isPrimitive()) {
+            await writePrimitiveProperty(propertyClass, propertyValue, propertyElement);
+        }
+        else if (propertyClass.isStruct()) {
+            await writeStructProperty(propertyClass, propertyValue, propertyElement, schemaDoc);
+        }
+    }
+    XmlSerializationUtils.writeInstanceProperty = writeInstanceProperty;
+    /**
+     * Serializes an EC ArrayProperty instance to the EC XML format.
+     * @param propertyClass The Property metadata object.
+     * @param propertyValue An array holding the property values.
+     * @param arrayElement The XML Element that will contain the serialized property instance.
+     * @param schemaDoc The Xml Document object holding the serialized EC Schema.
+     * @beta
+     */
+    async function writeArrayProperty(propertyClass, propertyValue, arrayElement, schemaDoc) {
+        if (propertyClass.isPrimitive()) {
+            const typeString = (0, ECObjects_1.primitiveTypeToString)(propertyClass.primitiveType);
+            for (const value of propertyValue) {
+                const entryElement = schemaDoc.createElement(typeString);
+                await writePrimitiveProperty(propertyClass, value, entryElement);
+                arrayElement.appendChild(entryElement);
+            }
+        }
+        if (propertyClass.isStruct()) {
+            for (const value of propertyValue) {
+                const structElement = schemaDoc.createElement(propertyClass.structClass.name);
+                arrayElement.appendChild(structElement);
+                await writeStructProperty(propertyClass, value, structElement, schemaDoc);
+            }
+        }
+    }
+    XmlSerializationUtils.writeArrayProperty = writeArrayProperty;
+    /**
+     * Serializes an EC StructProperty instance to the EC XML format.
+     * @param propertyClass The Property metadata object.
+     * @param propertyValue The struct object holding the property values.
+     * @param structElement The XML Element that will contain the serialized property instance.
+     * @param schemaDoc The Xml Document object holding the serialized EC Schema.
+     * @beta
+     */
+    async function writeStructProperty(propertyClass, propertyValue, structElement, schemaDoc) {
+        const structClass = propertyClass.structClass;
+        if (!structClass.properties)
+            return;
+        for (const propertyMetadata of structClass.properties)
+            await writeInstanceProperty(propertyMetadata, propertyValue, structElement, schemaDoc);
+    }
+    XmlSerializationUtils.writeStructProperty = writeStructProperty;
+    /**
+     * Serializes an EC PrimitiveProperty instance to the EC XML format.
+     * @param propertyClass The Property metadata object.
+     * @param propertyValue The struct object holding the property values.
+     * @param propertyElement The XML Element that will contain the serialized property instance.
+     * @beta
+     */
+    async function writePrimitiveProperty(propertyClass, propertyValue, propertyElement) {
+        let primitiveType;
+        if (propertyClass.isEnumeration()) {
+            const enumeration = await propertyClass.enumeration;
+            if (!enumeration)
+                throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.ClassNotFound, `The enumeration on property class '${propertyClass.fullName}' could not be found in the current schema context.`);
+            if (enumeration.type === undefined)
+                throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidType, `The enumeration on property class '${propertyClass.fullName}' has an invalid primitive type.`);
+            primitiveType = enumeration.type;
+        }
+        else
+            primitiveType = propertyClass.primitiveType;
+        switch (primitiveType) {
+            case ECObjects_1.PrimitiveType.String:
+                propertyElement.textContent = propertyValue;
+                return;
+            case ECObjects_1.PrimitiveType.Boolean:
+                propertyElement.textContent = propertyValue ? "True" : "False";
+                return;
+            case ECObjects_1.PrimitiveType.Integer:
+            case ECObjects_1.PrimitiveType.Double:
+            case ECObjects_1.PrimitiveType.Long:
+                propertyElement.textContent = propertyValue.toString();
+                return;
+            case ECObjects_1.PrimitiveType.DateTime:
+                propertyElement.textContent = propertyValue.getTime().toString();
+                return;
+            case ECObjects_1.PrimitiveType.Point2d:
+                propertyElement.textContent = `${propertyValue.x},${propertyValue.y}`;
+                return;
+            case ECObjects_1.PrimitiveType.Point3d:
+                propertyElement.textContent = `${propertyValue.x},${propertyValue.y},${propertyValue.z}`;
+                return;
+            case ECObjects_1.PrimitiveType.IGeometry:
+            case ECObjects_1.PrimitiveType.Binary:
+                propertyElement.textContent = propertyValue;
+                return;
+            default:
+                throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidPrimitiveType, `The property '${propertyClass.fullName}' has an invalid primitive type.`);
+        }
+    }
+    XmlSerializationUtils.writePrimitiveProperty = writePrimitiveProperty;
+    function createXmlTypedName(currentSchema, typeSchema, typeName) {
+        if (currentSchema.schemaKey.matches(typeSchema.schemaKey))
+            return typeName;
+        // Alias is required in Spec. It could be undefined (technically), so
+        // throw until fixed.
+        if (typeSchema.alias === undefined)
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidSchemaAlias, `The schema '${typeSchema.name}' has an invalid alias.`);
+        return `${typeSchema.alias}:${typeName}`;
+    }
+    XmlSerializationUtils.createXmlTypedName = createXmlTypedName;
+    async function resolveCustomAttributeNamespace(caName, schema) {
+        const nameParts = caName.split(".");
+        if (nameParts.length === 1)
+            return [caName, undefined];
+        const attributeSchema = nameParts[0].toUpperCase() === schema.name.toUpperCase() ? schema : await schema.getReference(nameParts[0]);
+        if (!attributeSchema)
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.UnableToLocateSchema, `Unable to resolve the namespace for CustomAttribute '${caName}' because the referenced schema '${nameParts[0]}' could not be located.`);
+        return [nameParts[1], `${nameParts[0]}.${attributeSchema.schemaKey.version.toString()}`];
+    }
+})(XmlSerializationUtils = exports.XmlSerializationUtils || (exports.XmlSerializationUtils = {}));
 //# sourceMappingURL=XmlSerializationUtils.js.map

package/lib/cjs/ECName.d.ts

@@ -1,31 +1,31 @@
-/** @packageDocumentation
- * @module Metadata
- */
-/** The name of an item in a [[Schema]], encoded to meet restrictions on the characters usable in such names.
- * An ECName meets the following criteria:
- *  - Contains at least one character.
- *  - Does not begin with a digit.
- *  - Consists entirely of characters in the ASCII ranges A-Z, a-z, and 0-9; and the underscore ("_") character.
- *
- * All characters not meeting the above criteria are encoded as "__x####__" where "####" is the UTF-16 character code.
- * Such names are often automatically generated from the item's display label, which is unrestricted in the characters it may contain.
- * @public
- */
-export declare class ECName {
-    private _name;
-    /** Construct a new ECName from a valid EC name.
-     * throws ECObjectsError if `name` does not meet the criteria for a valid EC name.
-     */
-    constructor(name: string);
-    /** Returns true if a string meets the criteria of a valid EC name. */
-    static validate(name: string): boolean;
-    /** The underlying name as a string. */
-    get name(): string;
-    /** Create an ECName from an arbitrary string, encoding any special characters as "__x####__" where "####" is the UTF-16 character code.
-     * @throws ECObjectsError if `input` is an empty string.
-     */
-    static encode(input: string): ECName;
-    /** Decode this ECName, replacing encoded special characters with the characters they encode. */
-    decode(): string;
-}
+/** @packageDocumentation
+ * @module Metadata
+ */
+/** The name of an item in a [[Schema]], encoded to meet restrictions on the characters usable in such names.
+ * An ECName meets the following criteria:
+ *  - Contains at least one character.
+ *  - Does not begin with a digit.
+ *  - Consists entirely of characters in the ASCII ranges A-Z, a-z, and 0-9; and the underscore ("_") character.
+ *
+ * All characters not meeting the above criteria are encoded as "__x####__" where "####" is the UTF-16 character code.
+ * Such names are often automatically generated from the item's display label, which is unrestricted in the characters it may contain.
+ * @public
+ */
+export declare class ECName {
+    private _name;
+    /** Construct a new ECName from a valid EC name.
+     * throws ECObjectsError if `name` does not meet the criteria for a valid EC name.
+     */
+    constructor(name: string);
+    /** Returns true if a string meets the criteria of a valid EC name. */
+    static validate(name: string): boolean;
+    /** The underlying name as a string. */
+    get name(): string;
+    /** Create an ECName from an arbitrary string, encoding any special characters as "__x####__" where "####" is the UTF-16 character code.
+     * @throws ECObjectsError if `input` is an empty string.
+     */
+    static encode(input: string): ECName;
+    /** Decode this ECName, replacing encoded special characters with the characters they encode. */
+    decode(): string;
+}
 //# sourceMappingURL=ECName.d.ts.map

package/lib/cjs/ECName.js

@@ -1,86 +1,86 @@
-"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 Metadata
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ECName = void 0;
-const core_bentley_1 = require("@itwin/core-bentley");
-const Exception_1 = require("./Exception");
-const validECNameRegex = /^([a-zA-Z_]+[a-zA-Z0-9_]*)$/i;
-const ecNameReplacerRegex = /__x([0-9a-fA-F]{4})__/g;
-const leadingDigits = ["0000", "000", "00", "0", ""];
-function isDigit(character) {
-    (0, core_bentley_1.assert)(1 === character.length);
-    return character >= "0" && character <= "9";
-}
-function isValidAlphaNumericCharacter(c) {
-    (0, core_bentley_1.assert)(1 === c.length);
-    return (((c >= "0" && c <= "9") || (c >= "A" && c <= "Z") || (c >= "a" && c <= "z") || c === "_"));
-}
-/** The name of an item in a [[Schema]], encoded to meet restrictions on the characters usable in such names.
- * An ECName meets the following criteria:
- *  - Contains at least one character.
- *  - Does not begin with a digit.
- *  - Consists entirely of characters in the ASCII ranges A-Z, a-z, and 0-9; and the underscore ("_") character.
- *
- * All characters not meeting the above criteria are encoded as "__x####__" where "####" is the UTF-16 character code.
- * Such names are often automatically generated from the item's display label, which is unrestricted in the characters it may contain.
- * @public
- */
-class ECName {
-    /** Construct a new ECName from a valid EC name.
-     * throws ECObjectsError if `name` does not meet the criteria for a valid EC name.
-     */
-    constructor(name) {
-        if (!ECName.validate(name))
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidECName);
-        this._name = name;
-    }
-    /** Returns true if a string meets the criteria of a valid EC name. */
-    static validate(name) {
-        return validECNameRegex.test(name);
-    }
-    /** The underlying name as a string. */
-    get name() {
-        return this._name;
-    }
-    /** Create an ECName from an arbitrary string, encoding any special characters as "__x####__" where "####" is the UTF-16 character code.
-     * @throws ECObjectsError if `input` is an empty string.
-     */
-    static encode(input) {
-        if (0 === input.length)
-            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidECName);
-        if (ECName.validate(input)) {
-            // It's already a valid EC name.
-            return new ECName(input);
-        }
-        let output = "";
-        function appendEncodedCharacter(index) {
-            const hex = input.charCodeAt(index).toString(16).toUpperCase();
-            (0, core_bentley_1.assert)(hex.length > 0 && hex.length < 5);
-            output += `__x${leadingDigits[hex.length]}${hex}__`;
-        }
-        // First character cannot be a digit.
-        const firstCharIsDigit = isDigit(input[0]);
-        if (firstCharIsDigit)
-            appendEncodedCharacter(0);
-        for (let i = firstCharIsDigit ? 1 : 0; i < input.length; i++) {
-            const char = input[i];
-            if (!isValidAlphaNumericCharacter(char))
-                appendEncodedCharacter(i);
-            else
-                output += char;
-        }
-        return new ECName(output);
-    }
-    /** Decode this ECName, replacing encoded special characters with the characters they encode. */
-    decode() {
-        return this.name.replace(ecNameReplacerRegex, (_match, hex) => String.fromCharCode(Number.parseInt(hex, 16)));
-    }
-}
-exports.ECName = ECName;
+"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 Metadata
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ECName = void 0;
+const core_bentley_1 = require("@itwin/core-bentley");
+const Exception_1 = require("./Exception");
+const validECNameRegex = /^([a-zA-Z_]+[a-zA-Z0-9_]*)$/i;
+const ecNameReplacerRegex = /__x([0-9a-fA-F]{4})__/g;
+const leadingDigits = ["0000", "000", "00", "0", ""];
+function isDigit(character) {
+    (0, core_bentley_1.assert)(1 === character.length);
+    return character >= "0" && character <= "9";
+}
+function isValidAlphaNumericCharacter(c) {
+    (0, core_bentley_1.assert)(1 === c.length);
+    return (((c >= "0" && c <= "9") || (c >= "A" && c <= "Z") || (c >= "a" && c <= "z") || c === "_"));
+}
+/** The name of an item in a [[Schema]], encoded to meet restrictions on the characters usable in such names.
+ * An ECName meets the following criteria:
+ *  - Contains at least one character.
+ *  - Does not begin with a digit.
+ *  - Consists entirely of characters in the ASCII ranges A-Z, a-z, and 0-9; and the underscore ("_") character.
+ *
+ * All characters not meeting the above criteria are encoded as "__x####__" where "####" is the UTF-16 character code.
+ * Such names are often automatically generated from the item's display label, which is unrestricted in the characters it may contain.
+ * @public
+ */
+class ECName {
+    /** Construct a new ECName from a valid EC name.
+     * throws ECObjectsError if `name` does not meet the criteria for a valid EC name.
+     */
+    constructor(name) {
+        if (!ECName.validate(name))
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidECName);
+        this._name = name;
+    }
+    /** Returns true if a string meets the criteria of a valid EC name. */
+    static validate(name) {
+        return validECNameRegex.test(name);
+    }
+    /** The underlying name as a string. */
+    get name() {
+        return this._name;
+    }
+    /** Create an ECName from an arbitrary string, encoding any special characters as "__x####__" where "####" is the UTF-16 character code.
+     * @throws ECObjectsError if `input` is an empty string.
+     */
+    static encode(input) {
+        if (0 === input.length)
+            throw new Exception_1.ECObjectsError(Exception_1.ECObjectsStatus.InvalidECName);
+        if (ECName.validate(input)) {
+            // It's already a valid EC name.
+            return new ECName(input);
+        }
+        let output = "";
+        function appendEncodedCharacter(index) {
+            const hex = input.charCodeAt(index).toString(16).toUpperCase();
+            (0, core_bentley_1.assert)(hex.length > 0 && hex.length < 5);
+            output += `__x${leadingDigits[hex.length]}${hex}__`;
+        }
+        // First character cannot be a digit.
+        const firstCharIsDigit = isDigit(input[0]);
+        if (firstCharIsDigit)
+            appendEncodedCharacter(0);
+        for (let i = firstCharIsDigit ? 1 : 0; i < input.length; i++) {
+            const char = input[i];
+            if (!isValidAlphaNumericCharacter(char))
+                appendEncodedCharacter(i);
+            else
+                output += char;
+        }
+        return new ECName(output);
+    }
+    /** Decode this ECName, replacing encoded special characters with the characters they encode. */
+    decode() {
+        return this.name.replace(ecNameReplacerRegex, (_match, hex) => String.fromCharCode(Number.parseInt(hex, 16)));
+    }
+}
+exports.ECName = ECName;
 //# sourceMappingURL=ECName.js.map