@fluidframework/tree 2.2.0 → 2.3.0

package/lib/shared-tree/treeView.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"treeView.js","sourceRoot":"","sources":["../../src/shared-tree/treeView.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAON,cAAc,GACd,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAoB,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAyDnE;;GAEG;AACH,MAAM,OAAO,oBAAoB;IAOhC,YACiB,QAAmB,EACnB,MAA6B,EAC7B,cAA8B,EAC7B,SAAsB;QAHvB,aAAQ,GAAR,QAAQ,CAAW;QACnB,WAAM,GAAN,MAAM,CAAuB;QAC7B,mBAAc,GAAd,cAAc,CAAgB;QAC7B,cAAS,GAAT,SAAS,CAAa;QAEvC,IAAI,CAAC,OAAO,GAAG,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;QACrE,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAC1C,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,IAAiC,CAAC;IAChE,CAAC;IAEM,CAAC,aAAa,CAAC;QACrB,KAAK,MAAM,UAAU,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACvD,kBAAkB,CAAC,UAAU,CAAC,CAAC;QAChC,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC;QAC9B,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;IACpB,CAAC;IAEM,IAAI;QACV,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QACpC,OAAO,IAAI,oBAAoB,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;IAC3E,CAAC;CACD;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,OAAO,EAAgC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport {\n\ttype Context,\n\ttype FlexFieldSchema,\n\ttype FlexTreeContext,\n\ttype FlexTreeSchema,\n\ttype FlexTreeTypedField,\n\ttype NodeKeyManager,\n\tgetTreeContext,\n} from \"../feature-libraries/index.js\";\nimport { tryDisposeTreeNode } from \"../simple-tree/index.js\";\nimport { type IDisposable, disposeSymbol } from \"../util/index.js\";\n\nimport type { ITreeCheckout, ITreeCheckoutFork } from \"./treeCheckout.js\";\n\n/**\n * The portion of {@link FlexTreeView} that does not depend on the schema's type.\n * @privateRemarks\n * Since {@link FlexTreeView}'s schema is invariant, `FlexTreeView<FlexFieldSchema>` does not cover this use case.\n */\nexport interface FlexTreeViewGeneric extends IDisposable {\n\t/**\n\t * Context for controlling the FlexTree nodes produced from {@link FlexTreeView.flexTree}.\n\t *\n\t * @remarks\n\t * This is an owning reference: disposing of this view disposes its context.\n\t */\n\treadonly context: FlexTreeContext;\n\n\t/**\n\t * Access non-view schema specific aspects of of this branch.\n\t *\n\t * @remarks\n\t * This is a non-owning reference: disposing of this view does not impact the branch.\n\t */\n\treadonly checkout: ITreeCheckout;\n}\n\n/**\n * An editable view of a (version control style) branch of a shared tree.\n * @privateRemarks\n * TODO:\n * If schema aware APIs are removed from flex tree, this can be combined with {@link FlexTreeViewGeneric}.\n */\nexport interface FlexTreeView<in out TRoot extends FlexFieldSchema>\n\textends FlexTreeViewGeneric {\n\t/**\n\t * Get a typed view of the tree content using the flex-tree API.\n\t */\n\treadonly flexTree: FlexTreeTypedField<TRoot>;\n\n\t/**\n\t * Spawn a new view which is based off of the current state of this view.\n\t * Any mutations of the new view will not apply to this view until the new view is merged back into this view via `merge()`.\n\t */\n\tfork(): ITreeViewFork<TRoot>;\n}\n\n/**\n * Branch (like in a version control system) of SharedTree.\n *\n * {@link FlexTreeView} that has forked off of the main trunk/branch.\n */\nexport interface ITreeViewFork<in out TRoot extends FlexFieldSchema>\n\textends FlexTreeView<TRoot> {\n\treadonly checkout: ITreeCheckoutFork;\n}\n\n/**\n * Implementation of FlexTreeView wrapping a ITreeCheckout.\n */\nexport class CheckoutFlexTreeView<\n\tin out TRoot extends FlexFieldSchema,\n\tout TCheckout extends ITreeCheckout = ITreeCheckout,\n> implements FlexTreeView<TRoot>\n{\n\tpublic readonly context: Context;\n\tpublic readonly flexTree: FlexTreeTypedField<TRoot>;\n\tpublic constructor(\n\t\tpublic readonly checkout: TCheckout,\n\t\tpublic readonly schema: FlexTreeSchema<TRoot>,\n\t\tpublic readonly nodeKeyManager: NodeKeyManager,\n\t\tprivate readonly onDispose?: () => void,\n\t) {\n\t\tthis.context = getTreeContext(schema, this.checkout, nodeKeyManager);\n\t\tcontextToTreeView.set(this.context, this);\n\t\tthis.flexTree = this.context.root as FlexTreeTypedField<TRoot>;\n\t}\n\n\tpublic [disposeSymbol](): void {\n\t\tfor (const anchorNode of this.checkout.forest.anchors) {\n\t\t\ttryDisposeTreeNode(anchorNode);\n\t\t}\n\n\t\tthis.context[disposeSymbol]();\n\t\tthis.onDispose?.();\n\t}\n\n\tpublic fork(): CheckoutFlexTreeView<TRoot, ITreeCheckout & ITreeCheckoutFork> {\n\t\tconst branch = this.checkout.fork();\n\t\treturn new CheckoutFlexTreeView(branch, this.schema, this.nodeKeyManager);\n\t}\n}\n\n/**\n * Maps the context of every {@link CheckoutFlexTreeView} to the view.\n * In practice, this allows the view or checkout to be obtained from a flex node by first getting the context from the flex node and then using this map.\n */\nexport const contextToTreeView = new WeakMap<Context, FlexTreeViewGeneric>();\n"]}

package/lib/simple-tree/getJsonSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getJsonSchema.d.ts","sourceRoot":"","sources":["../../src/simple-tree/getJsonSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAW7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,oBAAoB,GAAG,cAAc,CAK1E"}

