@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/dist/class-tree/index.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export { ITree, TreeView, TreeConfiguration, WrapperTreeView } from "./tree";
+export { TreeNodeSchema, NodeFromSchema, NodeKind, TreeNodeSchemaClass, TreeNodeSchemaNonClass, TreeNodeSchemaCore, ImplicitFieldSchema, TreeFieldFromImplicitField, ImplicitAllowedTypes, TreeNodeFromImplicitAllowedTypes, InsertableTreeNodeFromImplicitAllowedTypes, TreeMapNode, TreeLeafValue, } from "./schemaTypes";
+export { SchemaFactory } from "./schemaFactory";
+export { nodeApi as Tree, TreeApi, TreeNodeEvents } from "./treeApi";
+export { toFlexConfig } from "./toFlexSchema";
+export { SchemaFactoryRecursive } from "./schemaFactoryRecursive";
+export { adaptEnum, enumFromStrings, singletonSchema, typedObjectValues, } from "./schemaCreationUtilities";
+import * as InternalClassTreeTypes from "./internal";
+export { InternalClassTreeTypes };
+export { RecursiveObject as test_RecursiveObject, base as test_RecursiveObject_base, } from "./testRecursiveDomain";
+//# sourceMappingURL=index.d.ts.map

package/dist/class-tree/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/class-tree/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAC7E,OAAO,EACN,cAAc,EACd,cAAc,EACd,QAAQ,EACR,mBAAmB,EACnB,sBAAsB,EACtB,kBAAkB,EAClB,mBAAmB,EACnB,0BAA0B,EAC1B,oBAAoB,EACpB,gCAAgC,EAChC,0CAA0C,EAC1C,WAAW,EACX,aAAa,GACb,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAElE,OAAO,EACN,SAAS,EACT,eAAe,EACf,eAAe,EACf,iBAAiB,GACjB,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,sBAAsB,MAAM,YAAY,CAAC;AACrD,OAAO,EAAE,sBAAsB,EAAE,CAAC;AAIlC,OAAO,EACN,eAAe,IAAI,oBAAoB,EACvC,IAAI,IAAI,yBAAyB,GACjC,MAAM,uBAAuB,CAAC"}

package/dist/class-tree/index.js

@@ -0,0 +1,57 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.test_RecursiveObject_base = exports.test_RecursiveObject = exports.InternalClassTreeTypes = exports.typedObjectValues = exports.singletonSchema = exports.enumFromStrings = exports.adaptEnum = exports.SchemaFactoryRecursive = exports.toFlexConfig = exports.Tree = exports.SchemaFactory = exports.NodeKind = exports.WrapperTreeView = exports.TreeConfiguration = void 0;
+var tree_1 = require("./tree");
+Object.defineProperty(exports, "TreeConfiguration", { enumerable: true, get: function () { return tree_1.TreeConfiguration; } });
+Object.defineProperty(exports, "WrapperTreeView", { enumerable: true, get: function () { return tree_1.WrapperTreeView; } });
+var schemaTypes_1 = require("./schemaTypes");
+Object.defineProperty(exports, "NodeKind", { enumerable: true, get: function () { return schemaTypes_1.NodeKind; } });
+var schemaFactory_1 = require("./schemaFactory");
+Object.defineProperty(exports, "SchemaFactory", { enumerable: true, get: function () { return schemaFactory_1.SchemaFactory; } });
+var treeApi_1 = require("./treeApi");
+Object.defineProperty(exports, "Tree", { enumerable: true, get: function () { return treeApi_1.nodeApi; } });
+var toFlexSchema_1 = require("./toFlexSchema");
+Object.defineProperty(exports, "toFlexConfig", { enumerable: true, get: function () { return toFlexSchema_1.toFlexConfig; } });
+var schemaFactoryRecursive_1 = require("./schemaFactoryRecursive");
+Object.defineProperty(exports, "SchemaFactoryRecursive", { enumerable: true, get: function () { return schemaFactoryRecursive_1.SchemaFactoryRecursive; } });
+var schemaCreationUtilities_1 = require("./schemaCreationUtilities");
+Object.defineProperty(exports, "adaptEnum", { enumerable: true, get: function () { return schemaCreationUtilities_1.adaptEnum; } });
+Object.defineProperty(exports, "enumFromStrings", { enumerable: true, get: function () { return schemaCreationUtilities_1.enumFromStrings; } });
+Object.defineProperty(exports, "singletonSchema", { enumerable: true, get: function () { return schemaCreationUtilities_1.singletonSchema; } });
+Object.defineProperty(exports, "typedObjectValues", { enumerable: true, get: function () { return schemaCreationUtilities_1.typedObjectValues; } });
+// Below here are things that are used by the above, but not part of the desired API surface.
+const InternalClassTreeTypes = __importStar(require("./internal"));
+exports.InternalClassTreeTypes = InternalClassTreeTypes;
+// Exporting the schema (RecursiveObject) to test that recursive types are working correctly.
+// These are `@internal` so they can't be included in the `InternalClassTreeTypes` due to https://github.com/microsoft/rushstack/issues/3639
+var testRecursiveDomain_1 = require("./testRecursiveDomain");
+Object.defineProperty(exports, "test_RecursiveObject", { enumerable: true, get: function () { return testRecursiveDomain_1.RecursiveObject; } });
+Object.defineProperty(exports, "test_RecursiveObject_base", { enumerable: true, get: function () { return testRecursiveDomain_1.base; } });
+//# sourceMappingURL=index.js.map

