@itwin/core-common 4.0.0-dev.17 → 4.0.0-dev.18

package/lib/cjs/rpc/TestRpcManager.js

@@ -1,41 +1,41 @@
-"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 RpcInterface
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestRpcManager = void 0;
-const RpcConfiguration_1 = require("./core/RpcConfiguration");
-/* eslint-disable deprecation/deprecation */
-/** An RpcManager that uses RpcDefaultConfiguration/RpcDirectProtocol to make client stubs invoke
- * registered server impls as direct method calls within the same JavaScript context. In other words,
- * TestRpcManager sets up a protocol that uses our remoting mechanism but cuts out the communication
- * part of it. (No IPC or XHR is used or required.)
- * Nevertheless, all of the rest of the call marshalling and operation monitoring mechanism is used.
- * That makes TestRpcManager a way to write simple, single-process integration tests for frontends
- * and backends that actually use RpcInterfaces. Note that to write such a single-process integration
- * test, you must make *both* client and server use TestRpcManager to configure their RpcInterfaces.
- * It will not work if one side uses TestRpcManager and the other uses some other protocol (say, cloud).
- * That means that you must actually program the backend to know when it is running in direct test
- * mode and to employ TestRpcManager in that case.
- * @internal
- */
-class TestRpcManager {
-    static initialize(interfaces) {
-        const config = class extends RpcConfiguration_1.RpcDefaultConfiguration {
-            constructor() {
-                super(...arguments);
-                this.interfaces = () => interfaces;
-            }
-        };
-        for (const def of interfaces)
-            RpcConfiguration_1.RpcConfiguration.assign(def, () => RpcConfiguration_1.RpcDefaultConfiguration);
-        const instance = RpcConfiguration_1.RpcConfiguration.obtain(config);
-        RpcConfiguration_1.RpcConfiguration.initializeInterfaces(instance);
-    }
-}
-exports.TestRpcManager = TestRpcManager;
+"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 RpcInterface
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestRpcManager = void 0;
+const RpcConfiguration_1 = require("./core/RpcConfiguration");
+/* eslint-disable deprecation/deprecation */
+/** An RpcManager that uses RpcDefaultConfiguration/RpcDirectProtocol to make client stubs invoke
+ * registered server impls as direct method calls within the same JavaScript context. In other words,
+ * TestRpcManager sets up a protocol that uses our remoting mechanism but cuts out the communication
+ * part of it. (No IPC or XHR is used or required.)
+ * Nevertheless, all of the rest of the call marshalling and operation monitoring mechanism is used.
+ * That makes TestRpcManager a way to write simple, single-process integration tests for frontends
+ * and backends that actually use RpcInterfaces. Note that to write such a single-process integration
+ * test, you must make *both* client and server use TestRpcManager to configure their RpcInterfaces.
+ * It will not work if one side uses TestRpcManager and the other uses some other protocol (say, cloud).
+ * That means that you must actually program the backend to know when it is running in direct test
+ * mode and to employ TestRpcManager in that case.
+ * @internal
+ */
+class TestRpcManager {
+    static initialize(interfaces) {
+        const config = class extends RpcConfiguration_1.RpcDefaultConfiguration {
+            constructor() {
+                super(...arguments);
+                this.interfaces = () => interfaces;
+            }
+        };
+        for (const def of interfaces)
+            RpcConfiguration_1.RpcConfiguration.assign(def, () => RpcConfiguration_1.RpcDefaultConfiguration);
+        const instance = RpcConfiguration_1.RpcConfiguration.obtain(config);
+        RpcConfiguration_1.RpcConfiguration.initializeInterfaces(instance);
+    }
+}
+exports.TestRpcManager = TestRpcManager;
 //# sourceMappingURL=TestRpcManager.js.map

package/lib/cjs/rpc/TestRpcManager.js.map