package/lib/simple-tree/getJsonSchema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getJsonSchema.js","sourceRoot":"","sources":["../../src/simple-tree/getJsonSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAG/C;;GAEG;AACH,MAAM,eAAe,GAAG,IAAI,OAAO,EAAkC,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,UAAU,aAAa,CAAC,MAA4B;IACzD,OAAO,WAAW,CAAC,eAAe,EAAE,MAAM,EAAE,GAAG,EAAE;QAChD,MAAM,YAAY,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC;QAC7C,OAAO,YAAY,CAAC,YAAY,CAAC,CAAC;IACnC,CAAC,CAAC,CAAC;AACJ,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { JsonTreeSchema } from \"./jsonSchema.js\";\nimport type { ImplicitAllowedTypes } from \"./schemaTypes.js\";\nimport { toJsonSchema } from \"./simpleSchemaToJsonSchema.js\";\nimport { getSimpleSchema } from \"./getSimpleSchema.js\";\nimport { getOrCreate } from \"../util/index.js\";\nimport type { TreeNodeSchema } from \"./core/index.js\";\n\n/**\n * Cache in which the results of {@link getJsonSchema} are saved.\n */\nconst jsonSchemaCache = new WeakMap<TreeNodeSchema, JsonTreeSchema>();\n\n/**\n * Creates a {@link https://json-schema.org/ | JSON Schema} representation of the provided {@link TreeNodeSchema}.\n *\n * @remarks\n * Useful when communicating the schema to external libraries or services.\n * Caches the result for future calls.\n *\n * @example\n *\n * A Shared Tree schema like the following:\n *\n * ```typescript\n * class MyObject extends schemaFactory.object(\"MyObject\", {\n * \tfoo: schemaFactory.number,\n * \tbar: schemaFactory.optional(schemaFactory.string),\n * });\n * ```\n *\n * Will yield JSON Schema like the following:\n *\n * ```json\n * {\n * \t\"$defs\": {\n * \t\t\"com.fluidframework.leaf.string\": {\n * \t\t\t\"type\": \"string\",\n * \t\t},\n * \t\t\"com.fluidframework.leaf.number\": {\n * \t\t\t\"type\": \"number\",\n * \t\t},\n * \t\t\"com.myapp.MyObject\": {\n * \t\t\t\"type\": \"object\",\n * \t\t\t\"properties\": {\n * \t\t\t\t\"foo\": { \"$ref\": \"com.fluidframework.leaf.number\" },\n * \t\t\t\t\"bar\": { \"$ref\": \"com.fluidframework.leaf.string\" },\n * \t\t\t},\n * \t\t\t\"required\": [\"foo\"],\n * \t\t},\n * \t},\n * \t\"anyOf\": [ { \"$ref\": \"#/$defs/com.myapp.MyObject\" } ],\n * }\n * ```\n *\n * @privateRemarks In the future, we may wish to move this to a more discoverable API location.\n * For now, while still an experimental API, it is surfaced as a free function.\n *\n * @alpha\n */\nexport function getJsonSchema(schema: ImplicitAllowedTypes): JsonTreeSchema {\n\treturn getOrCreate(jsonSchemaCache, schema, () => {\n\t\tconst simpleSchema = getSimpleSchema(schema);\n\t\treturn toJsonSchema(simpleSchema);\n\t});\n}\n"]}

package/lib/simple-tree/getSimpleSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getSimpleSchema.d.ts","sourceRoot":"","sources":["../../src/simple-tree/getSimpleSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAQ1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,oBAAoB,GAAG,gBAAgB,CAE9E"}

package/lib/simple-tree/getSimpleSchema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getSimpleSchema.js","sourceRoot":"","sources":["../../src/simple-tree/getSimpleSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAI/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAEnE;;GAEG;AACH,MAAM,iBAAiB,GAAG,IAAI,OAAO,EAAoC,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,MAAM,UAAU,eAAe,CAAC,MAA4B;IAC3D,OAAO,WAAW,CAAC,iBAAiB,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC;AACjF,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { getOrCreate } from \"../util/index.js\";\nimport type { TreeNodeSchema } from \"./core/index.js\";\nimport type { ImplicitAllowedTypes } from \"./schemaTypes.js\";\nimport type { SimpleTreeSchema } from \"./simpleSchema.js\";\nimport { toSimpleTreeSchema } from \"./viewSchemaToSimpleSchema.js\";\n\n/**\n * Cache in which the results of {@link getSimpleSchema} saved.\n */\nconst simpleSchemaCache = new WeakMap<TreeNodeSchema, SimpleTreeSchema>();\n\n/**\n * Creates a simplified representation of the provided {@link TreeNodeSchema}.\n *\n * @remarks Caches the result on the input schema for future calls.\n *\n * @example\n *\n * A Shared Tree schema like the following:\n *\n * ```typescript\n * class MyObject extends schemaFactory.object(\"MyObject\", {\n * \tfoo: schemaFactory.number,\n * \tbar: schemaFactory.optional(schemaFactory.string),\n * });\n * ```\n *\n * Will yield JSON Schema like the following:\n *\n * ```typescript\n * {\n * \tdefinitions: [\n * \t\t[\"com.fluidframework.leaf.number\", {\n * \t\t\tkind: \"leaf\",\n * \t\t\ttype: \"number\",\n * \t\t}],\n * \t\t[\"com.fluidframework.leaf.string\", {\n * \t\t\tkind: \"leaf\",\n * \t\t\ttype: \"string\",\n * \t\t}],\n * \t\t[\"com.myapp.MyObject\", {\n * \t\t\tkind: \"object\",\n * \t\t\tfields: {\n * \t\t\t\tfoo: {\n * \t\t\t\t\tkind: \"required\",\n * \t\t\t\t\tallowedTypes: [\"com.fluidframework.leaf.number\"]\n * \t\t\t\t},\n * \t\t\t\tbar: {\n * \t\t\t\t\tkind: \"optional\",\n * \t\t\t\t\tallowedTypes: [\"com.fluidframework.leaf.string\"]\n * \t\t\t\t},\n * \t\t\t},\n * \t\t}],\n * \t],\n * \tallowedTypes: [\"com.myapp.MyObject\"],\n * }\n * ```\n *\n * @privateRemarks In the future, we may wish to move this to a more discoverable API location.\n * For now, while still an experimental API, it is surfaced as a free function.\n */\nexport function getSimpleSchema(schema: ImplicitAllowedTypes): SimpleTreeSchema {\n\treturn getOrCreate(simpleSchemaCache, schema, () => toSimpleTreeSchema(schema));\n}\n"]}