package/dist/class-tree/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/class-tree/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,+BAA6E;AAAnD,yGAAA,iBAAiB,OAAA;AAAE,uGAAA,eAAe,OAAA;AAC5D,6CAcuB;AAXtB,uGAAA,QAAQ,OAAA;AAYT,iDAAgD;AAAvC,8GAAA,aAAa,OAAA;AACtB,qCAAqE;AAA5D,+FAAA,OAAO,OAAQ;AACxB,+CAA8C;AAArC,4GAAA,YAAY,OAAA;AACrB,mEAAkE;AAAzD,gIAAA,sBAAsB,OAAA;AAE/B,qEAKmC;AAJlC,oHAAA,SAAS,OAAA;AACT,0HAAA,eAAe,OAAA;AACf,0HAAA,eAAe,OAAA;AACf,4HAAA,iBAAiB,OAAA;AAGlB,6FAA6F;AAC7F,mEAAqD;AAC5C,wDAAsB;AAE/B,6FAA6F;AAC7F,4IAA4I;AAC5I,6DAG+B;AAF9B,2HAAA,eAAe,OAAwB;AACvC,gIAAA,IAAI,OAA6B","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport { ITree, TreeView, TreeConfiguration, WrapperTreeView } from \"./tree\";\nexport {\n\tTreeNodeSchema,\n\tNodeFromSchema,\n\tNodeKind,\n\tTreeNodeSchemaClass,\n\tTreeNodeSchemaNonClass,\n\tTreeNodeSchemaCore,\n\tImplicitFieldSchema,\n\tTreeFieldFromImplicitField,\n\tImplicitAllowedTypes,\n\tTreeNodeFromImplicitAllowedTypes,\n\tInsertableTreeNodeFromImplicitAllowedTypes,\n\tTreeMapNode,\n\tTreeLeafValue,\n} from \"./schemaTypes\";\nexport { SchemaFactory } from \"./schemaFactory\";\nexport { nodeApi as Tree, TreeApi, TreeNodeEvents } from \"./treeApi\";\nexport { toFlexConfig } from \"./toFlexSchema\";\nexport { SchemaFactoryRecursive } from \"./schemaFactoryRecursive\";\n\nexport {\n\tadaptEnum,\n\tenumFromStrings,\n\tsingletonSchema,\n\ttypedObjectValues,\n} from \"./schemaCreationUtilities\";\n\n// Below here are things that are used by the above, but not part of the desired API surface.\nimport * as InternalClassTreeTypes from \"./internal\";\nexport { InternalClassTreeTypes };\n\n// Exporting the schema (RecursiveObject) to test that recursive types are working correctly.\n// These are `@internal` so they can't be included in the `InternalClassTreeTypes` due to https://github.com/microsoft/rushstack/issues/3639\nexport {\n\tRecursiveObject as test_RecursiveObject,\n\tbase as test_RecursiveObject_base,\n} from \"./testRecursiveDomain\";\n"]}

package/dist/class-tree/integerIndexable.d.ts

@@ -0,0 +1,31 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Info integerIndexable needs to work.
+ */
+export interface IndexLookup<T> {
+    read(index: number): T;
+    write(index: number, value: T): boolean;
+    readonly length: number;
+}
+/**
+ * Class which can be indexed with integers from 0 to length -1 like arrays.
+ * Unlike with arrays, this class asserts for out of bounds indexing on both read and write.
+ *
+ * @privateRemarks
+ * This class works by returning a proxy from its constructor which
+ * causes the derived class to get the proxy as its "this" object.
+ */
+export declare abstract class IntegerIndexable<in out T> {
+    length: number;
+    [x: number]: T;
+    protected abstract read(index: number): T;
+    protected abstract write(index: number, value: T): boolean;
+    constructor(length: number);
+}
+export declare function integerIndexable<T, TTarget extends object>(outerTarget: TTarget, provider: IndexLookup<T>): {
+    [x: number]: T;
+} & TTarget;
+//# sourceMappingURL=integerIndexable.d.ts.map

package/dist/class-tree/integerIndexable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integerIndexable.d.ts","sourceRoot":"","sources":["../../src/class-tree/integerIndexable.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC;IAC7B,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC;IACvB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,8BAAsB,gBAAgB,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAMpB,MAAM,EAAE,MAAM;IALxC,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC;IAEf,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC;IACzC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO;gBAEhC,MAAM,EAAE,MAAM;CAGxC;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,SAAS,MAAM,EACzD,WAAW,EAAE,OAAO,EACpB,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,GACtB;IACF,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC;CACf,GAAG,OAAO,CA4EV"}

package/dist/class-tree/integerIndexable.js