@@ -1 +1 @@
-{"version":3,"file":"TestRpcManager.js","sourceRoot":"","sources":["../../../src/rpc/TestRpcManager.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAGH,8DAAoF;AAEpF,4CAA4C;AAE5C;;;;;;;;;;;;GAYG;AACH,MAAa,cAAc;IAClB,MAAM,CAAC,UAAU,CAAC,UAAoC;QAC3D,MAAM,MAAM,GAAG,KAAM,SAAQ,0CAAuB;YAArC;;gBACG,eAAU,GAAQ,GAAG,EAAE,CAAC,UAAU,CAAC;YACrD,CAAC;SAAA,CAAC;QAEF,KAAK,MAAM,GAAG,IAAI,UAAU;YAC1B,mCAAgB,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,0CAAuB,CAAC,CAAC;QAE9D,MAAM,QAAQ,GAAG,mCAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACjD,mCAAgB,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IAClD,CAAC;CACF;AAZD,wCAYC","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 RpcInterface\n */\n\nimport { RpcInterfaceDefinition } from \"../RpcInterface\";\nimport { RpcConfiguration, RpcDefaultConfiguration } from \"./core/RpcConfiguration\";\n\n/* eslint-disable deprecation/deprecation */\n\n/** An RpcManager that uses RpcDefaultConfiguration/RpcDirectProtocol to make client stubs invoke\n * registered server impls as direct method calls within the same JavaScript context. In other words,\n * TestRpcManager sets up a protocol that uses our remoting mechanism but cuts out the communication\n * part of it. (No IPC or XHR is used or required.)\n * Nevertheless, all of the rest of the call marshalling and operation monitoring mechanism is used.\n * That makes TestRpcManager a way to write simple, single-process integration tests for frontends\n * and backends that actually use RpcInterfaces. Note that to write such a single-process integration\n * test, you must make *both* client and server use TestRpcManager to configure their RpcInterfaces.\n * It will not work if one side uses TestRpcManager and the other uses some other protocol (say, cloud).\n * That means that you must actually program the backend to know when it is running in direct test\n * mode and to employ TestRpcManager in that case.\n * @internal\n */\nexport class TestRpcManager {\n  public static initialize(interfaces: RpcInterfaceDefinition[]) {\n    const config = class extends RpcDefaultConfiguration {\n      public override interfaces: any = () => interfaces;\n    };\n\n    for (const def of interfaces)\n      RpcConfiguration.assign(def, () => RpcDefaultConfiguration);\n\n    const instance = RpcConfiguration.obtain(config);\n    RpcConfiguration.initializeInterfaces(instance);\n  }\n}\n"]}
+{"version":3,"file":"TestRpcManager.js","sourceRoot":"","sources":["../../../src/rpc/TestRpcManager.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAGH,8DAAoF;AAEpF,4CAA4C;AAE5C;;;;;;;;;;;;GAYG;AACH,MAAa,cAAc;IAClB,MAAM,CAAC,UAAU,CAAC,UAAoC;QAC3D,MAAM,MAAM,GAAG,KAAM,SAAQ,0CAAuB;YAArC;;gBACG,eAAU,GAAQ,GAAG,EAAE,CAAC,UAAU,CAAC;YACrD,CAAC;SAAA,CAAC;QAEF,KAAK,MAAM,GAAG,IAAI,UAAU;YAC1B,mCAAgB,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,0CAAuB,CAAC,CAAC;QAE9D,MAAM,QAAQ,GAAG,mCAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACjD,mCAAgB,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IAClD,CAAC;CACF;AAZD,wCAYC","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 RpcInterface\r\n */\r\n\r\nimport { RpcInterfaceDefinition } from \"../RpcInterface\";\r\nimport { RpcConfiguration, RpcDefaultConfiguration } from \"./core/RpcConfiguration\";\r\n\r\n/* eslint-disable deprecation/deprecation */\r\n\r\n/** An RpcManager that uses RpcDefaultConfiguration/RpcDirectProtocol to make client stubs invoke\r\n * registered server impls as direct method calls within the same JavaScript context. In other words,\r\n * TestRpcManager sets up a protocol that uses our remoting mechanism but cuts out the communication\r\n * part of it. (No IPC or XHR is used or required.)\r\n * Nevertheless, all of the rest of the call marshalling and operation monitoring mechanism is used.\r\n * That makes TestRpcManager a way to write simple, single-process integration tests for frontends\r\n * and backends that actually use RpcInterfaces. Note that to write such a single-process integration\r\n * test, you must make *both* client and server use TestRpcManager to configure their RpcInterfaces.\r\n * It will not work if one side uses TestRpcManager and the other uses some other protocol (say, cloud).\r\n * That means that you must actually program the backend to know when it is running in direct test\r\n * mode and to employ TestRpcManager in that case.\r\n * @internal\r\n */\r\nexport class TestRpcManager {\r\n  public static initialize(interfaces: RpcInterfaceDefinition[]) {\r\n    const config = class extends RpcDefaultConfiguration {\r\n      public override interfaces: any = () => interfaces;\r\n    };\r\n\r\n    for (const def of interfaces)\r\n      RpcConfiguration.assign(def, () => RpcDefaultConfiguration);\r\n\r\n    const instance = RpcConfiguration.obtain(config);\r\n    RpcConfiguration.initializeInterfaces(instance);\r\n  }\r\n}\r\n"]}