package/lib/simple-tree/jsonSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonSchema.d.ts","sourceRoot":"","sources":["../../src/simple-tree/jsonSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC;AAElC;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,WAAW,YAAY,EAAE,CAAC;AAEpD;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,OAAO,GAAG,kBAAkB,CAAC;AAErE;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAC;AAE1E;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB,CAClC,SAAS,SAAS,QAAQ,EAC1B,eAAe,SAAS,cAAc;IAEtC;;;;;;;OAOG;IACH,QAAQ,CAAC,mBAAmB,EAAE,SAAS,CAAC;IAExC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;CAC/B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAqB,SAAQ,kBAAkB,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1F;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAErD;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAE7B;;;OAGG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;CACxC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAoB,SAAQ,kBAAkB,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACvF;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE;QACf;;;;WAIG;QACH,KAAK,EAAE,aAAa,EAAE,CAAC;KACvB,CAAC;CACF;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,iBAAkB,SAAQ,kBAAkB,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IACpF;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,EAAE;QAC3B;;;WAGG;QACH,MAAM,EAAE,eAAe,CAAC;KACxB,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAChB,SAAQ,kBAAkB,CAAC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAC7D;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;CAClC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC7B;;;OAGG;IACH,IAAI,EAAE,WAAW,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,GACvB,kBAAkB,GAClB,iBAAiB,GACjB,mBAAmB,GACnB,oBAAoB,CAAC;AAExB;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,aAAa,EAAE,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,cAAe,SAAQ,eAAe;IACtD;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;CACrD"}

package/lib/simple-tree/jsonSchema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonSchema.js","sourceRoot":"","sources":["../../src/simple-tree/jsonSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { NodeKind } from \"./core/index.js\";\n\n/**\n * The fully-qualified {@link TreeNodeSchemaCore.identifier}.\n * @alpha\n */\nexport type JsonSchemaId = string;\n\n/**\n * Reference string pointing to a definition in the schema.\n * Should be the fully-qualified {@link TreeNodeSchemaCore.identifier}.\n * @remarks Of the form `#/$defs/<schema-identifier>`, where the `schema-identifier` is the fully-qualified {@link TreeNodeSchemaCore.identifier}.\n * @example Schema `com.myapp.foo` would be referenced via `#/$defs/com.myapp.foo`.\n * @alpha\n */\nexport type JsonRefPath = `#/$defs/${JsonSchemaId}`;\n\n/**\n * JSON entity type.\n * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.\n * @alpha\n */\nexport type JsonSchemaType = \"object\" | \"array\" | JsonLeafSchemaType;\n\n/**\n * JSON primitive types.\n * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.\n * @alpha\n */\nexport type JsonLeafSchemaType = \"string\" | \"number\" | \"boolean\" | \"null\";\n\n/**\n * Base interface for node schemas represented in {@link https://json-schema.org/draft/2020-12/json-schema-core | JSON Schema} format.\n *\n * @sealed\n * @alpha\n */\nexport interface JsonNodeSchemaBase<\n\tTNodeKind extends NodeKind,\n\tTJsonSchemaType extends JsonSchemaType,\n> {\n\t/**\n\t * Kind of {@link TreeNodeSchema} this JSON Schema entry represents.\n\t *\n\t * @remarks There is not a 1:1 mapping between {@link TreeNodeSchema} types and JSON Schema types.\n\t * This is used to disambiguate the type of {@link TreeNodeSchema} this JSON Schema maps to.\n\t *\n\t * Note: This property name is not a part of the JSON Schema spec. This is a Fluid-specific extension.\n\t */\n\treadonly _treeNodeSchemaKind: TNodeKind;\n\n\t/**\n\t * {@inheritDoc JsonSchemaType}\n\t */\n\treadonly type: TJsonSchemaType;\n}\n\n/**\n * JSON Schema for an object node.\n *\n * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.\n *\n * @sealed\n * @alpha\n */\nexport interface JsonObjectNodeSchema extends JsonNodeSchemaBase<NodeKind.Object, \"object\"> {\n\t/**\n\t * Object fields.\n\t * @remarks Required fields should have a corresponding entry in {@link JsonObjectNodeSchema.required}.\n\t * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-properties}.\n\t */\n\treadonly properties: Record<string, JsonFieldSchema>;\n\n\t/**\n\t * List of keys for required fields.\n\t *\n\t * @remarks\n\t * Optional fields should not be included in this list.\n\t * Each key specified must have an entry in {@link JsonObjectNodeSchema.properties}.\n\t */\n\treadonly required?: string[];\n\n\t/**\n\t * Whether or not additional properties (properties not specified by the schema) are allowed in objects of this type.\n\t * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-additionalproperties}.\n\t */\n\treadonly additionalProperties?: boolean;\n}\n\n/**\n * JSON Schema for an array node.\n *\n * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.\n *\n * @sealed\n * @alpha\n */\nexport interface JsonArrayNodeSchema extends JsonNodeSchemaBase<NodeKind.Array, \"array\"> {\n\t/**\n\t * The kinds of items allowed under the array.\n\t * @remarks Always represented via references to {@link JsonTreeSchema.$defs}.\n\t *\n\t * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-items}.\n\t */\n\treadonly items: {\n\t\t/**\n\t\t * The kinds of items allowed under the array.\n\t\t * @remarks Always represented via references to {@link JsonTreeSchema.$defs}.\n\t\t * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-anyof}.\n\t\t */\n\t\tanyOf: JsonSchemaRef[];\n\t};\n}\n\n/**\n * JSON Schema for a map node.\n *\n * @remarks Special case for map nodes, which do not have a native JSON schema corollary.\n *\n * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.\n *\n * @sealed\n * @alpha\n */\nexport interface JsonMapNodeSchema extends JsonNodeSchemaBase<NodeKind.Map, \"object\"> {\n\t/**\n\t * Used to control the types of properties that can appear in the \"object\" representation of the map.\n\t * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-patternproperties}.\n\t */\n\treadonly patternProperties: {\n\t\t/**\n\t\t * Types allowed in the map.\n\t\t * @remarks This format allows for any (JSON-compliant) key, but restricts the allowed types to only those specified.\n\t\t */\n\t\t\"^.*$\": JsonFieldSchema;\n\t};\n}\n\n/**\n * JSON Schema for a leaf node.\n *\n * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.\n *\n * @sealed\n * @alpha\n */\nexport interface JsonLeafNodeSchema\n\textends JsonNodeSchemaBase<NodeKind.Leaf, JsonLeafSchemaType> {\n\t/**\n\t * Primitive type.\n\t * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-instance-data-model}.\n\t */\n\treadonly type: JsonLeafSchemaType;\n}\n\n/**\n * Type entry containing a reference to a definition in the schema.\n *\n * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-schema-references}.\n *\n * @sealed\n * @alpha\n */\nexport interface JsonSchemaRef {\n\t/**\n\t * Reference to a definition in the schema.\n\t * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-direct-references-with-ref}.\n\t */\n\t$ref: JsonRefPath;\n}\n\n/**\n * {@link https://json-schema.org/draft/2020-12/json-schema-core | JSON Schema} representation of a {@link TreeNodeSchema}.\n *\n * @alpha\n */\nexport type JsonNodeSchema =\n\t| JsonLeafNodeSchema\n\t| JsonMapNodeSchema\n\t| JsonArrayNodeSchema\n\t| JsonObjectNodeSchema;\n\n/**\n *{@link https://json-schema.org/draft/2020-12/json-schema-core | JSON Schema} representation of a {@link FieldSchema}.\n *\n * @sealed\n * @alpha\n */\nexport interface JsonFieldSchema {\n\t/**\n\t * The kinds of items allowed under the field.\n\t * @remarks Always represented via references to {@link JsonTreeSchema.$defs}.\n\t * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-anyof}.\n\t */\n\treadonly anyOf: JsonSchemaRef[];\n}\n\n/**\n * {@link https://json-schema.org/draft/2020-12/json-schema-core | JSON Schema} representation of a tree schema.\n *\n * @remarks\n * Includes the complete set of definitions reachable from the \"root\" schema.\n *\n * Note: This representation only uses a limited subset of supported JSON Schema features.\n * It is scoped to a format that can be used to sufficiently represent supported SharedTree schema.\n *\n * Also note that this schema format contains Fluid-specific extensions, such as the {@link JsonNodeSchemaBase._treeNodeSchemaKind}\n * property, meaning that it is not a *strict* subset.\n * When using these schemas with validation tools (for example, {@link https://ajv.js.org/}), you will need to opt out\n * of *strict* validation to ensure extra properties are allowed.\n *\n * @privateRemarks\n * Extending JSON Schema is permitted by the spec.\n * See {@link https://json-schema.org/draft/2020-12/json-schema-core#name-extending-json-schema}.\n *\n * @sealed\n * @alpha\n */\nexport interface JsonTreeSchema extends JsonFieldSchema {\n\t/**\n\t * The set of definitions reachable from this schema's root.\n\t * @see {@link https://json-schema.org/draft/2020-12/json-schema-core#name-schema-re-use-with-defs}\n\t */\n\treadonly $defs: Record<JsonSchemaId, JsonNodeSchema>;\n}\n"]}