@@ -0,0 +1,97 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integerIndexable = exports.IntegerIndexable = void 0;
+const core_utils_1 = require("@fluidframework/core-utils");
+/**
+ * Class which can be indexed with integers from 0 to length -1 like arrays.
+ * Unlike with arrays, this class asserts for out of bounds indexing on both read and write.
+ *
+ * @privateRemarks
+ * This class works by returning a proxy from its constructor which
+ * causes the derived class to get the proxy as its "this" object.
+ */
+class IntegerIndexable {
+    constructor(length) {
+        this.length = length;
+        return integerIndexable(this, this);
+    }
+}
+exports.IntegerIndexable = IntegerIndexable;
+function integerIndexable(outerTarget, provider) {
+    function isValidIndex(index) {
+        return index >= 0 && index < provider.length;
+    }
+    function keyToNumber(key) {
+        if (typeof key !== "string") {
+            return undefined;
+        }
+        const index = Number.parseInt(key, 10);
+        return Number.isNaN(index) ? undefined : index;
+    }
+    const proxyHandler = {
+        get: (target, key, receiver) => {
+            const index = keyToNumber(key);
+            if (index !== undefined) {
+                (0, core_utils_1.assert)(isValidIndex(index), 0x839 /* invalid index */);
+                return provider.read(index);
+            }
+            // Pass the proxy as the receiver here, so that any methods on the prototype receive `proxy` as `this`.
+            return Reflect.get(target, key, receiver);
+        },
+        getOwnPropertyDescriptor: (target, key) => {
+            const index = keyToNumber(key);
+            if (index !== undefined) {
+                if (isValidIndex(index)) {
+                    const descriptor = {
+                        get() {
+                            return provider.read(index);
+                        },
+                        set(value) {
+                            provider.write(index, value);
+                        },
+                        writable: true,
+                        enumerable: true,
+                        configurable: true, // Must be 'configurable' if property is absent from proxy target.
+                    };
+                    return descriptor;
+                }
+                else {
+                    return undefined;
+                }
+            }
+            return Reflect.getOwnPropertyDescriptor(target, key);
+        },
+        has: (target, key) => {
+            if (typeof key === "string") {
+                const numericKey = Number.parseInt(key, 10);
+                if (!Number.isNaN(numericKey)) {
+                    return isValidIndex(numericKey);
+                }
+            }
+            return Reflect.has(target, key);
+        },
+        set: (target, key, newValue) => {
+            const index = keyToNumber(key);
+            if (index !== undefined) {
+                (0, core_utils_1.assert)(isValidIndex(index), 0x83a /* invalid index */);
+                return provider.write(index, newValue);
+            }
+            return Reflect.set(target, key, newValue);
+        },
+        ownKeys: (target) => {
+            const keys = Reflect.ownKeys(target);
+            for (let index = 0; index < provider.length; index++) {
+                keys.push(index.toString());
+            }
+            return keys;
+        },
+    };
+    const proxy = new Proxy(outerTarget, proxyHandler);
+    return proxy;
+}
+exports.integerIndexable = integerIndexable;
+//# sourceMappingURL=integerIndexable.js.map