package/lib/cjs/rpc/WipRpcInterface.d.ts

@@ -1,30 +1,30 @@
-/** @packageDocumentation
- * @module RpcInterface
- */
-import { ChangedElements } from "../ChangedElements";
-import { IModelRpcProps } from "../IModel";
-import { RpcInterface } from "../RpcInterface";
-/** The purpose of this class is to house WIP RPC methods. For example:
- * - WIP methods where signatures or behavior is still changing
- * - Experimental methods that we may decide are a bad idea and never release
- * The idea is to house these WIP RPC methods away from other RpcInterfaces that have stated compatibility goals.
- * Once stable, the goal is to move methods out to their rightful home.
- * Apps/services should understand the *flux* implied by registering this RpcInterface and should be in control of both the client and server before even considering using it.
- * @internal
- */
-export declare abstract class WipRpcInterface extends RpcInterface {
-    /** Returns the IModelReadRpcInterface instance for the frontend. */
-    static getClient(): WipRpcInterface;
-    /** The immutable name of the interface. */
-    static readonly interfaceName = "WipRpcInterface";
-    /** The semantic version of the interface.
-     * @note The WipRpcInterface will never progress to 1.0 since it is never intended to be public.
-     */
-    static interfaceVersion: string;
-    placeholder(_iModelToken: IModelRpcProps): Promise<string>;
-    isChangeCacheAttached(_iModelToken: IModelRpcProps): Promise<boolean>;
-    attachChangeCache(_iModelToken: IModelRpcProps): Promise<void>;
-    getChangedElements(_iModelToken: IModelRpcProps, _startChangesetId: string, _endChangesetId: string): Promise<ChangedElements | undefined>;
-    isChangesetProcessed(_iModelToken: IModelRpcProps, _changesetId: string): Promise<boolean>;
-}
+/** @packageDocumentation
+ * @module RpcInterface
+ */
+import { ChangedElements } from "../ChangedElements";
+import { IModelRpcProps } from "../IModel";
+import { RpcInterface } from "../RpcInterface";
+/** The purpose of this class is to house WIP RPC methods. For example:
+ * - WIP methods where signatures or behavior is still changing
+ * - Experimental methods that we may decide are a bad idea and never release
+ * The idea is to house these WIP RPC methods away from other RpcInterfaces that have stated compatibility goals.
+ * Once stable, the goal is to move methods out to their rightful home.
+ * Apps/services should understand the *flux* implied by registering this RpcInterface and should be in control of both the client and server before even considering using it.
+ * @internal
+ */
+export declare abstract class WipRpcInterface extends RpcInterface {
+    /** Returns the IModelReadRpcInterface instance for the frontend. */
+    static getClient(): WipRpcInterface;
+    /** The immutable name of the interface. */
+    static readonly interfaceName = "WipRpcInterface";
+    /** The semantic version of the interface.
+     * @note The WipRpcInterface will never progress to 1.0 since it is never intended to be public.
+     */
+    static interfaceVersion: string;
+    placeholder(_iModelToken: IModelRpcProps): Promise<string>;
+    isChangeCacheAttached(_iModelToken: IModelRpcProps): Promise<boolean>;
+    attachChangeCache(_iModelToken: IModelRpcProps): Promise<void>;
+    getChangedElements(_iModelToken: IModelRpcProps, _startChangesetId: string, _endChangesetId: string): Promise<ChangedElements | undefined>;
+    isChangesetProcessed(_iModelToken: IModelRpcProps, _changesetId: string): Promise<boolean>;
+}
 //# sourceMappingURL=WipRpcInterface.d.ts.map

package/lib/cjs/rpc/WipRpcInterface.js

