@itwin/ecschema-metadata 3.5.0-dev.4 → 3.5.0-dev.41

package/lib/cjs/DelayedPromise.js

@@ -1,92 +1,92 @@
-"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 Utils
- */
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DelayedPromiseWithProps = exports.DelayedPromise = void 0;
-/**
- * Similar to a normal Promise, a DelayedPromise represents the eventual completion (or failure)
- * and resulting value of an asynchronous operation ***that has not yet started***.
- *
- * The asynchronous operation behind a DelayedPromise will start when any of the following occurs:
- *  - The DelayedPromise is `await`ed.
- *  - A callback is attached via `.then()` or `.catch(() => { })`.
- *  - The asynchronous operation is explicitly started via `.start()`
- *
- * Just as normal Promises will never return to their pending state once fulfilled or rejected,
- * a DelayedPromise will never re-execute its asynchronous operation more than **once**.
- *
- * Ultimately, a DelayedPromise is nothing more than some syntactic sugar that allows you to
- * represent an (asynchronously) lazily-loaded value as an instance property instead of a method.
- * You could also accomplish something similar by defining an async function as a property getter.
- * However, since a property defined as a DelayedPromise will not start simply by being accessed,
- * additional (non-lazily-loaded) "nested" properties can be added.
- *
- * [!alert text="*Remember:* Unlike regular Promises in JavaScript, DelayedPromises represent processes that **may not** already be happening." kind="warning"]
- * @beta
- */
-class DelayedPromise {
-    /**
-     * Constructs a DelayedPromise object.
-     * @param startCallback The asynchronous callback to execute when this DelayedPromise should be "started".
-     */
-    constructor(startCallback) {
-        // We need this in order to fulfill the Promise interface defined in lib.es2015.symbol.wellknown.d.ts
-        this[_a] = "Promise";
-        let pending;
-        this.start = async () => {
-            pending = pending || startCallback();
-            return pending;
-        };
-    }
-    /**
-     * Attaches callbacks for the resolution and/or rejection of the Promise.
-     * @param onfulfilled The callback to execute when the Promise is resolved.
-     * @param onrejected The callback to execute when the Promise is rejected.
-     * @return A Promise for the completion of which ever callback is executed.
-     */
-    async then(onfulfilled, onrejected) {
-        return this.start().then(onfulfilled, onrejected);
-    }
-    /**
-     * Attaches a callback for only the rejection of the Promise.
-     * @param onrejected The callback to execute when the Promise is rejected.
-     * @return A Promise for the completion of the callback.
-     */
-    async catch(onrejected) {
-        return this.start().catch(onrejected);
-    }
-    /**
-     * Attaches a callback for only the finally clause of the Promise.
-     * @param onrejected The callback to execute when the Promise is finalized.
-     * @return A Promise for the completion of the callback.
-     */
-    async finally(onFinally) {
-        return this.start().finally(onFinally);
-    }
-}
-exports.DelayedPromise = DelayedPromise;
-_a = Symbol.toStringTag;
-// Because the property getters that wrap `props` are dynamically added, TypeScript isn't aware of them.
-// So by defining this as a class _expression_, we can cast the constructed type to Readonly<TProps> & DelayedPromise<TPayload>
-/**
- * @beta
- */
-// eslint-disable-next-line @typescript-eslint/naming-convention
-exports.DelayedPromiseWithProps = (class extends DelayedPromise {
-    constructor(props, cb) {
-        super(cb);
-        const handler = {
-            get: (target, name) => {
-                return (name in this) ? this[name] : target[name];
-            },
-        };
-        return new Proxy(props, handler);
-    }
-});
+"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 Utils
+ */
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelayedPromiseWithProps = exports.DelayedPromise = void 0;
+/**
+ * Similar to a normal Promise, a DelayedPromise represents the eventual completion (or failure)
+ * and resulting value of an asynchronous operation ***that has not yet started***.
+ *
+ * The asynchronous operation behind a DelayedPromise will start when any of the following occurs:
+ *  - The DelayedPromise is `await`ed.
+ *  - A callback is attached via `.then()` or `.catch(() => { })`.
+ *  - The asynchronous operation is explicitly started via `.start()`
+ *
+ * Just as normal Promises will never return to their pending state once fulfilled or rejected,
+ * a DelayedPromise will never re-execute its asynchronous operation more than **once**.
+ *
+ * Ultimately, a DelayedPromise is nothing more than some syntactic sugar that allows you to
+ * represent an (asynchronously) lazily-loaded value as an instance property instead of a method.
+ * You could also accomplish something similar by defining an async function as a property getter.
+ * However, since a property defined as a DelayedPromise will not start simply by being accessed,
+ * additional (non-lazily-loaded) "nested" properties can be added.
+ *
+ * [!alert text="*Remember:* Unlike regular Promises in JavaScript, DelayedPromises represent processes that **may not** already be happening." kind="warning"]
+ * @beta
+ */
+class DelayedPromise {
+    /**
+     * Constructs a DelayedPromise object.
+     * @param startCallback The asynchronous callback to execute when this DelayedPromise should be "started".
+     */
+    constructor(startCallback) {
+        // We need this in order to fulfill the Promise interface defined in lib.es2015.symbol.wellknown.d.ts
+        this[_a] = "Promise";
+        let pending;
+        this.start = async () => {
+            pending = pending || startCallback();
+            return pending;
+        };
+    }
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @return A Promise for the completion of which ever callback is executed.
+     */
+    async then(onfulfilled, onrejected) {
+        return this.start().then(onfulfilled, onrejected);
+    }
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @return A Promise for the completion of the callback.
+     */
+    async catch(onrejected) {
+        return this.start().catch(onrejected);
+    }
+    /**
+     * Attaches a callback for only the finally clause of the Promise.
+     * @param onrejected The callback to execute when the Promise is finalized.
+     * @return A Promise for the completion of the callback.
+     */
+    async finally(onFinally) {
+        return this.start().finally(onFinally);
+    }
+}
+exports.DelayedPromise = DelayedPromise;
+_a = Symbol.toStringTag;
+// Because the property getters that wrap `props` are dynamically added, TypeScript isn't aware of them.
+// So by defining this as a class _expression_, we can cast the constructed type to Readonly<TProps> & DelayedPromise<TPayload>
+/**
+ * @beta
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+exports.DelayedPromiseWithProps = (class extends DelayedPromise {
+    constructor(props, cb) {
+        super(cb);
+        const handler = {
+            get: (target, name) => {
+                return (name in this) ? this[name] : target[name];
+            },
+        };
+        return new Proxy(props, handler);
+    }
+});
 //# sourceMappingURL=DelayedPromise.js.map

package/lib/cjs/DelayedPromise.js.map

@@ -1 +1 @@
-{"version":3,"file":"DelayedPromise.js","sourceRoot":"","sources":["../../src/DelayedPromise.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAa,cAAc;IAEzB;;;OAGG;IACH,YAAY,aAA+B;QAQ3C,qGAAqG;QACrF,QAAoB,GAAc,SAAS,CAAC;QAR1D,IAAI,OAA+B,CAAC;QACpC,IAAI,CAAC,KAAK,GAAG,KAAK,IAAI,EAAE;YACtB,OAAO,GAAG,OAAO,IAAI,aAAa,EAAE,CAAC;YACrC,OAAO,OAAO,CAAC;QACjB,CAAC,CAAC;IACJ,CAAC;IAUD;;;;;OAKG;IACI,KAAK,CAAC,IAAI,CAAiC,WAAiF,EAAE,UAAmF;QACtN,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;IACpD,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,KAAK,CAAkB,UAAiF;QACnH,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IACxC,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,OAAO,CAAC,SAA2C;QAC9D,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACzC,CAAC;CACF;AAjDD,wCAiDC;KAlCkB,MAAM,CAAC,WAAW;AAkErC,wGAAwG;AACxG,+HAA+H;AAC/H;;GAEG;AACH,gEAAgE;AACnD,QAAA,uBAAuB,GAAG,CAAC,KAAyD,SAAQ,cAAwB;IAC/H,YAAY,KAAa,EAAE,EAA2B;QACpD,KAAK,CAAC,EAAE,CAAC,CAAC;QAEV,MAAM,OAAO,GAAG;YACd,GAAG,EAAE,CAAC,MAAc,EAAE,IAAY,EAAE,EAAE;gBACpC,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAkB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAoB,CAAC,CAAC;YAClF,CAAC;SACF,CAAC;QAEF,OAAO,IAAI,KAAK,CAAC,KAAK,EAAE,OAAO,CAAgD,CAAC;IAClF,CAAC;CACF,CAAuC,CAAC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/** @packageDocumentation\n * @module Utils\n */\n\n/**\n * Similar to a normal Promise, a DelayedPromise represents the eventual completion (or failure)\n * and resulting value of an asynchronous operation ***that has not yet started***.\n *\n * The asynchronous operation behind a DelayedPromise will start when any of the following occurs:\n *  - The DelayedPromise is `await`ed.\n *  - A callback is attached via `.then()` or `.catch(() => { })`.\n *  - The asynchronous operation is explicitly started via `.start()`\n *\n * Just as normal Promises will never return to their pending state once fulfilled or rejected,\n * a DelayedPromise will never re-execute its asynchronous operation more than **once**.\n *\n * Ultimately, a DelayedPromise is nothing more than some syntactic sugar that allows you to\n * represent an (asynchronously) lazily-loaded value as an instance property instead of a method.\n * You could also accomplish something similar by defining an async function as a property getter.\n * However, since a property defined as a DelayedPromise will not start simply by being accessed,\n * additional (non-lazily-loaded) \"nested\" properties can be added.\n *\n * [!alert text=\"*Remember:* Unlike regular Promises in JavaScript, DelayedPromises represent processes that **may not** already be happening.\" kind=\"warning\"]\n * @beta\n */\nexport class DelayedPromise<T> implements Promise<T> {\n\n  /**\n   * Constructs a DelayedPromise object.\n   * @param startCallback The asynchronous callback to execute when this DelayedPromise should be \"started\".\n   */\n  constructor(startCallback: () => Promise<T>) {\n    let pending: Promise<T> | undefined;\n    this.start = async () => {\n      pending = pending || startCallback();\n      return pending;\n    };\n  }\n\n  // We need this in order to fulfill the Promise interface defined in lib.es2015.symbol.wellknown.d.ts\n  public readonly [Symbol.toStringTag]: \"Promise\" = \"Promise\";\n\n  /**\n   * Explicitly starts the asynchronous operation behind this DelayedPromise (if it hasn't started already).\n   */\n  public start: () => Promise<T>;\n\n  /**\n   * Attaches callbacks for the resolution and/or rejection of the Promise.\n   * @param onfulfilled The callback to execute when the Promise is resolved.\n   * @param onrejected The callback to execute when the Promise is rejected.\n   * @return A Promise for the completion of which ever callback is executed.\n   */\n  public async then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2> {\n    return this.start().then(onfulfilled, onrejected);\n  }\n\n  /**\n   * Attaches a callback for only the rejection of the Promise.\n   * @param onrejected The callback to execute when the Promise is rejected.\n   * @return A Promise for the completion of the callback.\n   */\n  public async catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult> {\n    return this.start().catch(onrejected);\n  }\n\n  /**\n   * Attaches a callback for only the finally clause of the Promise.\n   * @param onrejected The callback to execute when the Promise is finalized.\n   * @return A Promise for the completion of the callback.\n   */\n  public async finally(onFinally?: (() => void) | undefined | null): Promise<T> {\n    return this.start().finally(onFinally);\n  }\n}\n\n// This keeps us from accidentally overriding one of DelayedPromise's methods in the DelayedPromiseWithProps constructor\n/**\n * @beta\n */\nexport interface NoDelayedPromiseMethods {\n  [propName: string]: any;\n  start?: never;\n  then?: never;\n  catch?: never;\n}\n\n// See definition of DelayedPromiseWithProps below\n/**\n * @beta\n */\nexport interface DelayedPromiseWithPropsConstructor {\n\n  /**\n   * Constructs a DelayedPromiseWithProps object, which is at once both:\n   *  - A DelayedPromise object representing the eventual completion (or failure)\n   *    of an asynchronous operation returning a value of type `TPayload`\n   *  - _and_ a readonly \"wrapper\" around an instance of type `TProps`\n   *\n   * @param props An object with properties and methods that will be accessible\n   *              as if they were readonly properties of the DelayedPromiseWithProps object being constructed.\n   * @param startCallback The asynchronous callback to execute when as soon as this DelayedPromise should be \"started\".\n   */\n  new <TProps extends NoDelayedPromiseMethods, TPayload>(props: TProps, startCallback: () => Promise<TPayload>): Readonly<TProps> & DelayedPromise<TPayload>; // eslint-disable-line @typescript-eslint/prefer-function-type\n}\n\n// Because the property getters that wrap `props` are dynamically added, TypeScript isn't aware of them.\n// So by defining this as a class _expression_, we can cast the constructed type to Readonly<TProps> & DelayedPromise<TPayload>\n/**\n * @beta\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const DelayedPromiseWithProps = (class <TProps extends NoDelayedPromiseMethods, TPayload> extends DelayedPromise<TPayload> {\n  constructor(props: TProps, cb: () => Promise<TPayload>) {\n    super(cb);\n\n    const handler = {\n      get: (target: TProps, name: string) => {\n        return (name in this) ? this[name as keyof this] : target[name as keyof TProps];\n      },\n    };\n\n    return new Proxy(props, handler) as Readonly<TProps> & DelayedPromise<TPayload>;\n  }\n}) as DelayedPromiseWithPropsConstructor;\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\n/** Define the type of a DelayedPromiseWithProps instance\n * @beta\n */\nexport type DelayedPromiseWithProps<TProps, TPayload> = Readonly<TProps> & DelayedPromise<TPayload>;\n"]}
+{"version":3,"file":"DelayedPromise.js","sourceRoot":"","sources":["../../src/DelayedPromise.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAa,cAAc;IAEzB;;;OAGG;IACH,YAAY,aAA+B;QAQ3C,qGAAqG;QACrF,QAAoB,GAAc,SAAS,CAAC;QAR1D,IAAI,OAA+B,CAAC;QACpC,IAAI,CAAC,KAAK,GAAG,KAAK,IAAI,EAAE;YACtB,OAAO,GAAG,OAAO,IAAI,aAAa,EAAE,CAAC;YACrC,OAAO,OAAO,CAAC;QACjB,CAAC,CAAC;IACJ,CAAC;IAUD;;;;;OAKG;IACI,KAAK,CAAC,IAAI,CAAiC,WAAiF,EAAE,UAAmF;QACtN,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;IACpD,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,KAAK,CAAkB,UAAiF;QACnH,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IACxC,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,OAAO,CAAC,SAA2C;QAC9D,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACzC,CAAC;CACF;AAjDD,wCAiDC;KAlCkB,MAAM,CAAC,WAAW;AAkErC,wGAAwG;AACxG,+HAA+H;AAC/H;;GAEG;AACH,gEAAgE;AACnD,QAAA,uBAAuB,GAAG,CAAC,KAAyD,SAAQ,cAAwB;IAC/H,YAAY,KAAa,EAAE,EAA2B;QACpD,KAAK,CAAC,EAAE,CAAC,CAAC;QAEV,MAAM,OAAO,GAAG;YACd,GAAG,EAAE,CAAC,MAAc,EAAE,IAAY,EAAE,EAAE;gBACpC,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAkB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAoB,CAAC,CAAC;YAClF,CAAC;SACF,CAAC;QAEF,OAAO,IAAI,KAAK,CAAC,KAAK,EAAE,OAAO,CAAgD,CAAC;IAClF,CAAC;CACF,CAAuC,CAAC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Utils\r\n */\r\n\r\n/**\r\n * Similar to a normal Promise, a DelayedPromise represents the eventual completion (or failure)\r\n * and resulting value of an asynchronous operation ***that has not yet started***.\r\n *\r\n * The asynchronous operation behind a DelayedPromise will start when any of the following occurs:\r\n *  - The DelayedPromise is `await`ed.\r\n *  - A callback is attached via `.then()` or `.catch(() => { })`.\r\n *  - The asynchronous operation is explicitly started via `.start()`\r\n *\r\n * Just as normal Promises will never return to their pending state once fulfilled or rejected,\r\n * a DelayedPromise will never re-execute its asynchronous operation more than **once**.\r\n *\r\n * Ultimately, a DelayedPromise is nothing more than some syntactic sugar that allows you to\r\n * represent an (asynchronously) lazily-loaded value as an instance property instead of a method.\r\n * You could also accomplish something similar by defining an async function as a property getter.\r\n * However, since a property defined as a DelayedPromise will not start simply by being accessed,\r\n * additional (non-lazily-loaded) \"nested\" properties can be added.\r\n *\r\n * [!alert text=\"*Remember:* Unlike regular Promises in JavaScript, DelayedPromises represent processes that **may not** already be happening.\" kind=\"warning\"]\r\n * @beta\r\n */\r\nexport class DelayedPromise<T> implements Promise<T> {\r\n\r\n  /**\r\n   * Constructs a DelayedPromise object.\r\n   * @param startCallback The asynchronous callback to execute when this DelayedPromise should be \"started\".\r\n   */\r\n  constructor(startCallback: () => Promise<T>) {\r\n    let pending: Promise<T> | undefined;\r\n    this.start = async () => {\r\n      pending = pending || startCallback();\r\n      return pending;\r\n    };\r\n  }\r\n\r\n  // We need this in order to fulfill the Promise interface defined in lib.es2015.symbol.wellknown.d.ts\r\n  public readonly [Symbol.toStringTag]: \"Promise\" = \"Promise\";\r\n\r\n  /**\r\n   * Explicitly starts the asynchronous operation behind this DelayedPromise (if it hasn't started already).\r\n   */\r\n  public start: () => Promise<T>;\r\n\r\n  /**\r\n   * Attaches callbacks for the resolution and/or rejection of the Promise.\r\n   * @param onfulfilled The callback to execute when the Promise is resolved.\r\n   * @param onrejected The callback to execute when the Promise is rejected.\r\n   * @return A Promise for the completion of which ever callback is executed.\r\n   */\r\n  public async then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2> {\r\n    return this.start().then(onfulfilled, onrejected);\r\n  }\r\n\r\n  /**\r\n   * Attaches a callback for only the rejection of the Promise.\r\n   * @param onrejected The callback to execute when the Promise is rejected.\r\n   * @return A Promise for the completion of the callback.\r\n   */\r\n  public async catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult> {\r\n    return this.start().catch(onrejected);\r\n  }\r\n\r\n  /**\r\n   * Attaches a callback for only the finally clause of the Promise.\r\n   * @param onrejected The callback to execute when the Promise is finalized.\r\n   * @return A Promise for the completion of the callback.\r\n   */\r\n  public async finally(onFinally?: (() => void) | undefined | null): Promise<T> {\r\n    return this.start().finally(onFinally);\r\n  }\r\n}\r\n\r\n// This keeps us from accidentally overriding one of DelayedPromise's methods in the DelayedPromiseWithProps constructor\r\n/**\r\n * @beta\r\n */\r\nexport interface NoDelayedPromiseMethods {\r\n  [propName: string]: any;\r\n  start?: never;\r\n  then?: never;\r\n  catch?: never;\r\n}\r\n\r\n// See definition of DelayedPromiseWithProps below\r\n/**\r\n * @beta\r\n */\r\nexport interface DelayedPromiseWithPropsConstructor {\r\n\r\n  /**\r\n   * Constructs a DelayedPromiseWithProps object, which is at once both:\r\n   *  - A DelayedPromise object representing the eventual completion (or failure)\r\n   *    of an asynchronous operation returning a value of type `TPayload`\r\n   *  - _and_ a readonly \"wrapper\" around an instance of type `TProps`\r\n   *\r\n   * @param props An object with properties and methods that will be accessible\r\n   *              as if they were readonly properties of the DelayedPromiseWithProps object being constructed.\r\n   * @param startCallback The asynchronous callback to execute when as soon as this DelayedPromise should be \"started\".\r\n   */\r\n  new <TProps extends NoDelayedPromiseMethods, TPayload>(props: TProps, startCallback: () => Promise<TPayload>): Readonly<TProps> & DelayedPromise<TPayload>; // eslint-disable-line @typescript-eslint/prefer-function-type\r\n}\r\n\r\n// Because the property getters that wrap `props` are dynamically added, TypeScript isn't aware of them.\r\n// So by defining this as a class _expression_, we can cast the constructed type to Readonly<TProps> & DelayedPromise<TPayload>\r\n/**\r\n * @beta\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport const DelayedPromiseWithProps = (class <TProps extends NoDelayedPromiseMethods, TPayload> extends DelayedPromise<TPayload> {\r\n  constructor(props: TProps, cb: () => Promise<TPayload>) {\r\n    super(cb);\r\n\r\n    const handler = {\r\n      get: (target: TProps, name: string) => {\r\n        return (name in this) ? this[name as keyof this] : target[name as keyof TProps];\r\n      },\r\n    };\r\n\r\n    return new Proxy(props, handler) as Readonly<TProps> & DelayedPromise<TPayload>;\r\n  }\r\n}) as DelayedPromiseWithPropsConstructor;\r\n\r\n/* eslint-disable @typescript-eslint/no-redeclare */\r\n\r\n/** Define the type of a DelayedPromiseWithProps instance\r\n * @beta\r\n */\r\nexport type DelayedPromiseWithProps<TProps, TPayload> = Readonly<TProps> & DelayedPromise<TPayload>;\r\n"]}

package/lib/cjs/Deserialization/AbstractParser.d.ts

@@ -1,46 +1,46 @@
-import { ConstantProps, CustomAttributeClassProps, EntityClassProps, EnumerationProps, FormatProps, InvertedUnitProps, KindOfQuantityProps, MixinProps, NavigationPropertyProps, PhenomenonProps, PrimitiveArrayPropertyProps, PrimitivePropertyProps, PropertyCategoryProps, RelationshipClassProps, SchemaProps, SchemaReferenceProps, StructArrayPropertyProps, StructClassProps, StructPropertyProps, UnitProps, UnitSystemProps } from "../Deserialization/JsonProps";
-import { CustomAttribute } from "../Metadata/CustomAttribute";
-import { CustomAttributeClass } from "../Metadata/CustomAttributeClass";
-declare type SchemaItemTuple<T> = Readonly<[string /** Name */, string /** SchemaItemType */, Readonly<T>]>;
-declare type PropertyTuple<T> = Readonly<[string /** Name */, string /** Property */, Readonly<T>]>;
-/** @internal */
-export declare type CustomAttributeProvider = (caClass: CustomAttributeClass) => CustomAttribute;
-/** @internal */
-export declare type CAProviderTuple = Readonly<[string /** Full Name */, CustomAttributeProvider]>;
-/** @internal */
-export declare abstract class AbstractParser<TItem = any, TProperty = TItem> {
-    abstract parseSchema(): SchemaProps;
-    abstract getReferences(): Iterable<SchemaReferenceProps>;
-    abstract getItems(): Iterable<SchemaItemTuple<TItem>>;
-    abstract findItem(itemName: string): SchemaItemTuple<TItem> | undefined;
-    abstract parseEntityClass(data: Readonly<TItem>): EntityClassProps;
-    abstract parseMixin(data: Readonly<TItem>): MixinProps;
-    abstract parseStructClass(data: Readonly<TItem>): StructClassProps;
-    abstract parseCustomAttributeClass(data: Readonly<TItem>): CustomAttributeClassProps;
-    abstract parseRelationshipClass(data: Readonly<TItem>): RelationshipClassProps;
-    abstract parseEnumeration(data: Readonly<TItem>): EnumerationProps;
-    abstract parseKindOfQuantity(data: Readonly<TItem>): KindOfQuantityProps;
-    abstract parsePropertyCategory(data: Readonly<TItem>): PropertyCategoryProps;
-    abstract parseUnit(data: Readonly<TItem>): UnitProps;
-    abstract parseInvertedUnit(data: Readonly<TItem>): InvertedUnitProps;
-    abstract parseConstant(data: Readonly<TItem>): ConstantProps;
-    abstract parsePhenomenon(data: Readonly<TItem>): PhenomenonProps;
-    abstract parseFormat(data: Readonly<TItem>): FormatProps;
-    abstract parseUnitSystem(data: Readonly<TItem>): UnitSystemProps;
-    abstract getProperties(data: Readonly<TItem>, itemName: string): Iterable<PropertyTuple<TProperty>>;
-    abstract parsePrimitiveProperty(data: Readonly<TProperty>): PrimitivePropertyProps;
-    abstract parseStructProperty(data: Readonly<TProperty>): StructPropertyProps;
-    abstract parsePrimitiveArrayProperty(data: Readonly<TProperty>): PrimitiveArrayPropertyProps;
-    abstract parseStructArrayProperty(data: Readonly<TProperty>): StructArrayPropertyProps;
-    abstract parseNavigationProperty(data: Readonly<TProperty>): NavigationPropertyProps;
-    abstract getSchemaCustomAttributeProviders(): Iterable<CAProviderTuple>;
-    abstract getClassCustomAttributeProviders(data: Readonly<TItem>): Iterable<CAProviderTuple>;
-    abstract getPropertyCustomAttributeProviders(data: Readonly<TProperty>): Iterable<CAProviderTuple>;
-    abstract getRelationshipConstraintCustomAttributeProviders(data: Readonly<TItem>): [Iterable<CAProviderTuple>, Iterable<CAProviderTuple>];
-}
-/** @internal */
-export interface AbstractParserConstructor<TSchema, TItem = any, TProperty = TItem> {
-    new (obj: Readonly<TSchema>): AbstractParser<TItem, TProperty>;
-}
-export {};
+import { ConstantProps, CustomAttributeClassProps, EntityClassProps, EnumerationProps, FormatProps, InvertedUnitProps, KindOfQuantityProps, MixinProps, NavigationPropertyProps, PhenomenonProps, PrimitiveArrayPropertyProps, PrimitivePropertyProps, PropertyCategoryProps, RelationshipClassProps, SchemaProps, SchemaReferenceProps, StructArrayPropertyProps, StructClassProps, StructPropertyProps, UnitProps, UnitSystemProps } from "../Deserialization/JsonProps";
+import { CustomAttribute } from "../Metadata/CustomAttribute";
+import { CustomAttributeClass } from "../Metadata/CustomAttributeClass";
+declare type SchemaItemTuple<T> = Readonly<[string /** Name */, string /** SchemaItemType */, Readonly<T>]>;
+declare type PropertyTuple<T> = Readonly<[string /** Name */, string /** Property */, Readonly<T>]>;
+/** @internal */
+export declare type CustomAttributeProvider = (caClass: CustomAttributeClass) => CustomAttribute;
+/** @internal */
+export declare type CAProviderTuple = Readonly<[string /** Full Name */, CustomAttributeProvider]>;
+/** @internal */
+export declare abstract class AbstractParser<TItem = any, TProperty = TItem> {
+    abstract parseSchema(): SchemaProps;
+    abstract getReferences(): Iterable<SchemaReferenceProps>;
+    abstract getItems(): Iterable<SchemaItemTuple<TItem>>;
+    abstract findItem(itemName: string): SchemaItemTuple<TItem> | undefined;
+    abstract parseEntityClass(data: Readonly<TItem>): EntityClassProps;
+    abstract parseMixin(data: Readonly<TItem>): MixinProps;
+    abstract parseStructClass(data: Readonly<TItem>): StructClassProps;
+    abstract parseCustomAttributeClass(data: Readonly<TItem>): CustomAttributeClassProps;
+    abstract parseRelationshipClass(data: Readonly<TItem>): RelationshipClassProps;
+    abstract parseEnumeration(data: Readonly<TItem>): EnumerationProps;
+    abstract parseKindOfQuantity(data: Readonly<TItem>): KindOfQuantityProps;
+    abstract parsePropertyCategory(data: Readonly<TItem>): PropertyCategoryProps;
+    abstract parseUnit(data: Readonly<TItem>): UnitProps;
+    abstract parseInvertedUnit(data: Readonly<TItem>): InvertedUnitProps;
+    abstract parseConstant(data: Readonly<TItem>): ConstantProps;
+    abstract parsePhenomenon(data: Readonly<TItem>): PhenomenonProps;
+    abstract parseFormat(data: Readonly<TItem>): FormatProps;
+    abstract parseUnitSystem(data: Readonly<TItem>): UnitSystemProps;
+    abstract getProperties(data: Readonly<TItem>, itemName: string): Iterable<PropertyTuple<TProperty>>;
+    abstract parsePrimitiveProperty(data: Readonly<TProperty>): PrimitivePropertyProps;
+    abstract parseStructProperty(data: Readonly<TProperty>): StructPropertyProps;
+    abstract parsePrimitiveArrayProperty(data: Readonly<TProperty>): PrimitiveArrayPropertyProps;
+    abstract parseStructArrayProperty(data: Readonly<TProperty>): StructArrayPropertyProps;
+    abstract parseNavigationProperty(data: Readonly<TProperty>): NavigationPropertyProps;
+    abstract getSchemaCustomAttributeProviders(): Iterable<CAProviderTuple>;
+    abstract getClassCustomAttributeProviders(data: Readonly<TItem>): Iterable<CAProviderTuple>;
+    abstract getPropertyCustomAttributeProviders(data: Readonly<TProperty>): Iterable<CAProviderTuple>;
+    abstract getRelationshipConstraintCustomAttributeProviders(data: Readonly<TItem>): [Iterable<CAProviderTuple>, Iterable<CAProviderTuple>];
+}
+/** @internal */
+export interface AbstractParserConstructor<TSchema, TItem = any, TProperty = TItem> {
+    new (obj: Readonly<TSchema>): AbstractParser<TItem, TProperty>;
+}
+export {};
 //# sourceMappingURL=AbstractParser.d.ts.map

package/lib/cjs/Deserialization/AbstractParser.js

@@ -1,12 +1,12 @@
-"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.AbstractParser = void 0;
-/** @internal */
-class AbstractParser {
-}
-exports.AbstractParser = AbstractParser;
+"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.AbstractParser = void 0;
+/** @internal */
+class AbstractParser {
+}
+exports.AbstractParser = AbstractParser;
 //# sourceMappingURL=AbstractParser.js.map

package/lib/cjs/Deserialization/AbstractParser.js.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractParser.js","sourceRoot":"","sources":["../../../src/Deserialization/AbstractParser.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;;;AAmB/F,gBAAgB;AAChB,MAAsB,cAAc;CAiCnC;AAjCD,wCAiCC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n\nimport {\n  ConstantProps, CustomAttributeClassProps, EntityClassProps, EnumerationProps, FormatProps, InvertedUnitProps, KindOfQuantityProps, MixinProps,\n  NavigationPropertyProps, PhenomenonProps, PrimitiveArrayPropertyProps, PrimitivePropertyProps, PropertyCategoryProps, RelationshipClassProps,\n  SchemaProps, SchemaReferenceProps, StructArrayPropertyProps, StructClassProps, StructPropertyProps, UnitProps, UnitSystemProps,\n} from \"../Deserialization/JsonProps\";\nimport { CustomAttribute } from \"../Metadata/CustomAttribute\";\nimport { CustomAttributeClass } from \"../Metadata/CustomAttributeClass\";\n\ntype SchemaItemTuple<T> = Readonly<[string /** Name */, string /** SchemaItemType */, Readonly<T>]>;\ntype PropertyTuple<T> = Readonly<[string /** Name */, string /** Property */, Readonly<T>]>;\n\n/** @internal */\nexport type CustomAttributeProvider = (caClass: CustomAttributeClass) => CustomAttribute;\n\n/** @internal */\nexport type CAProviderTuple = Readonly<[string /** Full Name */, CustomAttributeProvider]>;\n\n/** @internal */\nexport abstract class AbstractParser<TItem = any, TProperty = TItem> {\n  public abstract parseSchema(): SchemaProps;\n  public abstract getReferences(): Iterable<SchemaReferenceProps>;\n\n  public abstract getItems(): Iterable<SchemaItemTuple<TItem>>;\n  public abstract findItem(itemName: string): SchemaItemTuple<TItem> | undefined;\n\n  public abstract parseEntityClass(data: Readonly<TItem>): EntityClassProps;\n  public abstract parseMixin(data: Readonly<TItem>): MixinProps;\n  public abstract parseStructClass(data: Readonly<TItem>): StructClassProps;\n  public abstract parseCustomAttributeClass(data: Readonly<TItem>): CustomAttributeClassProps;\n  public abstract parseRelationshipClass(data: Readonly<TItem>): RelationshipClassProps;\n  public abstract parseEnumeration(data: Readonly<TItem>): EnumerationProps;\n  public abstract parseKindOfQuantity(data: Readonly<TItem>): KindOfQuantityProps;\n  public abstract parsePropertyCategory(data: Readonly<TItem>): PropertyCategoryProps;\n  public abstract parseUnit(data: Readonly<TItem>): UnitProps;\n  public abstract parseInvertedUnit(data: Readonly<TItem>): InvertedUnitProps;\n  public abstract parseConstant(data: Readonly<TItem>): ConstantProps;\n  public abstract parsePhenomenon(data: Readonly<TItem>): PhenomenonProps;\n  public abstract parseFormat(data: Readonly<TItem>): FormatProps;\n  public abstract parseUnitSystem(data: Readonly<TItem>): UnitSystemProps;\n\n  public abstract getProperties(data: Readonly<TItem>, itemName: string): Iterable<PropertyTuple<TProperty>>;\n  public abstract parsePrimitiveProperty(data: Readonly<TProperty>): PrimitivePropertyProps;\n  public abstract parseStructProperty(data: Readonly<TProperty>): StructPropertyProps;\n  public abstract parsePrimitiveArrayProperty(data: Readonly<TProperty>): PrimitiveArrayPropertyProps;\n  public abstract parseStructArrayProperty(data: Readonly<TProperty>): StructArrayPropertyProps;\n  public abstract parseNavigationProperty(data: Readonly<TProperty>): NavigationPropertyProps;\n\n  public abstract getSchemaCustomAttributeProviders(): Iterable<CAProviderTuple>;\n  public abstract getClassCustomAttributeProviders(data: Readonly<TItem>): Iterable<CAProviderTuple>;\n  public abstract getPropertyCustomAttributeProviders(data: Readonly<TProperty>): Iterable<CAProviderTuple>;\n  public abstract getRelationshipConstraintCustomAttributeProviders(data: Readonly<TItem>): [Iterable<CAProviderTuple> /* source */, Iterable<CAProviderTuple> /* target */];\n}\n\n/** @internal */\n// eslint-disable-next-line @typescript-eslint/prefer-function-type\nexport interface AbstractParserConstructor<TSchema, TItem = any, TProperty = TItem> { new(obj: Readonly<TSchema>): AbstractParser<TItem, TProperty> }\n"]}
+{"version":3,"file":"AbstractParser.js","sourceRoot":"","sources":["../../../src/Deserialization/AbstractParser.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;;;AAmB/F,gBAAgB;AAChB,MAAsB,cAAc;CAiCnC;AAjCD,wCAiCC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n\r\nimport {\r\n  ConstantProps, CustomAttributeClassProps, EntityClassProps, EnumerationProps, FormatProps, InvertedUnitProps, KindOfQuantityProps, MixinProps,\r\n  NavigationPropertyProps, PhenomenonProps, PrimitiveArrayPropertyProps, PrimitivePropertyProps, PropertyCategoryProps, RelationshipClassProps,\r\n  SchemaProps, SchemaReferenceProps, StructArrayPropertyProps, StructClassProps, StructPropertyProps, UnitProps, UnitSystemProps,\r\n} from \"../Deserialization/JsonProps\";\r\nimport { CustomAttribute } from \"../Metadata/CustomAttribute\";\r\nimport { CustomAttributeClass } from \"../Metadata/CustomAttributeClass\";\r\n\r\ntype SchemaItemTuple<T> = Readonly<[string /** Name */, string /** SchemaItemType */, Readonly<T>]>;\r\ntype PropertyTuple<T> = Readonly<[string /** Name */, string /** Property */, Readonly<T>]>;\r\n\r\n/** @internal */\r\nexport type CustomAttributeProvider = (caClass: CustomAttributeClass) => CustomAttribute;\r\n\r\n/** @internal */\r\nexport type CAProviderTuple = Readonly<[string /** Full Name */, CustomAttributeProvider]>;\r\n\r\n/** @internal */\r\nexport abstract class AbstractParser<TItem = any, TProperty = TItem> {\r\n  public abstract parseSchema(): SchemaProps;\r\n  public abstract getReferences(): Iterable<SchemaReferenceProps>;\r\n\r\n  public abstract getItems(): Iterable<SchemaItemTuple<TItem>>;\r\n  public abstract findItem(itemName: string): SchemaItemTuple<TItem> | undefined;\r\n\r\n  public abstract parseEntityClass(data: Readonly<TItem>): EntityClassProps;\r\n  public abstract parseMixin(data: Readonly<TItem>): MixinProps;\r\n  public abstract parseStructClass(data: Readonly<TItem>): StructClassProps;\r\n  public abstract parseCustomAttributeClass(data: Readonly<TItem>): CustomAttributeClassProps;\r\n  public abstract parseRelationshipClass(data: Readonly<TItem>): RelationshipClassProps;\r\n  public abstract parseEnumeration(data: Readonly<TItem>): EnumerationProps;\r\n  public abstract parseKindOfQuantity(data: Readonly<TItem>): KindOfQuantityProps;\r\n  public abstract parsePropertyCategory(data: Readonly<TItem>): PropertyCategoryProps;\r\n  public abstract parseUnit(data: Readonly<TItem>): UnitProps;\r\n  public abstract parseInvertedUnit(data: Readonly<TItem>): InvertedUnitProps;\r\n  public abstract parseConstant(data: Readonly<TItem>): ConstantProps;\r\n  public abstract parsePhenomenon(data: Readonly<TItem>): PhenomenonProps;\r\n  public abstract parseFormat(data: Readonly<TItem>): FormatProps;\r\n  public abstract parseUnitSystem(data: Readonly<TItem>): UnitSystemProps;\r\n\r\n  public abstract getProperties(data: Readonly<TItem>, itemName: string): Iterable<PropertyTuple<TProperty>>;\r\n  public abstract parsePrimitiveProperty(data: Readonly<TProperty>): PrimitivePropertyProps;\r\n  public abstract parseStructProperty(data: Readonly<TProperty>): StructPropertyProps;\r\n  public abstract parsePrimitiveArrayProperty(data: Readonly<TProperty>): PrimitiveArrayPropertyProps;\r\n  public abstract parseStructArrayProperty(data: Readonly<TProperty>): StructArrayPropertyProps;\r\n  public abstract parseNavigationProperty(data: Readonly<TProperty>): NavigationPropertyProps;\r\n\r\n  public abstract getSchemaCustomAttributeProviders(): Iterable<CAProviderTuple>;\r\n  public abstract getClassCustomAttributeProviders(data: Readonly<TItem>): Iterable<CAProviderTuple>;\r\n  public abstract getPropertyCustomAttributeProviders(data: Readonly<TProperty>): Iterable<CAProviderTuple>;\r\n  public abstract getRelationshipConstraintCustomAttributeProviders(data: Readonly<TItem>): [Iterable<CAProviderTuple> /* source */, Iterable<CAProviderTuple> /* target */];\r\n}\r\n\r\n/** @internal */\r\n// eslint-disable-next-line @typescript-eslint/prefer-function-type\r\nexport interface AbstractParserConstructor<TSchema, TItem = any, TProperty = TItem> { new(obj: Readonly<TSchema>): AbstractParser<TItem, TProperty> }\r\n"]}