package/dist/class-tree/integerIndexable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integerIndexable.js","sourceRoot":"","sources":["../../src/class-tree/integerIndexable.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,2DAAoD;AAcpD;;;;;;;GAOG;AACH,MAAsB,gBAAgB;IAMrC,YAA0B,MAAc;QAAd,WAAM,GAAN,MAAM,CAAQ;QACvC,OAAO,gBAAgB,CAAC,IAAI,EAAE,IAAiC,CAAC,CAAC;IAClE,CAAC;CACD;AATD,4CASC;AAED,SAAgB,gBAAgB,CAC/B,WAAoB,EACpB,QAAwB;IAIxB,SAAS,YAAY,CAAC,KAAa;QAClC,OAAO,KAAK,IAAI,CAAC,IAAI,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC;IAC9C,CAAC;IAED,SAAS,WAAW,CAAC,GAAoB;QACxC,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE;YAC5B,OAAO,SAAS,CAAC;SACjB;QACD,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACvC,OAAO,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC;IAChD,CAAC;IAED,MAAM,YAAY,GAA0B;QAC3C,GAAG,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAe,EAAE;YAC3C,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;YAC/B,IAAI,KAAK,KAAK,SAAS,EAAE;gBACxB,IAAA,mBAAM,EAAC,YAAY,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAC;gBACvD,OAAO,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;aAC5B;YAED,uGAAuG;YACvG,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;QAC3C,CAAC;QACD,wBAAwB,EAAE,CAAC,MAAM,EAAE,GAAG,EAAkC,EAAE;YACzE,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;YAC/B,IAAI,KAAK,KAAK,SAAS,EAAE;gBACxB,IAAI,YAAY,CAAC,KAAK,CAAC,EAAE;oBACxB,MAAM,UAAU,GAAuB;wBACtC,GAAG;4BACF,OAAO,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;wBAC7B,CAAC;wBACD,GAAG,CAAC,KAAQ;4BACX,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;wBAC9B,CAAC;wBACD,QAAQ,EAAE,IAAI;wBACd,UAAU,EAAE,IAAI;wBAChB,YAAY,EAAE,IAAI,EAAE,kEAAkE;qBACtF,CAAC;oBACF,OAAO,UAAU,CAAC;iBAClB;qBAAM;oBACN,OAAO,SAAS,CAAC;iBACjB;aACD;YAED,OAAO,OAAO,CAAC,wBAAwB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QACtD,CAAC;QACD,GAAG,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE;YACpB,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE;gBAC5B,MAAM,UAAU,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;gBAC5C,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE;oBAC9B,OAAO,YAAY,CAAC,UAAU,CAAC,CAAC;iBAChC;aACD;YACD,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QACjC,CAAC;QACD,GAAG,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAW,EAAE;YACvC,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;YAC/B,IAAI,KAAK,KAAK,SAAS,EAAE;gBACxB,IAAA,mBAAM,EAAC,YAAY,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAC;gBACvD,OAAO,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;aACvC;YACD,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;QAC3C,CAAC;QACD,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE;YACnB,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YACrC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;gBACrD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;aAC5B;YACD,OAAO,IAAI,CAAC;QACb,CAAC;KACD,CAAC;IACF,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;IACnD,OAAO,KAEI,CAAC;AACb,CAAC;AAjFD,4CAiFC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils\";\n\n// Note:\n// Currently this file is unused, though it could serve as the implementation of indexing for Lists when class and simple trees are merged.\n\n/**\n * Info integerIndexable needs to work.\n */\nexport interface IndexLookup<T> {\n\tread(index: number): T;\n\twrite(index: number, value: T): boolean;\n\treadonly length: number;\n}\n\n/**\n * Class which can be indexed with integers from 0 to length -1 like arrays.\n * Unlike with arrays, this class asserts for out of bounds indexing on both read and write.\n *\n * @privateRemarks\n * This class works by returning a proxy from its constructor which\n * causes the derived class to get the proxy as its \"this\" object.\n */\nexport abstract class IntegerIndexable<in out T> {\n\t[x: number]: T;\n\n\tprotected abstract read(index: number): T;\n\tprotected abstract write(index: number, value: T): boolean;\n\n\tpublic constructor(public length: number) {\n\t\treturn integerIndexable(this, this as unknown as IndexLookup<T>);\n\t}\n}\n\nexport function integerIndexable<T, TTarget extends object>(\n\touterTarget: TTarget,\n\tprovider: IndexLookup<T>,\n): {\n\t[x: number]: T;\n} & TTarget {\n\tfunction isValidIndex(index: number): boolean {\n\t\treturn index >= 0 && index < provider.length;\n\t}\n\n\tfunction keyToNumber(key: string | symbol): number | undefined {\n\t\tif (typeof key !== \"string\") {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst index = Number.parseInt(key, 10);\n\t\treturn Number.isNaN(index) ? undefined : index;\n\t}\n\n\tconst proxyHandler: ProxyHandler<TTarget> = {\n\t\tget: (target, key, receiver): T | unknown => {\n\t\t\tconst index = keyToNumber(key);\n\t\t\tif (index !== undefined) {\n\t\t\t\tassert(isValidIndex(index), 0x839 /* invalid index */);\n\t\t\t\treturn provider.read(index);\n\t\t\t}\n\n\t\t\t// Pass the proxy as the receiver here, so that any methods on the prototype receive `proxy` as `this`.\n\t\t\treturn Reflect.get(target, key, receiver);\n\t\t},\n\t\tgetOwnPropertyDescriptor: (target, key): PropertyDescriptor | undefined => {\n\t\t\tconst index = keyToNumber(key);\n\t\t\tif (index !== undefined) {\n\t\t\t\tif (isValidIndex(index)) {\n\t\t\t\t\tconst descriptor: PropertyDescriptor = {\n\t\t\t\t\t\tget() {\n\t\t\t\t\t\t\treturn provider.read(index);\n\t\t\t\t\t\t},\n\t\t\t\t\t\tset(value: T): void {\n\t\t\t\t\t\t\tprovider.write(index, value);\n\t\t\t\t\t\t},\n\t\t\t\t\t\twritable: true,\n\t\t\t\t\t\tenumerable: true,\n\t\t\t\t\t\tconfigurable: true, // Must be 'configurable' if property is absent from proxy target.\n\t\t\t\t\t};\n\t\t\t\t\treturn descriptor;\n\t\t\t\t} else {\n\t\t\t\t\treturn undefined;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn Reflect.getOwnPropertyDescriptor(target, key);\n\t\t},\n\t\thas: (target, key) => {\n\t\t\tif (typeof key === \"string\") {\n\t\t\t\tconst numericKey = Number.parseInt(key, 10);\n\t\t\t\tif (!Number.isNaN(numericKey)) {\n\t\t\t\t\treturn isValidIndex(numericKey);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn Reflect.has(target, key);\n\t\t},\n\t\tset: (target, key, newValue): boolean => {\n\t\t\tconst index = keyToNumber(key);\n\t\t\tif (index !== undefined) {\n\t\t\t\tassert(isValidIndex(index), 0x83a /* invalid index */);\n\t\t\t\treturn provider.write(index, newValue);\n\t\t\t}\n\t\t\treturn Reflect.set(target, key, newValue);\n\t\t},\n\t\townKeys: (target) => {\n\t\t\tconst keys = Reflect.ownKeys(target);\n\t\t\tfor (let index = 0; index < provider.length; index++) {\n\t\t\t\tkeys.push(index.toString());\n\t\t\t}\n\t\t\treturn keys;\n\t\t},\n\t};\n\tconst proxy = new Proxy(outerTarget, proxyHandler);\n\treturn proxy as unknown as {\n\t\t[x: number]: T;\n\t} & TTarget;\n}\n"]}