@@ -1,41 +1,41 @@
-"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 RpcInterface
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WipRpcInterface = void 0;
-const RpcInterface_1 = require("../RpcInterface");
-const RpcManager_1 = require("../RpcManager");
-/** The purpose of this class is to house WIP RPC methods. For example:
- * - WIP methods where signatures or behavior is still changing
- * - Experimental methods that we may decide are a bad idea and never release
- * The idea is to house these WIP RPC methods away from other RpcInterfaces that have stated compatibility goals.
- * Once stable, the goal is to move methods out to their rightful home.
- * Apps/services should understand the *flux* implied by registering this RpcInterface and should be in control of both the client and server before even considering using it.
- * @internal
- */
-class WipRpcInterface extends RpcInterface_1.RpcInterface {
-    /** Returns the IModelReadRpcInterface instance for the frontend. */
-    static getClient() { return RpcManager_1.RpcManager.getClientForInterface(WipRpcInterface); }
-    /*===========================================================================================
-      NOTE: Any add/remove/change to the methods below requires an update of the interface version.
-      NOTE: Please consult the README in this folder for the semantic versioning rules.
-    ==========================================================================================*/
-    async placeholder(_iModelToken) { return this.forward(arguments); } // here to test that WipRpcInterface is configured properly
-    async isChangeCacheAttached(_iModelToken) { return this.forward(arguments); }
-    async attachChangeCache(_iModelToken) { return this.forward(arguments); }
-    async getChangedElements(_iModelToken, _startChangesetId, _endChangesetId) { return this.forward(arguments); }
-    async isChangesetProcessed(_iModelToken, _changesetId) { return this.forward(arguments); }
-}
-exports.WipRpcInterface = WipRpcInterface;
-/** The immutable name of the interface. */
-WipRpcInterface.interfaceName = "WipRpcInterface";
-/** The semantic version of the interface.
- * @note The WipRpcInterface will never progress to 1.0 since it is never intended to be public.
- */
-WipRpcInterface.interfaceVersion = "0.5.0";
+"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 RpcInterface
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WipRpcInterface = void 0;
+const RpcInterface_1 = require("../RpcInterface");
+const RpcManager_1 = require("../RpcManager");
+/** The purpose of this class is to house WIP RPC methods. For example:
+ * - WIP methods where signatures or behavior is still changing
+ * - Experimental methods that we may decide are a bad idea and never release
+ * The idea is to house these WIP RPC methods away from other RpcInterfaces that have stated compatibility goals.
+ * Once stable, the goal is to move methods out to their rightful home.
+ * Apps/services should understand the *flux* implied by registering this RpcInterface and should be in control of both the client and server before even considering using it.
+ * @internal
+ */
+class WipRpcInterface extends RpcInterface_1.RpcInterface {
+    /** Returns the IModelReadRpcInterface instance for the frontend. */
+    static getClient() { return RpcManager_1.RpcManager.getClientForInterface(WipRpcInterface); }
+    /*===========================================================================================
+      NOTE: Any add/remove/change to the methods below requires an update of the interface version.
+      NOTE: Please consult the README in this folder for the semantic versioning rules.
+    ==========================================================================================*/
+    async placeholder(_iModelToken) { return this.forward(arguments); } // here to test that WipRpcInterface is configured properly
+    async isChangeCacheAttached(_iModelToken) { return this.forward(arguments); }
+    async attachChangeCache(_iModelToken) { return this.forward(arguments); }
+    async getChangedElements(_iModelToken, _startChangesetId, _endChangesetId) { return this.forward(arguments); }
+    async isChangesetProcessed(_iModelToken, _changesetId) { return this.forward(arguments); }
+}
+exports.WipRpcInterface = WipRpcInterface;
+/** The immutable name of the interface. */
+WipRpcInterface.interfaceName = "WipRpcInterface";
+/** The semantic version of the interface.
+ * @note The WipRpcInterface will never progress to 1.0 since it is never intended to be public.
+ */
+WipRpcInterface.interfaceVersion = "0.5.0";
 //# sourceMappingURL=WipRpcInterface.js.map

package/lib/cjs/rpc/WipRpcInterface.js.map