package/lib/simple-tree/simpleSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"simpleSchema.d.ts","sourceRoot":"","sources":["../../src/simple-tree/simpleSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD;;;;GAIG;AACH,MAAM,WAAW,oBAAoB,CAAC,SAAS,SAAS,QAAQ;IAC/D;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAuB,SAAQ,oBAAoB,CAAC,QAAQ,CAAC,MAAM,CAAC;IACpF;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;CACnD;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAsB,SAAQ,oBAAoB,CAAC,QAAQ,CAAC,KAAK,CAAC;IAClF;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC3C;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAoB,SAAQ,oBAAoB,CAAC,QAAQ,CAAC,GAAG,CAAC;IAC9E;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC3C;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB,CAAC,QAAQ,CAAC,IAAI,CAAC;IAChF;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GACzB,oBAAoB,GACpB,mBAAmB,GACnB,qBAAqB,GACrB,sBAAsB,CAAC;AAE1B;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAiB;IACjC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAEzB;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC3C;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAChC;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAE5D;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC3C"}

package/lib/simple-tree/simpleSchema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"simpleSchema.js","sourceRoot":"","sources":["../../src/simple-tree/simpleSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { ValueSchema } from \"../core/index.js\";\nimport type { NodeKind } from \"./core/index.js\";\nimport type { FieldKind } from \"./schemaTypes.js\";\n\n/**\n * Base interface for all {@link SimpleNodeSchema} implementations.\n *\n * @sealed\n */\nexport interface SimpleNodeSchemaBase<TNodeKind extends NodeKind> {\n\t/**\n\t * The kind of {@link SimpleNodeSchema}.\n\t *\n\t * @remarks can be used to type-switch between implementations.\n\t */\n\treadonly kind: TNodeKind;\n}\n\n/**\n * A {@link SimpleNodeSchema} for an object node.\n *\n * @sealed\n */\nexport interface SimpleObjectNodeSchema extends SimpleNodeSchemaBase<NodeKind.Object> {\n\t/**\n\t * Schemas for each of the object's fields, keyed off of schema's view keys.\n\t */\n\treadonly fields: Record<string, SimpleFieldSchema>;\n}\n\n/**\n * A {@link SimpleNodeSchema} for an array node.\n *\n * @sealed\n */\nexport interface SimpleArrayNodeSchema extends SimpleNodeSchemaBase<NodeKind.Array> {\n\t/**\n\t * The types allowed in the array.\n\t *\n\t * @remarks Refers to the types by identifier.\n\t * A {@link SimpleTreeSchema} is needed to resolve these identifiers to their schema {@link SimpleTreeSchema.definitions}.\n\t */\n\treadonly allowedTypes: ReadonlySet<string>;\n}\n\n/**\n * A {@link SimpleNodeSchema} for a map node.\n *\n * @sealed\n */\nexport interface SimpleMapNodeSchema extends SimpleNodeSchemaBase<NodeKind.Map> {\n\t/**\n\t * The types allowed as values in the map.\n\t *\n\t * @remarks Refers to the types by identifier.\n\t * A {@link SimpleTreeSchema} is needed to resolve these identifiers to their schema {@link SimpleTreeSchema.definitions}.\n\t */\n\treadonly allowedTypes: ReadonlySet<string>;\n}\n\n/**\n * A {@link SimpleNodeSchema} for a leaf node.\n *\n * @sealed\n */\nexport interface SimpleLeafNodeSchema extends SimpleNodeSchemaBase<NodeKind.Leaf> {\n\t/**\n\t * The kind of leaf node.\n\t */\n\treadonly leafKind: ValueSchema;\n}\n\n/**\n * A simple, shallow representation of a schema for a node.\n *\n * @remarks This definition is incomplete, and references child types by identifiers.\n * To be useful, this generally needs to be used as a part of a complete {@link SimpleTreeSchema}, which\n * contains backing {@link SimpleTreeSchema.definitions} for each referenced identifier.\n */\nexport type SimpleNodeSchema =\n\t| SimpleLeafNodeSchema\n\t| SimpleMapNodeSchema\n\t| SimpleArrayNodeSchema\n\t| SimpleObjectNodeSchema;\n\n/**\n * A simple, shallow representation of a schema for a field.\n *\n * @remarks This definition is incomplete, and references child types by identifiers.\n * To be useful, this generally needs to be used as a part of a complete {@link SimpleTreeSchema}, which\n * contains backing {@link SimpleTreeSchema.definitions} for each referenced identifier.\n *\n * @sealed\n */\nexport interface SimpleFieldSchema {\n\t/**\n\t * The kind of object field.\n\t */\n\treadonly kind: FieldKind;\n\n\t/**\n\t * The types allowed under the field.\n\t *\n\t * @remarks Refers to the types by identifier.\n\t * A {@link SimpleTreeSchema} is needed to resolve these identifiers to their schema {@link SimpleTreeSchema.definitions}.\n\t */\n\treadonly allowedTypes: ReadonlySet<string>;\n}\n\n/**\n * A simplified representation of a schema for a tree.\n *\n * @remarks Contains the complete set of schema {@link SimpleTreeSchema.definitions} required to resolve references\n * by schema identifier.\n *\n * @sealed\n */\nexport interface SimpleTreeSchema {\n\t/**\n\t * The complete set of node schema definitions recursively referenced by the tree's {@link SimpleTreeSchema.allowedTypes}.\n\t *\n\t * @remarks the keys are the schemas' {@link TreeNodeSchemaCore.identifier | identifiers}.\n\t */\n\treadonly definitions: ReadonlyMap<string, SimpleNodeSchema>;\n\n\t/**\n\t * The types allowed under the root of the tree.\n\t *\n\t * @remarks Refers to the types by identifier.\n\t * {@link SimpleTreeSchema.definitions} can be used to resolve these identifiers to their associated schema definition.\n\t */\n\treadonly allowedTypes: ReadonlySet<string>;\n}\n"]}