package/dist/class-tree/internal.d.ts

@@ -0,0 +1,6 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export { ObjectFromSchemaRecord, InsertableObjectFromSchemaRecord, TreeNodeFromImplicitAllowedTypes, ImplicitAllowedTypes, FieldKind, InsertableTreeFieldFromImplicitField, AllowedTypes, FieldSchema, ApplyKind, InsertableTypedNode, NodeBuilderData, } from "./schemaTypes";
+//# sourceMappingURL=internal.d.ts.map

package/dist/class-tree/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../src/class-tree/internal.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EACN,sBAAsB,EACtB,gCAAgC,EAChC,gCAAgC,EAChC,oBAAoB,EACpB,SAAS,EACT,oCAAoC,EACpC,YAAY,EACZ,WAAW,EACX,SAAS,EACT,mBAAmB,EACnB,eAAe,GACf,MAAM,eAAe,CAAC"}

package/dist/class-tree/internal.js

@@ -0,0 +1,12 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldSchema = exports.FieldKind = void 0;
+// Used by public types, but not part of the desired API surface
+var schemaTypes_1 = require("./schemaTypes");
+Object.defineProperty(exports, "FieldKind", { enumerable: true, get: function () { return schemaTypes_1.FieldKind; } });
+Object.defineProperty(exports, "FieldSchema", { enumerable: true, get: function () { return schemaTypes_1.FieldSchema; } });
+//# sourceMappingURL=internal.js.map

package/dist/class-tree/internal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.js","sourceRoot":"","sources":["../../src/class-tree/internal.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,gEAAgE;AAEhE,6CAYuB;AAPtB,wGAAA,SAAS,OAAA;AAGT,0GAAA,WAAW,OAAA","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n// Used by public types, but not part of the desired API surface\n\nexport {\n\tObjectFromSchemaRecord,\n\tInsertableObjectFromSchemaRecord,\n\tTreeNodeFromImplicitAllowedTypes,\n\tImplicitAllowedTypes,\n\tFieldKind,\n\tInsertableTreeFieldFromImplicitField,\n\tAllowedTypes,\n\tFieldSchema,\n\tApplyKind,\n\tInsertableTypedNode,\n\tNodeBuilderData,\n} from \"./schemaTypes\";\n"]}

package/dist/class-tree/schemaCreationUtilities.d.ts

@@ -0,0 +1,96 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { EmptyObject } from "../feature-libraries";
+import { SchemaFactory } from "./schemaFactory";
+import { type NodeKind as _dummy } from "./schemaTypes";
+/**
+ * Create a schema for a node with no state.
+ * @remarks
+ * This is commonly used in unions when the only information needed is which kind of node the value is.
+ * Enums are a common example of this pattern.
+ * @internal
+ */
+export declare function singletonSchema<TScope extends string, TName extends string | number>(factory: SchemaFactory<TScope, TName>, name: TName): {
+    new (data?: EmptyObject): {
+        readonly value: TName;
+    };
+    readonly identifier: `${TScope}.${TName}`;
+    readonly kind: _dummy.Object;
+    readonly info: unknown;
+    readonly implicitlyConstructable: true;
+};
+/**
+ * Converts an enum into a collection of schema which can be used in a union.
+ * @remarks
+ * Currently only supports `string` enums.
+ * @example
+ * ```typescript
+ * enum Mode {
+ * 	a = "A",
+ * 	b = "B",
+ * }
+ * const ModeNodes = adaptEnum(schema, Mode);
+ * type ModeNodes = NodeFromSchema<(typeof ModeNodes)[keyof typeof ModeNodes]>;
+ * const nodeFromString: ModeNodes = ModeNodes(Mode.a);
+ * const nodeFromSchema: ModeNodes = new ModeNodes.a();
+ * const nameFromNode: Mode = nodeFromSchema.value;
+ * class Parent extends schemaFactory.object("Parent", {
+ * 	mode: typedObjectValues(ModeNodes),
+ * }) {}
+ * ```
+ * @privateRemarks
+ * TODO:
+ * Extends this to support numeric enums.
+ * Maybe require an explicit nested scope to group them under, or at least a warning about collisions.
+ * Maybe just provide `SchemaFactory.nested` to east creating nested scopes?
+ * @internal
+ */
+export declare function adaptEnum<TScope extends string, const TEnum extends Record<string, string>>(factory: SchemaFactory<TScope>, members: TEnum): (<TValue extends TEnum[keyof TEnum]>(value: TValue) => {
+    readonly value: TValue;
+}) & { readonly [Property in keyof TEnum]: {
+    new (data?: EmptyObject | undefined): {
+        readonly value: TEnum[Property];
+    };
+    readonly identifier: `${TScope}.${TEnum[Property]}`;
+    readonly kind: _dummy.Object;
+    readonly info: unknown;
+    readonly implicitlyConstructable: true;
+}; };
+/**
+ * `Object.values`, but with more specific types.
+ * @internal
+ */
+export declare function typedObjectValues<TKey extends string, TValues>(object: Record<TKey, TValues>): TValues[];
+/**
+ * Converts an array of distinct strings into a collection of schema which can be used like an enum style union.
+ * @remarks
+ * The returned collection is also a function which can be used to convert strings into {@link Unhydrated} nodes in the union.
+ * Each node type has a `.value` getter which returns the associated string.
+ *
+ * The produced nodes use the provided strings as their `name`, and don't store any data beyond that.
+ * @example
+ * ```typescript
+ * const Mode = enumFromStrings(schemaFactory, ["Fun", "Cool"]);
+ * type Mode = NodeFromSchema<(typeof Mode)[keyof typeof Mode]>;
+ * const nodeFromString: Mode = Mode("Fun");
+ * const nodeFromSchema: Mode = new Mode.Fun();
+ * const nameFromNode = nodeFromSchema.value;
+ *
+ * class Parent extends schemaFactory.object("Parent", { mode: typedObjectValues(Mode) }) {}
+ * ```
+ * @internal
+ */
+export declare function enumFromStrings<TScope extends string, const Members extends string>(factory: SchemaFactory<TScope>, members: Members[]): (<TValue extends Members>(value: TValue) => {
+    readonly value: TValue;
+}) & Record<Members, {
+    new (data?: EmptyObject | undefined): {
+        readonly value: Members;
+    };
+    readonly identifier: `${TScope}.${Members}`;
+    readonly kind: _dummy.Object;
+    readonly info: unknown;
+    readonly implicitlyConstructable: true;
+}>;
+//# sourceMappingURL=schemaCreationUtilities.d.ts.map