@@ -1 +1 @@
-{"version":3,"file":"WipRpcInterface.js","sourceRoot":"","sources":["../../../src/rpc/WipRpcInterface.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAIH,kDAA+C;AAC/C,8CAA2C;AAE3C;;;;;;;GAOG;AACH,MAAsB,eAAgB,SAAQ,2BAAY;IACxD,oEAAoE;IAC7D,MAAM,CAAC,SAAS,KAAsB,OAAO,uBAAU,CAAC,qBAAqB,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;IAUxG;;;gGAG4F;IACrF,KAAK,CAAC,WAAW,CAAC,YAA4B,IAAqB,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,2DAA2D;IAChK,KAAK,CAAC,qBAAqB,CAAC,YAA4B,IAAsB,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAC/G,KAAK,CAAC,iBAAiB,CAAC,YAA4B,IAAmB,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACxG,KAAK,CAAC,kBAAkB,CAAC,YAA4B,EAAE,iBAAyB,EAAE,eAAuB,IAA0C,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACpL,KAAK,CAAC,oBAAoB,CAAC,YAA4B,EAAE,YAAoB,IAAsB,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;;AApB7I,0CAqBC;AAjBC,2CAA2C;AACpB,6BAAa,GAAG,iBAAiB,CAAC;AAEzD;;GAEG;AACW,gCAAgB,GAAG,OAAO,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 RpcInterface\n */\n\nimport { ChangedElements } from \"../ChangedElements\";\nimport { IModelRpcProps } from \"../IModel\";\nimport { RpcInterface } from \"../RpcInterface\";\nimport { RpcManager } from \"../RpcManager\";\n\n/** The purpose of this class is to house WIP RPC methods. For example:\n * - WIP methods where signatures or behavior is still changing\n * - Experimental methods that we may decide are a bad idea and never release\n * The idea is to house these WIP RPC methods away from other RpcInterfaces that have stated compatibility goals.\n * Once stable, the goal is to move methods out to their rightful home.\n * Apps/services should understand the *flux* implied by registering this RpcInterface and should be in control of both the client and server before even considering using it.\n * @internal\n */\nexport abstract class WipRpcInterface extends RpcInterface { // eslint-disable-line deprecation/deprecation\n  /** Returns the IModelReadRpcInterface instance for the frontend. */\n  public static getClient(): WipRpcInterface { return RpcManager.getClientForInterface(WipRpcInterface); }\n\n  /** The immutable name of the interface. */\n  public static readonly interfaceName = \"WipRpcInterface\";\n\n  /** The semantic version of the interface.\n   * @note The WipRpcInterface will never progress to 1.0 since it is never intended to be public.\n   */\n  public static interfaceVersion = \"0.5.0\";\n\n  /*===========================================================================================\n    NOTE: Any add/remove/change to the methods below requires an update of the interface version.\n    NOTE: Please consult the README in this folder for the semantic versioning rules.\n  ==========================================================================================*/\n  public async placeholder(_iModelToken: IModelRpcProps): Promise<string> { return this.forward(arguments); } // here to test that WipRpcInterface is configured properly\n  public async isChangeCacheAttached(_iModelToken: IModelRpcProps): Promise<boolean> { return this.forward(arguments); }\n  public async attachChangeCache(_iModelToken: IModelRpcProps): Promise<void> { return this.forward(arguments); }\n  public async getChangedElements(_iModelToken: IModelRpcProps, _startChangesetId: string, _endChangesetId: string): Promise<ChangedElements | undefined> { return this.forward(arguments); }\n  public async isChangesetProcessed(_iModelToken: IModelRpcProps, _changesetId: string): Promise<boolean> { return this.forward(arguments); }\n}\n"]}
+{"version":3,"file":"WipRpcInterface.js","sourceRoot":"","sources":["../../../src/rpc/WipRpcInterface.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAIH,kDAA+C;AAC/C,8CAA2C;AAE3C;;;;;;;GAOG;AACH,MAAsB,eAAgB,SAAQ,2BAAY;IACxD,oEAAoE;IAC7D,MAAM,CAAC,SAAS,KAAsB,OAAO,uBAAU,CAAC,qBAAqB,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;IAUxG;;;gGAG4F;IACrF,KAAK,CAAC,WAAW,CAAC,YAA4B,IAAqB,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,2DAA2D;IAChK,KAAK,CAAC,qBAAqB,CAAC,YAA4B,IAAsB,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAC/G,KAAK,CAAC,iBAAiB,CAAC,YAA4B,IAAmB,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACxG,KAAK,CAAC,kBAAkB,CAAC,YAA4B,EAAE,iBAAyB,EAAE,eAAuB,IAA0C,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACpL,KAAK,CAAC,oBAAoB,CAAC,YAA4B,EAAE,YAAoB,IAAsB,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;;AApB7I,0CAqBC;AAjBC,2CAA2C;AACpB,6BAAa,GAAG,iBAAiB,CAAC;AAEzD;;GAEG;AACW,gCAAgB,GAAG,OAAO,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 RpcInterface\r\n */\r\n\r\nimport { ChangedElements } from \"../ChangedElements\";\r\nimport { IModelRpcProps } from \"../IModel\";\r\nimport { RpcInterface } from \"../RpcInterface\";\r\nimport { RpcManager } from \"../RpcManager\";\r\n\r\n/** The purpose of this class is to house WIP RPC methods. For example:\r\n * - WIP methods where signatures or behavior is still changing\r\n * - Experimental methods that we may decide are a bad idea and never release\r\n * The idea is to house these WIP RPC methods away from other RpcInterfaces that have stated compatibility goals.\r\n * Once stable, the goal is to move methods out to their rightful home.\r\n * Apps/services should understand the *flux* implied by registering this RpcInterface and should be in control of both the client and server before even considering using it.\r\n * @internal\r\n */\r\nexport abstract class WipRpcInterface extends RpcInterface { // eslint-disable-line deprecation/deprecation\r\n  /** Returns the IModelReadRpcInterface instance for the frontend. */\r\n  public static getClient(): WipRpcInterface { return RpcManager.getClientForInterface(WipRpcInterface); }\r\n\r\n  /** The immutable name of the interface. */\r\n  public static readonly interfaceName = \"WipRpcInterface\";\r\n\r\n  /** The semantic version of the interface.\r\n   * @note The WipRpcInterface will never progress to 1.0 since it is never intended to be public.\r\n   */\r\n  public static interfaceVersion = \"0.5.0\";\r\n\r\n  /*===========================================================================================\r\n    NOTE: Any add/remove/change to the methods below requires an update of the interface version.\r\n    NOTE: Please consult the README in this folder for the semantic versioning rules.\r\n  ==========================================================================================*/\r\n  public async placeholder(_iModelToken: IModelRpcProps): Promise<string> { return this.forward(arguments); } // here to test that WipRpcInterface is configured properly\r\n  public async isChangeCacheAttached(_iModelToken: IModelRpcProps): Promise<boolean> { return this.forward(arguments); }\r\n  public async attachChangeCache(_iModelToken: IModelRpcProps): Promise<void> { return this.forward(arguments); }\r\n  public async getChangedElements(_iModelToken: IModelRpcProps, _startChangesetId: string, _endChangesetId: string): Promise<ChangedElements | undefined> { return this.forward(arguments); }\r\n  public async isChangesetProcessed(_iModelToken: IModelRpcProps, _changesetId: string): Promise<boolean> { return this.forward(arguments); }\r\n}\r\n"]}