package/lib/simple-tree/simpleSchemaToJsonSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"simpleSchemaToJsonSchema.d.ts","sourceRoot":"","sources":["../../src/simple-tree/simpleSchemaToJsonSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,KAAK,EASX,cAAc,EAEd,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAMX,gBAAgB,EAChB,MAAM,mBAAmB,CAAC;AAG3B;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,gBAAgB,GAAG,cAAc,CAYrE"}

package/lib/simple-tree/simpleSchemaToJsonSchema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"simpleSchemaToJsonSchema.js","sourceRoot":"","sources":["../../src/simple-tree/simpleSchemaToJsonSchema.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 { unreachableCase } from \"@fluidframework/core-utils/internal\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\nimport { ValueSchema } from \"../core/index.js\";\nimport { getOrCreate } from \"../util/index.js\";\nimport type {\n\tJsonArrayNodeSchema,\n\tJsonFieldSchema,\n\tJsonSchemaRef,\n\tJsonRefPath,\n\tJsonLeafNodeSchema,\n\tJsonMapNodeSchema,\n\tJsonNodeSchema,\n\tJsonObjectNodeSchema,\n\tJsonTreeSchema,\n\tJsonLeafSchemaType,\n} from \"./jsonSchema.js\";\nimport { FieldKind } from \"./schemaTypes.js\";\nimport type {\n\tSimpleArrayNodeSchema,\n\tSimpleLeafNodeSchema,\n\tSimpleMapNodeSchema,\n\tSimpleNodeSchema,\n\tSimpleObjectNodeSchema,\n\tSimpleTreeSchema,\n} from \"./simpleSchema.js\";\nimport { NodeKind } from \"./core/index.js\";\n\n/**\n * Generates a JSON Schema representation from a simple tree schema.\n * @internal\n */\nexport function toJsonSchema(schema: SimpleTreeSchema): JsonTreeSchema {\n\tconst definitions = convertDefinitions(schema.definitions);\n\n\tconst anyOf: JsonSchemaRef[] = [];\n\tfor (const allowedType of schema.allowedTypes) {\n\t\tanyOf.push(createSchemaRef(allowedType));\n\t}\n\n\treturn {\n\t\t$defs: definitions,\n\t\tanyOf,\n\t};\n}\n\nfunction convertDefinitions(\n\tdefinitions: ReadonlyMap<string, SimpleNodeSchema>,\n): Record<string, JsonNodeSchema> {\n\tconst result: Record<string, JsonNodeSchema> = {};\n\tfor (const [key, value] of definitions) {\n\t\tresult[key] = convertNodeSchema(value);\n\t}\n\treturn result;\n}\n\n/**\n * Private symbol under which the results of {@link convertNodeSchema} are cached on an input {@link SimpleNodeSchema}.\n */\nconst nodeJsonSchemaCache = new WeakMap<SimpleNodeSchema, JsonNodeSchema>();\n\n/**\n * Converts an input {@link SimpleNodeSchema} to a {@link JsonNodeSchema}.\n *\n * @remarks Caches the result on the input schema for future calls.\n */\nfunction convertNodeSchema(schema: SimpleNodeSchema): JsonNodeSchema {\n\treturn getOrCreate(nodeJsonSchemaCache, schema, () => {\n\t\tswitch (schema.kind) {\n\t\t\tcase NodeKind.Array:\n\t\t\t\treturn convertArrayNodeSchema(schema);\n\t\t\tcase NodeKind.Leaf:\n\t\t\t\treturn convertLeafNodeSchema(schema);\n\t\t\tcase NodeKind.Map:\n\t\t\t\treturn convertMapNodeSchema(schema);\n\t\t\tcase NodeKind.Object:\n\t\t\t\treturn convertObjectNodeSchema(schema);\n\t\t\tdefault:\n\t\t\t\tthrow new TypeError(`Unknown node schema kind: ${(schema as SimpleNodeSchema).kind}`);\n\t\t}\n\t});\n}\n\nfunction convertArrayNodeSchema(schema: SimpleArrayNodeSchema): JsonArrayNodeSchema {\n\tconst allowedTypes: JsonSchemaRef[] = [];\n\tschema.allowedTypes.forEach((type) => {\n\t\tallowedTypes.push(createSchemaRef(type));\n\t});\n\treturn {\n\t\ttype: \"array\",\n\t\t_treeNodeSchemaKind: NodeKind.Array,\n\t\titems: {\n\t\t\tanyOf: allowedTypes,\n\t\t},\n\t};\n}\n\nfunction convertLeafNodeSchema(schema: SimpleLeafNodeSchema): JsonLeafNodeSchema {\n\tlet type: JsonLeafSchemaType;\n\tswitch (schema.leafKind) {\n\t\tcase ValueSchema.String:\n\t\t\ttype = \"string\";\n\t\t\tbreak;\n\t\tcase ValueSchema.Number:\n\t\t\ttype = \"number\";\n\t\t\tbreak;\n\t\tcase ValueSchema.Boolean:\n\t\t\ttype = \"boolean\";\n\t\t\tbreak;\n\t\tcase ValueSchema.Null:\n\t\t\ttype = \"null\";\n\t\t\tbreak;\n\t\tcase ValueSchema.FluidHandle:\n\t\t\tthrow new UsageError(\"Fluid handles are not supported via JSON Schema.\");\n\t\tdefault:\n\t\t\tunreachableCase(schema.leafKind);\n\t}\n\n\treturn {\n\t\ttype,\n\t\t_treeNodeSchemaKind: NodeKind.Leaf,\n\t};\n}\n\nfunction convertObjectNodeSchema(schema: SimpleObjectNodeSchema): JsonObjectNodeSchema {\n\tconst properties: Record<string, JsonFieldSchema> = {};\n\tconst required: string[] = [];\n\tfor (const [key, value] of Object.entries(schema.fields)) {\n\t\tconst anyOf: JsonSchemaRef[] = [];\n\t\tfor (const allowedType of value.allowedTypes) {\n\t\t\tanyOf.push(createSchemaRef(allowedType));\n\t\t}\n\n\t\tproperties[key] = {\n\t\t\tanyOf,\n\t\t};\n\t\tif (value.kind === FieldKind.Required) {\n\t\t\trequired.push(key);\n\t\t}\n\t}\n\treturn {\n\t\ttype: \"object\",\n\t\t_treeNodeSchemaKind: NodeKind.Object,\n\t\tproperties,\n\t\trequired,\n\t\tadditionalProperties: false,\n\t};\n}\n\nfunction convertMapNodeSchema(schema: SimpleMapNodeSchema): JsonMapNodeSchema {\n\tconst allowedTypes: JsonSchemaRef[] = [];\n\tschema.allowedTypes.forEach((type) => {\n\t\tallowedTypes.push(createSchemaRef(type));\n\t});\n\treturn {\n\t\ttype: \"object\",\n\t\t_treeNodeSchemaKind: NodeKind.Map,\n\t\tpatternProperties: {\n\t\t\t\"^.*$\": {\n\t\t\t\tanyOf: allowedTypes,\n\t\t\t},\n\t\t},\n\t};\n}\n\nfunction createSchemaRef(schemaId: string): JsonSchemaRef {\n\treturn {\n\t\t\"$ref\": createRefPath(schemaId),\n\t};\n}\n\nfunction createRefPath(schemaId: string): JsonRefPath {\n\treturn `#/$defs/${schemaId}`;\n}\n"]}