package/dist/class-tree/schemaCreationUtilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaCreationUtilities.d.ts","sourceRoot":"","sources":["../../src/class-tree/schemaCreationUtilities.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAKhD,OAAO,EAAkB,KAAK,QAAQ,IAAI,MAAM,EAAE,MAAM,eAAe,CAAC;AAExE;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,SAAS,MAAM,EAAE,KAAK,SAAS,MAAM,GAAG,MAAM,EACnF,OAAO,EAAE,aAAa,CAAC,MAAM,EAAE,KAAK,CAAC,EACrC,IAAI,EAAE,KAAK;gBAGgB,WAAW;;;;;;;EAOtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,SAAS,CAAC,MAAM,SAAS,MAAM,EAAE,KAAK,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1F,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,EAC9B,OAAO,EAAE,KAAK;;;;;;;;;;KAkCd;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,SAAS,MAAM,EAAE,OAAO,EAC7D,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAC3B,OAAO,EAAE,CAEX;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,MAAM,SAAS,MAAM,EAAE,KAAK,CAAC,OAAO,SAAS,MAAM,EAClF,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,EAC9B,OAAO,EAAE,OAAO,EAAE;;;;;;;;;;GAwBlB"}

package/dist/class-tree/schemaCreationUtilities.js

@@ -0,0 +1,137 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumFromStrings = exports.typedObjectValues = exports.adaptEnum = exports.singletonSchema = void 0;
+const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
+const util_1 = require("../util");
+/**
+ * Create a schema for a node with no state.
+ * @remarks
+ * This is commonly used in unions when the only information needed is which kind of node the value is.
+ * Enums are a common example of this pattern.
+ * @internal
+ */
+function singletonSchema(factory, name) {
+    return class SingletonSchema extends factory.object(name, {}) {
+        constructor(data) {
+            super(data ?? {});
+        }
+        get value() {
+            return name;
+        }
+    };
+}
+exports.singletonSchema = singletonSchema;
+/**
+ * Converts an enum into a collection of schema which can be used in a union.
+ * @remarks
+ * Currently only supports `string` enums.
+ * @example
+ * ```typescript
+ * enum Mode {
+ * 	a = "A",
+ * 	b = "B",
+ * }
+ * const ModeNodes = adaptEnum(schema, Mode);
+ * type ModeNodes = NodeFromSchema<(typeof ModeNodes)[keyof typeof ModeNodes]>;
+ * const nodeFromString: ModeNodes = ModeNodes(Mode.a);
+ * const nodeFromSchema: ModeNodes = new ModeNodes.a();
+ * const nameFromNode: Mode = nodeFromSchema.value;
+ * class Parent extends schemaFactory.object("Parent", {
+ * 	mode: typedObjectValues(ModeNodes),
+ * }) {}
+ * ```
+ * @privateRemarks
+ * TODO:
+ * Extends this to support numeric enums.
+ * Maybe require an explicit nested scope to group them under, or at least a warning about collisions.
+ * Maybe just provide `SchemaFactory.nested` to east creating nested scopes?
+ * @internal
+ */
+function adaptEnum(factory, members) {
+    const values = Object.values(members);
+    const inverse = new Map(Object.entries(members).map(([key, value]) => [value, key]));
+    if (inverse.size !== values.length) {
+        throw new telemetry_utils_1.UsageError("All members of enums must have distinct values.");
+    }
+    const factoryOut = (value) => {
+        return new out[inverse.get(value) ?? (0, util_1.fail)("missing enum value")]({});
+    };
+    const out = factoryOut;
+    for (const [key, value] of Object.entries(members)) {
+        Object.defineProperty(out, key, {
+            enumerable: true,
+            configurable: false,
+            writable: false,
+            value: singletonSchema(factory, value),
+        });
+    }
+    return out;
+}
+exports.adaptEnum = adaptEnum;
+/**
+ * `Object.values`, but with more specific types.
+ * @internal
+ */
+function typedObjectValues(object) {
+    return Object.values(object);
+}
+exports.typedObjectValues = typedObjectValues;
+/**
+ * Converts an array of distinct strings into a collection of schema which can be used like an enum style union.
+ * @remarks
+ * The returned collection is also a function which can be used to convert strings into {@link Unhydrated} nodes in the union.
+ * Each node type has a `.value` getter which returns the associated string.
+ *
+ * The produced nodes use the provided strings as their `name`, and don't store any data beyond that.
+ * @example
+ * ```typescript
+ * const Mode = enumFromStrings(schemaFactory, ["Fun", "Cool"]);
+ * type Mode = NodeFromSchema<(typeof Mode)[keyof typeof Mode]>;
+ * const nodeFromString: Mode = Mode("Fun");
+ * const nodeFromSchema: Mode = new Mode.Fun();
+ * const nameFromNode = nodeFromSchema.value;
+ *
+ * class Parent extends schemaFactory.object("Parent", { mode: typedObjectValues(Mode) }) {}
+ * ```
+ * @internal
+ */
+function enumFromStrings(factory, members) {
+    const names = new Set(members);
+    if (names.size !== members.length) {
+        throw new telemetry_utils_1.UsageError("All members of enums must have distinct names");
+    }
+    const factoryOut = (value) => {
+        return new out[value]({});
+    };
+    const out = factoryOut;
+    for (const name of members) {
+        Object.defineProperty(out, name, {
+            enumerable: true,
+            configurable: false,
+            writable: false,
+            value: singletonSchema(factory, name),
+        });
+    }
+    return out;
+}
+exports.enumFromStrings = enumFromStrings;
+// TODO: Why does this one generate an invalid d.ts file if exported?
+// Tracked by https://github.com/microsoft/TypeScript/issues/56718
+// TODO: replace enumFromStrings above with this simpler implementation when the TypeScript bug is resolved.
+function _enumFromStrings2(factory, members) {
+    const enumObject = Object.create(null);
+    for (const name of members) {
+        Object.defineProperty(enumObject, name, {
+            enumerable: true,
+            configurable: false,
+            writable: false,
+            value: name,
+        });
+    }
+    return adaptEnum(factory, enumObject);
+}
+//# sourceMappingURL=schemaCreationUtilities.js.map