package/lib/cjs/rpc/core/RpcConfiguration.d.ts

@@ -1,112 +1,112 @@
-/** @packageDocumentation
- * @module RpcInterface
- */
-import { RpcInterface, RpcInterfaceDefinition } from "../../RpcInterface";
-import { RpcControlChannel } from "./RpcControl";
-import { RpcProtocol, RpcRequestFulfillment } from "./RpcProtocol";
-import { RpcRequest } from "./RpcRequest";
-import { RpcRequestContext } from "./RpcRequestContext";
-import { RpcRoutingToken } from "./RpcRoutingToken";
-/** @internal */
-export declare type RpcConfigurationSupplier = (routing?: RpcRoutingToken) => {
-    new (): RpcConfiguration;
-};
-/** @internal */
-export interface RpcRoutingMap extends RpcConfigurationSupplier {
-    configurations: Map<number, RpcConfigurationSupplier>;
-}
-/** @internal */
-export declare namespace RpcRoutingMap {
-    function create(): RpcRoutingMap;
-}
-/** A RpcConfiguration specifies how calls on an RPC interface will be marshalled, plus other operating parameters.
- * RpcConfiguration is the base class for specific configurations.
- * @internal
- */
-export declare abstract class RpcConfiguration {
-    /** Whether development mode is enabled.
-     * @note This parameter determines whether developer convenience features like backend stack traces are available.
-     */
-    static developmentMode: boolean;
-    /** Whether frontend checks that are relevant in a cloud-hosted routing scenario are disabled. */
-    static disableRoutingValidation: boolean;
-    /** Whether strict mode is enabled.
-     * This parameter determines system behaviors relating to strict checking:
-     * - Whether an error is thrown if the type marshaling system encounters an unregistered type (only in strict mode).
-     */
-    static strictMode: boolean;
-    /**
-     * Whether to throw an error when the IModelRpcProps in the operation parameter list differs from the token in the URL.
-     * @note By default, a warning is logged and the operation is allowed to proceed.
-     * @note The parameter token is always replaced by the url token (unless RpcOperationPolicy.allowTokenMismatch is set).
-     */
-    static throwOnTokenMismatch: boolean;
-    /** Sets the configuration supplier for an RPC interface class. */
-    static assign<T extends RpcInterface>(definition: RpcInterfaceDefinition<T>, supplier: RpcConfigurationSupplier): void;
-    /** Sets the configuration supplier for an RPC interface class for a given routing. */
-    static assignWithRouting<T extends RpcInterface>(definition: RpcInterfaceDefinition<T>, routing: RpcRoutingToken, configuration: new () => RpcConfiguration): void;
-    /** Obtains the instance of an RPC configuration class. */
-    static obtain<T extends RpcConfiguration>(configurationConstructor: new () => T): T;
-    /** Enables passing of application-specific context with each RPC request. */
-    static requestContext: RpcRequestContext;
-    /** @internal */
-    attached: RpcInterfaceDefinition[];
-    /** The protocol of the configuration.
-     * @internal
-     */
-    abstract readonly protocol: RpcProtocol;
-    /** The RPC interfaces managed by the configuration. */
-    abstract readonly interfaces: () => RpcInterfaceDefinition[];
-    /** @internal */
-    allowAttachedInterfaces: boolean;
-    /** @internal */
-    get attachedInterfaces(): ReadonlyArray<RpcInterfaceDefinition>;
-    /** The target interval (in milliseconds) between connection attempts for pending RPC operation requests. */
-    pendingOperationRetryInterval: number;
-    /** The maximum number of transient faults permitted before request failure. */
-    transientFaultLimit: number;
-    /** @internal */
-    readonly routing: RpcRoutingToken;
-    /** The control channel for the configuration.
-     * @internal
-     */
-    readonly controlChannel: RpcControlChannel;
-    /** @internal */
-    attach<T extends RpcInterface>(definition: RpcInterfaceDefinition<T>): void;
-    /** Initializes the RPC interfaces managed by the configuration. */
-    static initializeInterfaces(configuration: RpcConfiguration): void;
-    /** @internal */
-    static supply(definition: RpcInterface): RpcConfiguration;
-    /** @internal */
-    onRpcClientInitialized(definition: RpcInterfaceDefinition, client: RpcInterface): void;
-    /** @internal */
-    onRpcImplInitialized(definition: RpcInterfaceDefinition, impl: RpcInterface): void;
-    /** @internal */
-    onRpcClientTerminated(definition: RpcInterfaceDefinition, client: RpcInterface): void;
-    /** @internal */
-    onRpcImplTerminated(definition: RpcInterfaceDefinition, impl: RpcInterface): void;
-}
-/** A default configuration that can be used for basic testing within a library.
- * @internal
- */
-export declare class RpcDefaultConfiguration extends RpcConfiguration {
-    interfaces: () => never[];
-    protocol: RpcProtocol;
-}
-/** A default protocol that can be used for basic testing within a library.
- * @internal
- */
-export declare class RpcDirectProtocol extends RpcProtocol {
-    readonly requestType: typeof RpcDirectRequest;
-}
-/** A default request type that can be used for basic testing within a library.
- * @internal
- */
-export declare class RpcDirectRequest extends RpcRequest {
-    headers: Map<string, string>;
-    fulfillment: RpcRequestFulfillment | undefined;
-    protected send(): Promise<number>;
-    protected setHeader(name: string, value: string): void;
-    protected load(): Promise<import("./RpcMarshaling").RpcSerializedValue>;
-}
+/** @packageDocumentation
+ * @module RpcInterface
+ */
+import { RpcInterface, RpcInterfaceDefinition } from "../../RpcInterface";
+import { RpcControlChannel } from "./RpcControl";
+import { RpcProtocol, RpcRequestFulfillment } from "./RpcProtocol";
+import { RpcRequest } from "./RpcRequest";
+import { RpcRequestContext } from "./RpcRequestContext";
+import { RpcRoutingToken } from "./RpcRoutingToken";
+/** @internal */
+export declare type RpcConfigurationSupplier = (routing?: RpcRoutingToken) => {
+    new (): RpcConfiguration;
+};
+/** @internal */
+export interface RpcRoutingMap extends RpcConfigurationSupplier {
+    configurations: Map<number, RpcConfigurationSupplier>;
+}
+/** @internal */
+export declare namespace RpcRoutingMap {
+    function create(): RpcRoutingMap;
+}
+/** A RpcConfiguration specifies how calls on an RPC interface will be marshalled, plus other operating parameters.
+ * RpcConfiguration is the base class for specific configurations.
+ * @internal
+ */
+export declare abstract class RpcConfiguration {
+    /** Whether development mode is enabled.
+     * @note This parameter determines whether developer convenience features like backend stack traces are available.
+     */
+    static developmentMode: boolean;
+    /** Whether frontend checks that are relevant in a cloud-hosted routing scenario are disabled. */
+    static disableRoutingValidation: boolean;
+    /** Whether strict mode is enabled.
+     * This parameter determines system behaviors relating to strict checking:
+     * - Whether an error is thrown if the type marshaling system encounters an unregistered type (only in strict mode).
+     */
+    static strictMode: boolean;
+    /**
+     * Whether to throw an error when the IModelRpcProps in the operation parameter list differs from the token in the URL.
+     * @note By default, a warning is logged and the operation is allowed to proceed.
+     * @note The parameter token is always replaced by the url token (unless RpcOperationPolicy.allowTokenMismatch is set).
+     */
+    static throwOnTokenMismatch: boolean;
+    /** Sets the configuration supplier for an RPC interface class. */
+    static assign<T extends RpcInterface>(definition: RpcInterfaceDefinition<T>, supplier: RpcConfigurationSupplier): void;
+    /** Sets the configuration supplier for an RPC interface class for a given routing. */
+    static assignWithRouting<T extends RpcInterface>(definition: RpcInterfaceDefinition<T>, routing: RpcRoutingToken, configuration: new () => RpcConfiguration): void;
+    /** Obtains the instance of an RPC configuration class. */
+    static obtain<T extends RpcConfiguration>(configurationConstructor: new () => T): T;
+    /** Enables passing of application-specific context with each RPC request. */
+    static requestContext: RpcRequestContext;
+    /** @internal */
+    attached: RpcInterfaceDefinition[];
+    /** The protocol of the configuration.
+     * @internal
+     */
+    abstract readonly protocol: RpcProtocol;
+    /** The RPC interfaces managed by the configuration. */
+    abstract readonly interfaces: () => RpcInterfaceDefinition[];
+    /** @internal */
+    allowAttachedInterfaces: boolean;
+    /** @internal */
+    get attachedInterfaces(): ReadonlyArray<RpcInterfaceDefinition>;
+    /** The target interval (in milliseconds) between connection attempts for pending RPC operation requests. */
+    pendingOperationRetryInterval: number;
+    /** The maximum number of transient faults permitted before request failure. */
+    transientFaultLimit: number;
+    /** @internal */
+    readonly routing: RpcRoutingToken;
+    /** The control channel for the configuration.
+     * @internal
+     */
+    readonly controlChannel: RpcControlChannel;
+    /** @internal */
+    attach<T extends RpcInterface>(definition: RpcInterfaceDefinition<T>): void;
+    /** Initializes the RPC interfaces managed by the configuration. */
+    static initializeInterfaces(configuration: RpcConfiguration): void;
+    /** @internal */
+    static supply(definition: RpcInterface): RpcConfiguration;
+    /** @internal */
+    onRpcClientInitialized(definition: RpcInterfaceDefinition, client: RpcInterface): void;
+    /** @internal */
+    onRpcImplInitialized(definition: RpcInterfaceDefinition, impl: RpcInterface): void;
+    /** @internal */
+    onRpcClientTerminated(definition: RpcInterfaceDefinition, client: RpcInterface): void;
+    /** @internal */
+    onRpcImplTerminated(definition: RpcInterfaceDefinition, impl: RpcInterface): void;
+}
+/** A default configuration that can be used for basic testing within a library.
+ * @internal
+ */
+export declare class RpcDefaultConfiguration extends RpcConfiguration {
+    interfaces: () => never[];
+    protocol: RpcProtocol;
+}
+/** A default protocol that can be used for basic testing within a library.
+ * @internal
+ */
+export declare class RpcDirectProtocol extends RpcProtocol {
+    readonly requestType: typeof RpcDirectRequest;
+}
+/** A default request type that can be used for basic testing within a library.
+ * @internal
+ */
+export declare class RpcDirectRequest extends RpcRequest {
+    headers: Map<string, string>;
+    fulfillment: RpcRequestFulfillment | undefined;
+    protected send(): Promise<number>;
+    protected setHeader(name: string, value: string): void;
+    protected load(): Promise<import("./RpcMarshaling").RpcSerializedValue>;
+}
 //# sourceMappingURL=RpcConfiguration.d.ts.map