package/lib/simple-tree/viewSchemaToSimpleSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"viewSchemaToSimpleSchema.d.ts","sourceRoot":"","sources":["../../src/simple-tree/viewSchemaToSimpleSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAGN,KAAK,oBAAoB,EACzB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAOX,gBAAgB,EAChB,MAAM,mBAAmB,CAAC;AAM3B;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,oBAAoB,GAAG,gBAAgB,CAYjF"}

package/src/domains/README.md

@@ -1,6 +0,0 @@
-# domains
-
-A collection of domain libraries.
-
-Domain libraries collect together code related to a particular content type or related sets of content types (aka a domain).
-These typically include schema, as well as an specialized code that works with objects that are related to those schema.

package/src/domains/fence.json

@@ -1,5 +0,0 @@
-{
-	"tags": ["domains"],
-	"exports": ["index"],
-	"imports": ["util", "core", "feature-libraries"]
-}

package/src/domains/index.ts

@@ -1,19 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-export { SchemaBuilder } from "./schemaBuilder.js";
-export {
-	cursorToJsonObject,
-	jsonArray,
-	jsonObject,
-	jsonRoot,
-	jsonSchema,
-	singleJsonCursor,
-	typedJsonCursor,
-	type TypedJsonCompatible,
-	type TypedJsonCompatibleObject,
-} from "./json/index.js";
-
-export { leaf } from "./leafDomain.js";

package/src/domains/json/fence.json

@@ -1,5 +0,0 @@
-{
-	"tags": ["domains-json"],
-	"exports": ["index"],
-	"imports": ["util", "core", "feature-libraries", "domains"]
-}

package/src/domains/json/index.ts

@@ -1,13 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-export {
-	singleJsonCursor,
-	cursorToJsonObject,
-	typedJsonCursor,
-	type TypedJsonCompatible,
-	type TypedJsonCompatibleObject,
-} from "./jsonCursor.js";
-export { jsonSchema, jsonObject, jsonArray, jsonRoot } from "./jsonDomainSchema.js";

package/src/domains/json/jsonCursor.ts