package/dist/class-tree/schemaCreationUtilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaCreationUtilities.js","sourceRoot":"","sources":["../../src/class-tree/schemaCreationUtilities.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { UsageError } from \"@fluidframework/telemetry-utils\";\nimport { fail } from \"../util\";\nimport { EmptyObject } from \"../feature-libraries\";\nimport { SchemaFactory } from \"./schemaFactory\";\n// This type is referred to by the base type generated by schema.\n// Adding the import of it here prevents TypeScript from generating inline includes for it in the d.ts file.\n// If we let TypeScript generate these includes, they use relative paths which break API extractor's rollup.\n// eslint-disable-next-line unused-imports/no-unused-imports\nimport { NodeFromSchema, type NodeKind as _dummy } from \"./schemaTypes\";\n\n/**\n * Create a schema for a node with no state.\n * @remarks\n * This is commonly used in unions when the only information needed is which kind of node the value is.\n * Enums are a common example of this pattern.\n * @internal\n */\nexport function singletonSchema<TScope extends string, TName extends string | number>(\n\tfactory: SchemaFactory<TScope, TName>,\n\tname: TName,\n) {\n\treturn class SingletonSchema extends factory.object(name, {}) {\n\t\tpublic constructor(data?: EmptyObject) {\n\t\t\tsuper(data ?? {});\n\t\t}\n\t\tpublic get value(): TName {\n\t\t\treturn name;\n\t\t}\n\t};\n}\n\n/**\n * Converts an enum into a collection of schema which can be used in a union.\n * @remarks\n * Currently only supports `string` enums.\n * @example\n * ```typescript\n * enum Mode {\n * \ta = \"A\",\n * \tb = \"B\",\n * }\n * const ModeNodes = adaptEnum(schema, Mode);\n * type ModeNodes = NodeFromSchema<(typeof ModeNodes)[keyof typeof ModeNodes]>;\n * const nodeFromString: ModeNodes = ModeNodes(Mode.a);\n * const nodeFromSchema: ModeNodes = new ModeNodes.a();\n * const nameFromNode: Mode = nodeFromSchema.value;\n * class Parent extends schemaFactory.object(\"Parent\", {\n * \tmode: typedObjectValues(ModeNodes),\n * }) {}\n * ```\n * @privateRemarks\n * TODO:\n * Extends this to support numeric enums.\n * Maybe require an explicit nested scope to group them under, or at least a warning about collisions.\n * Maybe just provide `SchemaFactory.nested` to east creating nested scopes?\n * @internal\n */\nexport function adaptEnum<TScope extends string, const TEnum extends Record<string, string>>(\n\tfactory: SchemaFactory<TScope>,\n\tmembers: TEnum,\n) {\n\ttype Values = TEnum[keyof TEnum];\n\tconst values = Object.values(members) as Values[];\n\tconst inverse = new Map(Object.entries(members).map(([key, value]) => [value, key])) as Map<\n\t\tValues,\n\t\tkeyof TEnum\n\t>;\n\n\tif (inverse.size !== values.length) {\n\t\tthrow new UsageError(\"All members of enums must have distinct values.\");\n\t}\n\n\ttype TOut = {\n\t\treadonly [Property in keyof TEnum]: ReturnType<\n\t\t\ttypeof singletonSchema<TScope, TEnum[Property]>\n\t\t>;\n\t};\n\tconst factoryOut = <TValue extends Values>(value: TValue) => {\n\t\treturn new out[inverse.get(value) ?? fail(\"missing enum value\")]({}) as NodeFromSchema<\n\t\t\tReturnType<typeof singletonSchema<TScope, TValue>>\n\t\t>;\n\t};\n\tconst out = factoryOut as typeof factoryOut & TOut;\n\tfor (const [key, value] of Object.entries(members)) {\n\t\tObject.defineProperty(out, key, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: false,\n\t\t\twritable: false,\n\t\t\tvalue: singletonSchema(factory, value),\n\t\t});\n\t}\n\n\treturn out;\n}\n\n/**\n * `Object.values`, but with more specific types.\n * @internal\n */\nexport function typedObjectValues<TKey extends string, TValues>(\n\tobject: Record<TKey, TValues>,\n): TValues[] {\n\treturn Object.values(object);\n}\n\n/**\n * Converts an array of distinct strings into a collection of schema which can be used like an enum style union.\n * @remarks\n * The returned collection is also a function which can be used to convert strings into {@link Unhydrated} nodes in the union.\n * Each node type has a `.value` getter which returns the associated string.\n *\n * The produced nodes use the provided strings as their `name`, and don't store any data beyond that.\n * @example\n * ```typescript\n * const Mode = enumFromStrings(schemaFactory, [\"Fun\", \"Cool\"]);\n * type Mode = NodeFromSchema<(typeof Mode)[keyof typeof Mode]>;\n * const nodeFromString: Mode = Mode(\"Fun\");\n * const nodeFromSchema: Mode = new Mode.Fun();\n * const nameFromNode = nodeFromSchema.value;\n *\n * class Parent extends schemaFactory.object(\"Parent\", { mode: typedObjectValues(Mode) }) {}\n * ```\n * @internal\n */\nexport function enumFromStrings<TScope extends string, const Members extends string>(\n\tfactory: SchemaFactory<TScope>,\n\tmembers: Members[],\n) {\n\tconst names = new Set(members);\n\tif (names.size !== members.length) {\n\t\tthrow new UsageError(\"All members of enums must have distinct names\");\n\t}\n\n\ttype TOut = Record<Members, ReturnType<typeof singletonSchema<TScope, Members>>>;\n\tconst factoryOut = <TValue extends Members>(value: TValue) => {\n\t\treturn new out[value]({}) as NodeFromSchema<\n\t\t\tReturnType<typeof singletonSchema<TScope, TValue>>\n\t\t>;\n\t};\n\tconst out = factoryOut as typeof factoryOut & TOut;\n\tfor (const name of members) {\n\t\tObject.defineProperty(out, name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: false,\n\t\t\twritable: false,\n\t\t\tvalue: singletonSchema(factory, name),\n\t\t});\n\t}\n\n\treturn out;\n}\n\n// TODO: Why does this one generate an invalid d.ts file if exported?\n// Tracked by https://github.com/microsoft/TypeScript/issues/56718\n// TODO: replace enumFromStrings above with this simpler implementation when the TypeScript bug is resolved.\nfunction _enumFromStrings2<TScope extends string, const Members extends readonly string[]>(\n\tfactory: SchemaFactory<TScope>,\n\tmembers: Members,\n) {\n\tconst enumObject: {\n\t\t[key in keyof Members as Members[key] extends string ? Members[key] : string]: Members[key];\n\t} = Object.create(null);\n\tfor (const name of members) {\n\t\tObject.defineProperty(enumObject, name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: false,\n\t\t\twritable: false,\n\t\t\tvalue: name,\n\t\t});\n\t}\n\n\treturn adaptEnum(factory, enumObject);\n}\n"]}