@@ -1,247 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { assert } from "@fluidframework/core-utils/internal";
-
-import {
-	EmptyKey,
-	type FieldKey,
-	type ITreeCursor,
-	type ITreeCursorSynchronous,
-	mapCursorField,
-	mapCursorFields,
-} from "../../core/index.js";
-import {
-	type CursorAdapter,
-	stackTreeNodeCursor,
-	TreeNodeSchemaBase,
-} from "../../feature-libraries/index.js";
-import { brand, isReadonlyArray, type JsonCompatible } from "../../util/index.js";
-import { leaf } from "../leafDomain.js";
-
-import { jsonArray, jsonObject } from "./jsonDomainSchema.js";
-import { isFluidHandle } from "@fluidframework/runtime-utils/internal";
-import type { IFluidHandle } from "@fluidframework/core-interfaces/internal";
-
-const adapter: CursorAdapter<JsonCompatible> = {
-	value: (node: JsonCompatible) =>
-		node !== null && typeof node === "object"
-			? undefined // arrays and objects have no defined value
-			: node, // null, boolean, numbers, and strings are their own values
-	type: (node: JsonCompatible) => {
-		const type = typeof node;
-
-		switch (type) {
-			case "number":
-				return leaf.number.name;
-			case "string":
-				return leaf.string.name;
-			case "boolean":
-				return leaf.boolean.name;
-			default:
-				if (node === null) {
-					return leaf.null.name;
-				} else if (isReadonlyArray(node)) {
-					return jsonArray.name;
-				} else {
-					return jsonObject.name;
-				}
-		}
-	},
-	keysFromNode: (node: JsonCompatible): readonly FieldKey[] => {
-		switch (typeof node) {
-			case "object":
-				if (node === null) {
-					return [];
-				} else if (isReadonlyArray(node)) {
-					return node.length === 0 ? [] : [EmptyKey];
-				} else {
-					return Object.keys(node) as FieldKey[];
-				}
-			default:
-				return [];
-		}
-	},
-	getFieldFromNode: (node: JsonCompatible, key: FieldKey): readonly JsonCompatible[] => {
-		// Object.prototype.hasOwnProperty can return true for strings (ex: with key "0"), so we have to filter them out.
-		// Rather than just special casing strings, we can handle them with an early return for all primitives.
-		if (typeof node !== "object") {
-			return [];
-		}
-
-		if (node === null) {
-			return [];
-		}
-
-		if (isReadonlyArray(node)) {
-			return key === EmptyKey ? node : [];
-		}
-
-		if (Object.prototype.hasOwnProperty.call(node, key)) {
-			const field = node[key];
-			assert(
-				field !== undefined,
-				0x41e /* explicit undefined fields should not be preserved in JSON */,
-			);
-			return [field];
-		}
-
-		return [];
-	},
-};
-
-/**
- * Used to read generic json compatible data as a tree in the JSON domain.
- * The returned tree will have a schema in the json domain as defined by {@link jsonRoot}.
- *
- * @returns an {@link ITreeCursorSynchronous} for a single {@link JsonCompatible}.
- */
-export function singleJsonCursor(root: JsonCompatible): ITreeCursorSynchronous {
-	return stackTreeNodeCursor(adapter, root);
-}
-
-/**
- * Extract a JS object tree from the contents of the given ITreeCursor.
- * Assumes that ITreeCursor contains only unaugmented JsonTypes.
- */
-export function cursorToJsonObject(reader: ITreeCursor): JsonCompatible {
-	const type = reader.type;
-
-	switch (type) {
-		case leaf.number.name:
-		case leaf.boolean.name:
-		case leaf.string.name:
-			assert(reader.value !== undefined, 0x84f /* out of schema: missing value */);
-			assert(!isFluidHandle(reader.value), 0x850 /* out of schema: unexpected FluidHandle */);
-			return reader.value;
-		case jsonArray.name: {
-			reader.enterField(EmptyKey);
-			const result = mapCursorField(reader, cursorToJsonObject);
-			reader.exitField();
-			return result;
-		}
-		case jsonObject.name: {
-			const result: JsonCompatible = {};
-			mapCursorFields(reader, (cursor) => {
-				const key = cursor.getFieldKey();
-				assert(cursor.firstNode(), 0x420 /* expected non-empty field */);
-				// like `result[key] = cursorToJsonObject(reader);` except safe when keyString == "__proto__".
-				Object.defineProperty(result, key, {
-					enumerable: true,
-					configurable: true,
-					writable: true,
-					value: cursorToJsonObject(reader),
-				});
-				assert(!cursor.nextNode(), 0x421 /* expected exactly one node */);
-			});
-			return result;
-		}
-		default: {
-			assert(type === leaf.null.name, 0x422 /* unexpected type */);
-			return null;
-		}
-	}
-}
-
-// #region TypedJsonCursor
-
-/** Used to construct a {@link TypedJsonCursor} */
-export interface TypedJsonCompatibleObject {
-	[key: string]: TypedJsonCompatible;
-	[typedJsonSymbol]: string | TreeNodeSchemaBase;
-}
-
-/** Used to construct a {@link TypedJsonCursor} */
-export type TypedJsonCompatible =
-	| JsonCompatible
-	| TypedJsonCompatibleObject
-	| TypedJsonCompatible[]
-	| IFluidHandle
-	| JsonCompatible;
-
-const typedJsonSymbol = Symbol("JSON Cursor Type");
-
-function isObject(json: TypedJsonCompatible): json is TypedJsonCompatibleObject {
-	if (typeof json === "object" && json !== null) {
-		const typed = json as Partial<TypedJsonCompatibleObject>;
-		return typed[typedJsonSymbol] !== undefined;
-	}
-
-	return false;
-}
-
-const typedAdapter: CursorAdapter<TypedJsonCompatible> = {
-	value: (node: TypedJsonCompatible) => {
-		if (isFluidHandle(node)) {
-			return node;
-		}
-
-		// TODO: Get rid of this cast by combining TypedJsonCompatible and JsonCompatible into a single cursor with flags to configure behavior.
-		// This cast is necessary because TypedJsonCompatible can have Fluid handles underneath it, however, `adapter` only cares if `node` itself is a FluidHandle, which it is not.
-		return adapter.value(node as JsonCompatible);
-	},
-	type: (node: TypedJsonCompatible) => {
-		if (isFluidHandle(node)) {
-			return leaf.handle.name;
-		}
-
-		if (isObject(node)) {
-			const type = node[typedJsonSymbol];
-			return type instanceof TreeNodeSchemaBase ? type.name : brand(type);
-		}
-
-		return adapter.type(node as JsonCompatible);
-	},
-	keysFromNode: (node: TypedJsonCompatible): readonly FieldKey[] => {
-		if (isFluidHandle(node)) {
-			return [];
-		}
-		return adapter.keysFromNode(node as JsonCompatible);
-	},
-	getFieldFromNode: (
-		node: TypedJsonCompatible,
-		key: FieldKey,
-	): readonly TypedJsonCompatible[] => {
-		if (isFluidHandle(node)) {
-			return [];
-		}
-
-		const field = adapter.getFieldFromNode(node as JsonCompatible, key);
-		if (isReadonlyArray(field) && field.length === 1 && isReadonlyArray(field[0])) {
-			// If the field is an array wrapping another array, then unbox to the inner array
-			return field[0];
-		}
-
-		return field;
-	},
-};
-
-/**
- * A variant of {@link singleJsonCursor} which allows types to be provided for nodes.
- *
- * @remarks Types are optional, but if present will be used to derive the type of the node when the cursor is read.
- *
- * This cursor differs from singleJsonCursor in that it inlines arrays, (arrays are not boxed into an "array node" but are directly interpreted as sequence fields).
- *
- * It also allows Fluid handles as input.
- *
- * @example
- * ```ts
- * const cursor = typedJsonCursor({
- *   [typedJsonCursor.type]: Point,
- *   x: 3,
- *   y: 42
- * });
- * ```
- */
-const singleTypedJsonCursor = function (root: TypedJsonCompatible): ITreeCursorSynchronous {
-	return stackTreeNodeCursor(typedAdapter, root);
-};
-
-singleTypedJsonCursor.type = typedJsonSymbol;
-
-export { singleTypedJsonCursor as typedJsonCursor };
-
-// #endregion TypedJsonCursor

package/src/domains/json/jsonDomainSchema.ts

@@ -1,47 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-// Adding this unused import makes the generated d.ts file produced by TypeScript stop breaking API-Extractor's rollup generation.
-// Without this import, TypeScript generates inline `import("../..")` statements in the d.ts file,
-// which API-Extractor leaves as is when generating the rollup, leaving them pointing at the wrong directory.
-// API-Extractor issue: https://github.com/microsoft/rushstack/issues/4507
-// eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports
-import { EmptyKey, ValueSchema } from "../../core/index.js";
-import {
-	FieldKinds,
-	type FlexAllowedTypes,
-	FlexFieldSchema,
-	SchemaBuilderInternal,
-} from "../../feature-libraries/index.js";
-import type { requireAssignableTo } from "../../util/index.js";
-import { leaf } from "../leafDomain.js";
-
-const builder = new SchemaBuilderInternal({
-	scope: "com.fluidframework.json",
-	libraries: [leaf.library],
-});
-
-const jsonPrimitives = [...leaf.primitives, leaf.null] as const;
-
-/**
- * Types allowed as roots of Json content.
- */
-export const jsonRoot = [() => jsonObject, () => jsonArray, ...jsonPrimitives] as const;
-
-{
-	// Recursive objects don't get this type checking automatically, so confirm it
-	type _check = requireAssignableTo<typeof jsonRoot, FlexAllowedTypes>;
-}
-
-export const jsonObject = builder.mapRecursive(
-	"object",
-	FlexFieldSchema.createUnsafe(FieldKinds.optional, jsonRoot),
-);
-
-export const jsonArray = builder.objectRecursive("array", {
-	[EmptyKey]: FlexFieldSchema.createUnsafe(FieldKinds.sequence, jsonRoot),
-});
-
-export const jsonSchema = builder.intoLibrary();

package/src/domains/leafDomain.ts

@@ -1,97 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { ValueSchema } from "../core/index.js";
-import { SchemaBuilderInternal } from "../feature-libraries/index.js";
-
-/**
- * Names in this domain follow https://en.wikipedia.org/wiki/Reverse_domain_name_notation
- */
-const builder = new SchemaBuilderInternal({ scope: "com.fluidframework.leaf" });
-
-const number = builder.leaf("number", ValueSchema.Number);
-const boolean = builder.leaf("boolean", ValueSchema.Boolean);
-const string = builder.leaf("string", ValueSchema.String);
-const handle = builder.leaf("handle", ValueSchema.FluidHandle);
-const nullSchema = builder.leaf("null", ValueSchema.Null);
-
-const primitives = [number, boolean, string] as const;
-const all = [handle, nullSchema, ...primitives] as const;
-
-const library = builder.intoLibrary();
-
-/**
- * Built-in {@link LeafNodeSchema}.
- */
-export const leaf = {
-	/**
-	 * {@link LeafNodeSchema} for holding a JavaScript `number`.
-	 *
-	 * @remarks
-	 * The number is a [double-precision 64-bit binary format IEEE 754](https://en.wikipedia.org/wiki/Double-precision_floating-point_format) value, however there are some exceptions:
-	 * - `NaN`, and the infinities should not be used.
-	 * - `-0` may be converted to `0` in some cases.
-	 *
-	 * These limitations match the limitations of JSON.
-	 * @privateRemarks
-	 * TODO:
-	 * We should be much more clear about what happens if you use problematic values.
-	 * We should validate and/or normalize them when inserting content.
-	 */
-	number,
-
-	/**
-	 * {@link LeafNodeSchema} for holding a boolean.
-	 */
-	boolean,
-
-	/**
-	 * {@link LeafNodeSchema} for holding a JavaScript `string`.
-	 *
-	 * @remarks
-	 * Strings containing unpaired UTF-16 surrogate pair code units may not be handled correctly.
-	 *
-	 * These limitations come from the use of UTF-8 encoding of the strings, which requires them to be valid unicode.
-	 * JavaScript does not make this requirement for its strings so not all possible JavaScript strings are supported.
-	 * @privateRemarks
-	 * TODO:
-	 * We should be much more clear about what happens if you use problematic values.
-	 * We should validate and/or normalize them when inserting content.
-	 */
-	string,
-
-	/**
-	 * {@link LeafNodeSchema} for holding an {@link @fluidframework/core-interfaces#(IFluidHandle:interface)}.
-	 */
-	handle,
-
-	/**
-	 * {@link LeafNodeSchema} for JavaScript `null`.
-	 *
-	 * @remarks
-	 * There are good [reasons to avoid using null](https://www.npmjs.com/package/%40rushstack/eslint-plugin#rushstackno-new-null) in JavaScript, however sometimes it is desired.
-	 * This {@link LeafNodeSchema} node provides the option to include nulls in trees when desired.
-	 * Unless directly inter-operating with existing data using null, consider other approaches, like wrapping the value in an optional field, or using a more specifically named empty object node.
-	 */
-	null: nullSchema,
-
-	/**
-	 * The set of {@link LeafNodeSchema} which correspond to JavaScript primitive (non-object) types.
-	 */
-	primitives,
-
-	/**
-	 * All {@link LeafNodeSchema} defined in this library..
-	 */
-	all,
-
-	/**
-	 * {@link SchemaLibrary} of the {@link LeafNodeSchema}.
-	 *
-	 * @privateRemarks
-	 * This is included by default in schema produced with {@link SchemaBuilder}.
-	 */
-	library,
-};