@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/dist/feature-libraries/contextuallyTyped.d.ts

@@ -0,0 +1,212 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { FieldKey, Value, MapTree, ITreeCursorSynchronous, TreeValue } from "../core";
+import { FieldKind } from "./modular-schema";
+import { AllowedTypeSet, AllowedTypes, FlexTreeSchema, TreeFieldSchema, TreeNodeSchema } from "./typed-schema";
+import { AllowedTypesToFlexInsertableTree, InsertableFlexField, InsertableFlexNode } from "./schema-aware";
+import { TreeDataContext } from "./fieldGenerator";
+/**
+ * This library defines a tree data format that can infer its types from context.
+ * It can only be used when the schema is known.
+ * The format is optimized for ergonomics when the developer knows the schema,
+ * and needs to declare or navigate trees.
+ *
+ * The format defined here is very tolerant to optimize for flexibility of expressing trees:
+ * APIs exposing data in this format should likely further constrain what is allowed.
+ * For example guarantee which fields and nodes should be inlined, and that types will be required everywhere.
+ *
+ * This is from Editable tree one which has been deleted and should no longer be used!
+ */
+/**
+ * Check if NewFieldContent is made of {@link ITreeCursor}s.
+ *
+ * Useful when APIs want to take in tree data in multiple formats, including cursors.
+ */
+export declare function areCursors(data: NewFieldContent): data is ITreeCursorSynchronous | readonly ITreeCursorSynchronous[];
+/**
+ * A symbol for the name of the type of a tree in contexts where string keys are already in use for fields.
+ * See {@link TreeNodeSchemaIdentifier}.
+ * @internal
+ */
+export declare const typeNameSymbol: unique symbol;
+/**
+ * A symbol for the value of a tree node in contexts where string keys are already in use for fields.
+ * @internal
+ */
+export declare const valueSymbol: unique symbol;
+/**
+ * Checks if a value is a {@link TreeValue}.
+ */
+export declare function isTreeValue(nodeValue: unknown): nodeValue is TreeValue;
+export declare function getFieldKind(fieldSchema: TreeFieldSchema): FieldKind;
+/**
+ * @returns all allowed child types for `typeSet`.
+ */
+export declare function getAllowedTypes(schemaData: FlexTreeSchema, typeSet: AllowedTypeSet): ReadonlySet<TreeNodeSchema>;
+/**
+ * @returns all types, for which the data is schema-compatible.
+ */
+export declare function getPossibleTypes(context: FlexTreeSchema, typeSet: AllowedTypeSet, data: ContextuallyTypedNodeData): TreeNodeSchema[];
+/**
+ * A symbol used to define a {@link MarkedArrayLike} interface.
+ * @internal
+ */
+export declare const arrayLikeMarkerSymbol: unique symbol;
+/**
+ * Can be used to mark a type which works like an array, but is not compatible with `Array.isArray`.
+ * @internal
+ */
+export interface MarkedArrayLike<TGet, TSet extends TGet = TGet> extends ArrayLikeMut<TGet, TSet> {
+    readonly [arrayLikeMarkerSymbol]: true;
+    [Symbol.iterator](): IterableIterator<TGet>;
+}
+/**
+ * Can be used to mark a type which works like an array, but is not compatible with `Array.isArray`.
+ * @internal
+ */
+export interface ReadonlyMarkedArrayLike<T> extends ArrayLike<T> {
+    readonly [arrayLikeMarkerSymbol]: true;
+    [Symbol.iterator](): IterableIterator<T>;
+}
+/**
+ * `ArrayLike` numeric indexed access, but writable.
+ *
+ * @remarks
+ * Note that due to language limitations, this also allows reading as TSet.
+ * This is why `TSet extends TGet` is required.
+ *
+ * See https://github.com/microsoft/TypeScript/issues/43826.
+ * @internal
+ */
+export interface ArrayLikeMut<TGet, TSet extends TGet = TGet> extends ArrayLike<TGet> {
+    [n: number]: TSet;
+}
+/**
+ * Content of a tree which needs external schema information to interpret.
+ *
+ * This format is intended for concise authoring of tree literals when the schema is statically known.
+ *
+ * Once schema aware APIs are implemented, they can be used to provide schema specific subsets of this type.
+ * @internal
+ */
+export type ContextuallyTypedNodeData = ContextuallyTypedNodeDataObject | number | string | boolean | null | readonly ContextuallyTypedNodeData[] | MarkedArrayLike<ContextuallyTypedNodeData>;
+/**
+ * Content of a field which needs external schema information to interpret.
+ *
+ * This format is intended for concise authoring of tree literals when the schema is statically known.
+ *
+ * Once schema aware APIs are implemented, they can be used to provide schema specific subsets of this type.
+ * @internal
+ */
+export type ContextuallyTypedFieldData = ContextuallyTypedNodeData | undefined;
+/**
+ * Checks the type of a `ContextuallyTypedNodeData`.
+ */
+export declare function isArrayLike(data: ContextuallyTypedFieldData): data is readonly ContextuallyTypedNodeData[] | ReadonlyMarkedArrayLike<ContextuallyTypedNodeData>;
+/**
+ * Checks the type of a `ContextuallyTypedNodeData`.
+ * @internal
+ */
+export declare function isContextuallyTypedNodeDataObject(data: ContextuallyTypedNodeData | undefined): data is ContextuallyTypedNodeDataObject;
+/**
+ * Object case of {@link ContextuallyTypedNodeData}.
+ * @internal
+ */
+export interface ContextuallyTypedNodeDataObject {
+    /**
+     * Value stored on this node.
+     */
+    readonly [valueSymbol]?: Value;
+    /**
+     * The type of the node.
+     * If this node is well-formed, it must follow this schema.
+     */
+    readonly [typeNameSymbol]?: string;
+    /**
+     * Fields of this node, indexed by their field keys.
+     *
+     * Allow explicit undefined for compatibility with EditableTree, and type-safety on read.
+     */
+    [key: FieldKey]: ContextuallyTypedFieldData;
+    /**
+     * Fields of this node, indexed by their field keys as strings.
+     *
+     * Allow unbranded field keys as a convenience for literals.
+     */
+    [key: string]: ContextuallyTypedFieldData;
+}
+/**
+ * Construct a tree from ContextuallyTypedNodeData.
+ *
+ * TODO: this should probably be refactored into a `try` function which either returns a Cursor or a SchemaError with a path to the error.
+ * @returns a cursor in Nodes mode for a single node containing the provided data.
+ * @internal
+ */
+export declare function cursorFromContextualData(context: TreeDataContext, typeSet: AllowedTypeSet, data: ContextuallyTypedNodeData): ITreeCursorSynchronous;
+/**
+ * Strongly typed {@link cursorFromContextualData} for a TreeNodeSchema.
+ * @returns a cursor in Nodes mode for a single node containing the provided data.
+ * @internal
+ */
+export declare function cursorForTypedTreeData<T extends TreeNodeSchema>(context: TreeDataContext, schema: T, data: InsertableFlexNode<T>): ITreeCursorSynchronous;
+/**
+ * Strongly typed {@link cursorFromContextualData} for AllowedTypes.
+ * @returns a cursor in Nodes mode for a single node containing the provided data.
+ * @internal
+ */
+export declare function cursorForTypedData<T extends AllowedTypes>(context: TreeDataContext, schema: T, data: AllowedTypesToFlexInsertableTree<T>): ITreeCursorSynchronous;
+/**
+ * Construct a tree from ContextuallyTypedNodeData.
+ *
+ * TODO: this should probably be refactored into a `try` function which either returns a Cursor or a SchemaError with a path to the error.
+ * TODO: migrate APIs which take arrays of cursors to take cursors in fields mode.
+ */
+export declare function cursorsFromContextualData(context: TreeDataContext, field: TreeFieldSchema, data: ContextuallyTypedNodeData | undefined): ITreeCursorSynchronous[];
+/**
+ * Strongly typed {@link cursorsFromContextualData} for a TreeFieldSchema
+ * @internal
+ */
+export declare function cursorsForTypedFieldData<T extends TreeFieldSchema>(context: TreeDataContext, schema: T, data: InsertableFlexField<T>): ITreeCursorSynchronous[];
+/**
+ * Construct a MapTree from ContextuallyTypedNodeData.
+ *
+ * TODO: this should probably be refactored into a `try` function which either returns a MapTree or a SchemaError with a path to the error.
+ * TODO: test suite.
+ *
+ * @remarks
+ * This version is only exported as a more testable entry point than `cursorFromContextualData` which keeps the use of `MapTree` as an implementation detail.
+ * This should not be reexported from the parent module.
+ */
+export declare function applyTypesFromContext(context: TreeDataContext, typeSet: AllowedTypeSet, data: ContextuallyTypedNodeData): MapTree;
+/**
+ * Construct a MapTree from ContextuallyTypedNodeData.
+ *
+ * TODO: this should probably be refactored into a `try` function which either returns a MapTree or a SchemaError with a path to the error.
+ * TODO: test suite.
+ *
+ * @remarks
+ * This version is only exported as a more testable entry point than `cursorsFromContextualData` which keeps the use of `MapTree` as an implementation detail.
+ * This should not be reexported from the parent module.
+ */
+export declare function applyFieldTypesFromContext(context: TreeDataContext, field: TreeFieldSchema, data: ContextuallyTypedFieldData): MapTree[];
+/**
+ * Content to use for a field.
+ *
+ * When used, this content will be deeply copied into the tree, and must comply with the schema.
+ *
+ * The content must follow the {@link Multiplicity} of the {@link FieldKind}:
+ * - use a single cursor for an `optional` or `value` field;
+ * - use array of cursors for a `sequence` field;
+ *
+ * TODO: this should allow a field cursor instead of an array of cursors.
+ * TODO: Make this generic so a variant of this type that allows placeholders for detached sequences to consume.
+ * @internal
+ */
+export type NewFieldContent = ITreeCursorSynchronous | readonly ITreeCursorSynchronous[] | ContextuallyTypedFieldData;
+/**
+ * Convert NewFieldContent into ITreeCursor array.
+ */
+export declare function normalizeNewFieldContent(context: TreeDataContext, schema: TreeFieldSchema, content: NewFieldContent): readonly ITreeCursorSynchronous[];
+//# sourceMappingURL=contextuallyTyped.d.ts.map

package/dist/feature-libraries/contextuallyTyped.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextuallyTyped.d.ts","sourceRoot":"","sources":["../../src/feature-libraries/contextuallyTyped.ts"],"names":[],"mappings":"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"}

package/dist/feature-libraries/contextuallyTyped.js

@@ -0,0 +1,342 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeNewFieldContent = exports.applyFieldTypesFromContext = exports.applyTypesFromContext = exports.cursorsForTypedFieldData = exports.cursorsFromContextualData = exports.cursorForTypedData = exports.cursorForTypedTreeData = exports.cursorFromContextualData = exports.isContextuallyTypedNodeDataObject = exports.isArrayLike = exports.arrayLikeMarkerSymbol = exports.getPossibleTypes = exports.getAllowedTypes = exports.getFieldKind = exports.isTreeValue = exports.valueSymbol = exports.typeNameSymbol = exports.areCursors = void 0;
+const core_utils_1 = require("@fluidframework/core-utils");
+const util_1 = require("../util");
+const core_1 = require("../core");
+// TODO:
+// This module currently is assuming use of default-field-kinds.
+// The field kinds should instead come from a view schema registry thats provided somewhere.
+const default_schema_1 = require("./default-schema");
+const typed_schema_1 = require("./typed-schema");
+const mapTreeCursor_1 = require("./mapTreeCursor");
+const valueUtilities_1 = require("./valueUtilities");
+const multiplicity_1 = require("./multiplicity");
+/**
+ * This library defines a tree data format that can infer its types from context.
+ * It can only be used when the schema is known.
+ * The format is optimized for ergonomics when the developer knows the schema,
+ * and needs to declare or navigate trees.
+ *
+ * The format defined here is very tolerant to optimize for flexibility of expressing trees:
+ * APIs exposing data in this format should likely further constrain what is allowed.
+ * For example guarantee which fields and nodes should be inlined, and that types will be required everywhere.
+ *
+ * This is from Editable tree one which has been deleted and should no longer be used!
+ */
+/**
+ * Check if NewFieldContent is made of {@link ITreeCursor}s.
+ *
+ * Useful when APIs want to take in tree data in multiple formats, including cursors.
+ */
+function areCursors(data) {
+    if ((0, core_1.isCursor)(data)) {
+        return true;
+    }
+    if (Array.isArray(data) && data.length >= 0 && (0, core_1.isCursor)(data[0])) {
+        return true;
+    }
+    return false;
+}
+exports.areCursors = areCursors;
+/**
+ * String which identifies this code.
+ * Targeted at developers: can be used for symbol strings, or other developer targeted strings,
+ * like error messages.
+ */
+const scope = "contextuallyTyped";
+/**
+ * A symbol for the name of the type of a tree in contexts where string keys are already in use for fields.
+ * See {@link TreeNodeSchemaIdentifier}.
+ * @internal
+ */
+exports.typeNameSymbol = Symbol(`${scope}:typeName`);
+/**
+ * A symbol for the value of a tree node in contexts where string keys are already in use for fields.
+ * @internal
+ */
+exports.valueSymbol = Symbol(`${scope}:value`);
+/**
+ * Checks if a value is a {@link TreeValue}.
+ */
+function isTreeValue(nodeValue) {
+    switch (typeof nodeValue) {
+        case "string":
+        case "number":
+        case "boolean":
+            return true;
+        default:
+            return nodeValue === null || (0, valueUtilities_1.isFluidHandle)(nodeValue);
+    }
+}
+exports.isTreeValue = isTreeValue;
+function getFieldKind(fieldSchema) {
+    // TODO:
+    // This module currently is assuming use of defaultFieldKinds.
+    // The field kinds should instead come from a view schema registry thats provided somewhere.
+    return default_schema_1.fieldKinds.get(fieldSchema.kind.identifier) ?? (0, util_1.fail)("missing field kind");
+}
+exports.getFieldKind = getFieldKind;
+/**
+ * @returns all allowed child types for `typeSet`.
+ */
+function getAllowedTypes(schemaData, typeSet) {
+    // TODO: Performance: avoid the `Any` case being frequent, possibly with caching in the caller of `getPossibleChildTypes`.
+    return typeSet === typed_schema_1.Any ? new Set(schemaData.nodeSchema.values()) : typeSet;
+}
+exports.getAllowedTypes = getAllowedTypes;
+/**
+ * @returns all types, for which the data is schema-compatible.
+ */
+function getPossibleTypes(context, typeSet, data) {
+    // All types allowed by schema
+    const allowedTypes = getAllowedTypes(context, typeSet);
+    const possibleTypes = [];
+    for (const allowed of allowedTypes) {
+        if (shallowCompatibilityTest(allowed, data)) {
+            possibleTypes.push(allowed);
+        }
+    }
+    return possibleTypes;
+}
+exports.getPossibleTypes = getPossibleTypes;
+/**
+ * A symbol used to define a {@link MarkedArrayLike} interface.
+ * @internal
+ */
+exports.arrayLikeMarkerSymbol = Symbol("editable-tree:arrayLikeMarker");
+/**
+ * Checks the type of a `ContextuallyTypedNodeData`.
+ */
+function isArrayLike(data) {
+    if (typeof data !== "object" || data === null) {
+        return false;
+    }
+    return (data[exports.arrayLikeMarkerSymbol] ===
+        true || Array.isArray(data));
+}
+exports.isArrayLike = isArrayLike;
+/**
+ * Checks the type of a `ContextuallyTypedNodeData`.
+ * @internal
+ */
+function isContextuallyTypedNodeDataObject(data) {
+    return !(isTreeValue(data) || isArrayLike(data));
+}
+exports.isContextuallyTypedNodeDataObject = isContextuallyTypedNodeDataObject;
+/**
+ * Checks if data might be schema-compatible.
+ *
+ * @returns false if `data` is incompatible with `type` based on a cheap/shallow check.
+ *
+ * Note that this may return true for cases where data is incompatible, but it must not return false in cases where the data is compatible.
+ */
+function shallowCompatibilityTest(schema, data) {
+    (0, core_utils_1.assert)(!areCursors(data), 0x6b1 /* cursors cannot be used as contextually typed data. */);
+    (0, core_utils_1.assert)(data !== undefined, 0x6b2 /* undefined cannot be used as contextually typed data. Use ContextuallyTypedFieldData. */);
+    if (schema instanceof typed_schema_1.LeafNodeSchema) {
+        // Reject objects with no value from being leaf nodes.
+        // Note that if allowing IFluidHandles without wrapping them in a leaf node object,
+        // this (or the above isPrimitiveValue) would have to change.
+        if (isTreeValue(data)) {
+            return (0, valueUtilities_1.allowsValue)(schema.leafValue, data);
+        }
+        if (data[exports.valueSymbol] === undefined) {
+            return false;
+        }
+    }
+    if (isTreeValue(data)) {
+        return false;
+    }
+    if (isArrayLike(data)) {
+        if (schema instanceof typed_schema_1.FieldNodeSchema) {
+            const field = schema.getFieldSchema();
+            return field.kind.multiplicity === multiplicity_1.Multiplicity.Sequence;
+        }
+        else {
+            return false;
+        }
+    }
+    if (data[exports.typeNameSymbol] !== undefined) {
+        return data[exports.typeNameSymbol] === schema.name;
+    }
+    // For now, consider all not explicitly typed objects shallow compatible.
+    // This will require explicit differentiation in polymorphic cases rather than automatic structural differentiation.
+    return true;
+}
+/**
+ * Construct a tree from ContextuallyTypedNodeData.
+ *
+ * TODO: this should probably be refactored into a `try` function which either returns a Cursor or a SchemaError with a path to the error.
+ * @returns a cursor in Nodes mode for a single node containing the provided data.
+ * @internal
+ */
+function cursorFromContextualData(context, typeSet, data) {
+    const mapTree = applyTypesFromContext(context, typeSet, data);
+    return (0, mapTreeCursor_1.cursorForMapTreeNode)(mapTree);
+}
+exports.cursorFromContextualData = cursorFromContextualData;
+/**
+ * Strongly typed {@link cursorFromContextualData} for a TreeNodeSchema.
+ * @returns a cursor in Nodes mode for a single node containing the provided data.
+ * @internal
+ */
+function cursorForTypedTreeData(context, schema, data) {
+    return cursorFromContextualData(context, new Set([schema]), data);
+}
+exports.cursorForTypedTreeData = cursorForTypedTreeData;
+/**
+ * Strongly typed {@link cursorFromContextualData} for AllowedTypes.
+ * @returns a cursor in Nodes mode for a single node containing the provided data.
+ * @internal
+ */
+function cursorForTypedData(context, schema, data) {
+    return cursorFromContextualData(context, (0, typed_schema_1.allowedTypesSchemaSet)(schema), data);
+}
+exports.cursorForTypedData = cursorForTypedData;
+/**
+ * Construct a tree from ContextuallyTypedNodeData.
+ *
+ * TODO: this should probably be refactored into a `try` function which either returns a Cursor or a SchemaError with a path to the error.
+ * TODO: migrate APIs which take arrays of cursors to take cursors in fields mode.
+ */
+function cursorsFromContextualData(context, field, data) {
+    const mapTrees = applyFieldTypesFromContext(context, field, data);
+    return mapTrees.map(mapTreeCursor_1.cursorForMapTreeNode);
+}
+exports.cursorsFromContextualData = cursorsFromContextualData;
+/**
+ * Strongly typed {@link cursorsFromContextualData} for a TreeFieldSchema
+ * @internal
+ */
+function cursorsForTypedFieldData(context, schema, data) {
+    return cursorsFromContextualData(context, schema, data);
+}
+exports.cursorsForTypedFieldData = cursorsForTypedFieldData;
+/**
+ * Construct a MapTree from ContextuallyTypedNodeData.
+ *
+ * TODO: this should probably be refactored into a `try` function which either returns a MapTree or a SchemaError with a path to the error.
+ * TODO: test suite.
+ *
+ * @remarks
+ * This version is only exported as a more testable entry point than `cursorFromContextualData` which keeps the use of `MapTree` as an implementation detail.
+ * This should not be reexported from the parent module.
+ */
+function applyTypesFromContext(context, typeSet, data) {
+    const possibleTypes = getPossibleTypes(context.schema, typeSet, data);
+    (0, core_utils_1.assert)(possibleTypes.length !== 0, 0x4d4 /* data incompatible with all types allowed by the schema */);
+    (0, core_utils_1.assert)(possibleTypes.length === 1, 0x4d5 /* data compatible with more than one type allowed by the schema */);
+    const schema = possibleTypes[0];
+    if (schema instanceof typed_schema_1.LeafNodeSchema) {
+        const value = isTreeValue(data)
+            ? data
+            : data[exports.valueSymbol];
+        (0, core_utils_1.assert)((0, valueUtilities_1.allowsValue)(schema.leafValue, value), 0x4d3 /* unsupported schema for provided primitive */);
+        return { value, type: schema.name, fields: new Map() };
+    }
+    (0, core_utils_1.assert)(!isTreeValue(data), "leaf value for non leaf");
+    if (schema instanceof typed_schema_1.FieldNodeSchema) {
+        if (isArrayLike(data)) {
+            const children = applyFieldTypesFromContext(context, schema.getFieldSchema(), data);
+            return {
+                value: undefined,
+                type: schema.name,
+                fields: new Map(children.length > 0 ? [[core_1.EmptyKey, children]] : []),
+            };
+        }
+    }
+    (0, core_utils_1.assert)(!isArrayLike(data), "array for non field node");
+    if (schema instanceof typed_schema_1.MapNodeSchema ||
+        schema instanceof typed_schema_1.ObjectNodeSchema ||
+        schema instanceof typed_schema_1.FieldNodeSchema) {
+        const fields = new Map();
+        for (const key of fieldKeysFromData(data)) {
+            (0, core_utils_1.assert)(!fields.has(key), 0x6b3 /* Keys should not be duplicated */);
+            const childSchema = schema.getFieldSchema(key);
+            const children = applyFieldTypesFromContext(context, childSchema, data[key]);
+            if (children.length > 0) {
+                fields.set(key, children);
+            }
+        }
+        if (schema instanceof typed_schema_1.ObjectNodeSchema) {
+            for (const key of schema.objectNodeFields.keys()) {
+                if (data[key] === undefined) {
+                    setFieldForKey(key, context, schema, fields);
+                }
+            }
+        }
+        const value = data[exports.valueSymbol];
+        (0, core_utils_1.assert)(value === undefined, 0x4d7 /* provided value not permitted by the schema */);
+        return { value, type: schema.name, fields };
+    }
+    else {
+        (0, util_1.fail)("unexpected node kind");
+    }
+}
+exports.applyTypesFromContext = applyTypesFromContext;
+function setFieldForKey(key, context, schema, fields) {
+    const requiredFieldSchema = schema.getFieldSchema(key);
+    const multiplicity = getFieldKind(requiredFieldSchema).multiplicity;
+    if (multiplicity === multiplicity_1.Multiplicity.Single && context.fieldSource !== undefined) {
+        const fieldGenerator = context.fieldSource(key, requiredFieldSchema);
+        if (fieldGenerator !== undefined) {
+            const children = fieldGenerator();
+            fields.set(key, children);
+        }
+    }
+}
+function fieldKeysFromData(data) {
+    const keys = Reflect.ownKeys(data).filter((key) => typeof key === "string");
+    return keys;
+}
+/**
+ * Construct a MapTree from ContextuallyTypedNodeData.
+ *
+ * TODO: this should probably be refactored into a `try` function which either returns a MapTree or a SchemaError with a path to the error.
+ * TODO: test suite.
+ *
+ * @remarks
+ * This version is only exported as a more testable entry point than `cursorsFromContextualData` which keeps the use of `MapTree` as an implementation detail.
+ * This should not be reexported from the parent module.
+ */
+function applyFieldTypesFromContext(context, field, data) {
+    const multiplicity = getFieldKind(field).multiplicity;
+    if (data === undefined) {
+        (0, core_utils_1.assert)(multiplicity === multiplicity_1.Multiplicity.Forbidden || multiplicity === multiplicity_1.Multiplicity.Optional, 0x4d8 /* `undefined` provided for a field that does not support `undefined` */);
+        return [];
+    }
+    if (multiplicity === multiplicity_1.Multiplicity.Sequence) {
+        (0, core_utils_1.assert)(isArrayLike(data), 0x4d9 /* expected array for a sequence field */);
+        const children = Array.from(data, (child) => applyTypesFromContext(context, field.allowedTypeSet, child));
+        return children;
+    }
+    (0, core_utils_1.assert)(multiplicity === multiplicity_1.Multiplicity.Single || multiplicity === multiplicity_1.Multiplicity.Optional, 0x4da /* single value provided for an unsupported field */);
+    return [applyTypesFromContext(context, field.allowedTypeSet, data)];
+}
+exports.applyFieldTypesFromContext = applyFieldTypesFromContext;
+/**
+ * Convert NewFieldContent into ITreeCursor array.
+ */
+function normalizeNewFieldContent(context, schema, content) {
+    if (areCursors(content)) {
+        if (getFieldKind(schema).multiplicity === multiplicity_1.Multiplicity.Sequence) {
+            (0, core_utils_1.assert)((0, util_1.isReadonlyArray)(content), 0x6b7 /* sequence fields require array content */);
+            return content;
+        }
+        else {
+            if ((0, util_1.isReadonlyArray)(content)) {
+                (0, core_utils_1.assert)(content.length === 1, 0x6b8 /* non-sequence fields can not be provided content that is multiple cursors */);
+                return content;
+            }
+            return [content];
+        }
+    }
+    return cursorsFromContextualData(context, schema, content);
+}
+exports.normalizeNewFieldContent = normalizeNewFieldContent;
+//# sourceMappingURL=contextuallyTyped.js.map

package/dist/feature-libraries/contextuallyTyped.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextuallyTyped.js","sourceRoot":"","sources":["../../src/feature-libraries/contextuallyTyped.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 { assert } from \"@fluidframework/core-utils\";\nimport { fail, isReadonlyArray } from \"../util\";\nimport {\n\tEmptyKey,\n\tFieldKey,\n\tValue,\n\tMapTree,\n\tITreeCursorSynchronous,\n\tisCursor,\n\tTreeValue,\n} from \"../core\";\n// TODO:\n// This module currently is assuming use of default-field-kinds.\n// The field kinds should instead come from a view schema registry thats provided somewhere.\nimport { fieldKinds } from \"./default-schema\";\nimport { FieldKind } from \"./modular-schema\";\nimport {\n\tAllowedTypeSet,\n\tAllowedTypes,\n\tAny,\n\tFieldNodeSchema,\n\tFlexTreeSchema,\n\tLeafNodeSchema,\n\tMapNodeSchema,\n\tObjectNodeSchema,\n\tTreeFieldSchema,\n\tTreeNodeSchema,\n\tallowedTypesSchemaSet,\n} from \"./typed-schema\";\nimport { cursorForMapTreeNode } from \"./mapTreeCursor\";\nimport {\n\tAllowedTypesToFlexInsertableTree,\n\tInsertableFlexField,\n\tInsertableFlexNode,\n} from \"./schema-aware\";\nimport { isFluidHandle, allowsValue } from \"./valueUtilities\";\nimport { TreeDataContext } from \"./fieldGenerator\";\nimport { Multiplicity } from \"./multiplicity\";\n\n/**\n * This library defines a tree data format that can infer its types from context.\n * It can only be used when the schema is known.\n * The format is optimized for ergonomics when the developer knows the schema,\n * and needs to declare or navigate trees.\n *\n * The format defined here is very tolerant to optimize for flexibility of expressing trees:\n * APIs exposing data in this format should likely further constrain what is allowed.\n * For example guarantee which fields and nodes should be inlined, and that types will be required everywhere.\n *\n * This is from Editable tree one which has been deleted and should no longer be used!\n */\n\n/**\n * Check if NewFieldContent is made of {@link ITreeCursor}s.\n *\n * Useful when APIs want to take in tree data in multiple formats, including cursors.\n */\nexport function areCursors(\n\tdata: NewFieldContent,\n): data is ITreeCursorSynchronous | readonly ITreeCursorSynchronous[] {\n\tif (isCursor(data)) {\n\t\treturn true;\n\t}\n\n\tif (Array.isArray(data) && data.length >= 0 && isCursor(data[0])) {\n\t\treturn true;\n\t}\n\n\treturn false;\n}\n\n/**\n * String which identifies this code.\n * Targeted at developers: can be used for symbol strings, or other developer targeted strings,\n * like error messages.\n */\nconst scope = \"contextuallyTyped\";\n\n/**\n * A symbol for the name of the type of a tree in contexts where string keys are already in use for fields.\n * See {@link TreeNodeSchemaIdentifier}.\n * @internal\n */\nexport const typeNameSymbol: unique symbol = Symbol(`${scope}:typeName`);\n\n/**\n * A symbol for the value of a tree node in contexts where string keys are already in use for fields.\n * @internal\n */\nexport const valueSymbol: unique symbol = Symbol(`${scope}:value`);\n\n/**\n * Checks if a value is a {@link TreeValue}.\n */\nexport function isTreeValue(nodeValue: unknown): nodeValue is TreeValue {\n\tswitch (typeof nodeValue) {\n\t\tcase \"string\":\n\t\tcase \"number\":\n\t\tcase \"boolean\":\n\t\t\treturn true;\n\t\tdefault:\n\t\t\treturn nodeValue === null || isFluidHandle(nodeValue);\n\t}\n}\n\nexport function getFieldKind(fieldSchema: TreeFieldSchema): FieldKind {\n\t// TODO:\n\t// This module currently is assuming use of defaultFieldKinds.\n\t// The field kinds should instead come from a view schema registry thats provided somewhere.\n\treturn fieldKinds.get(fieldSchema.kind.identifier) ?? fail(\"missing field kind\");\n}\n\n/**\n * @returns all allowed child types for `typeSet`.\n */\nexport function getAllowedTypes(\n\tschemaData: FlexTreeSchema,\n\ttypeSet: AllowedTypeSet,\n): ReadonlySet<TreeNodeSchema> {\n\t// TODO: Performance: avoid the `Any` case being frequent, possibly with caching in the caller of `getPossibleChildTypes`.\n\treturn typeSet === Any ? new Set(schemaData.nodeSchema.values()) : typeSet;\n}\n\n/**\n * @returns all types, for which the data is schema-compatible.\n */\nexport function getPossibleTypes(\n\tcontext: FlexTreeSchema,\n\ttypeSet: AllowedTypeSet,\n\tdata: ContextuallyTypedNodeData,\n) {\n\t// All types allowed by schema\n\tconst allowedTypes = getAllowedTypes(context, typeSet);\n\n\tconst possibleTypes: TreeNodeSchema[] = [];\n\tfor (const allowed of allowedTypes) {\n\t\tif (shallowCompatibilityTest(allowed, data)) {\n\t\t\tpossibleTypes.push(allowed);\n\t\t}\n\t}\n\treturn possibleTypes;\n}\n\n/**\n * A symbol used to define a {@link MarkedArrayLike} interface.\n * @internal\n */\nexport const arrayLikeMarkerSymbol: unique symbol = Symbol(\"editable-tree:arrayLikeMarker\");\n\n/**\n * Can be used to mark a type which works like an array, but is not compatible with `Array.isArray`.\n * @internal\n */\nexport interface MarkedArrayLike<TGet, TSet extends TGet = TGet> extends ArrayLikeMut<TGet, TSet> {\n\treadonly [arrayLikeMarkerSymbol]: true;\n\t[Symbol.iterator](): IterableIterator<TGet>;\n}\n\n/**\n * Can be used to mark a type which works like an array, but is not compatible with `Array.isArray`.\n * @internal\n */\nexport interface ReadonlyMarkedArrayLike<T> extends ArrayLike<T> {\n\treadonly [arrayLikeMarkerSymbol]: true;\n\t[Symbol.iterator](): IterableIterator<T>;\n}\n\n/**\n * `ArrayLike` numeric indexed access, but writable.\n *\n * @remarks\n * Note that due to language limitations, this also allows reading as TSet.\n * This is why `TSet extends TGet` is required.\n *\n * See https://github.com/microsoft/TypeScript/issues/43826.\n * @internal\n */\nexport interface ArrayLikeMut<TGet, TSet extends TGet = TGet> extends ArrayLike<TGet> {\n\t[n: number]: TSet;\n}\n\n/**\n * Content of a tree which needs external schema information to interpret.\n *\n * This format is intended for concise authoring of tree literals when the schema is statically known.\n *\n * Once schema aware APIs are implemented, they can be used to provide schema specific subsets of this type.\n * @internal\n */\nexport type ContextuallyTypedNodeData =\n\t| ContextuallyTypedNodeDataObject\n\t| number\n\t| string\n\t| boolean\n\t// eslint-disable-next-line @rushstack/no-new-null\n\t| null\n\t| readonly ContextuallyTypedNodeData[]\n\t| MarkedArrayLike<ContextuallyTypedNodeData>;\n\n/**\n * Content of a field which needs external schema information to interpret.\n *\n * This format is intended for concise authoring of tree literals when the schema is statically known.\n *\n * Once schema aware APIs are implemented, they can be used to provide schema specific subsets of this type.\n * @internal\n */\nexport type ContextuallyTypedFieldData = ContextuallyTypedNodeData | undefined;\n\n/**\n * Checks the type of a `ContextuallyTypedNodeData`.\n */\nexport function isArrayLike(\n\tdata: ContextuallyTypedFieldData,\n): data is\n\t| readonly ContextuallyTypedNodeData[]\n\t| ReadonlyMarkedArrayLike<ContextuallyTypedNodeData> {\n\tif (typeof data !== \"object\" || data === null) {\n\t\treturn false;\n\t}\n\treturn (\n\t\t(data as Partial<MarkedArrayLike<ContextuallyTypedNodeData>>)[arrayLikeMarkerSymbol] ===\n\t\t\ttrue || Array.isArray(data)\n\t);\n}\n\n/**\n * Checks the type of a `ContextuallyTypedNodeData`.\n * @internal\n */\nexport function isContextuallyTypedNodeDataObject(\n\tdata: ContextuallyTypedNodeData | undefined,\n): data is ContextuallyTypedNodeDataObject {\n\treturn !(isTreeValue(data) || isArrayLike(data));\n}\n\n/**\n * Object case of {@link ContextuallyTypedNodeData}.\n * @internal\n */\nexport interface ContextuallyTypedNodeDataObject {\n\t/**\n\t * Value stored on this node.\n\t */\n\treadonly [valueSymbol]?: Value;\n\n\t/**\n\t * The type of the node.\n\t * If this node is well-formed, it must follow this schema.\n\t */\n\treadonly [typeNameSymbol]?: string;\n\n\t/**\n\t * Fields of this node, indexed by their field keys.\n\t *\n\t * Allow explicit undefined for compatibility with EditableTree, and type-safety on read.\n\t */\n\t// TODO: make sure explicit undefined is actually handled correctly.\n\t[key: FieldKey]: ContextuallyTypedFieldData;\n\n\t/**\n\t * Fields of this node, indexed by their field keys as strings.\n\t *\n\t * Allow unbranded field keys as a convenience for literals.\n\t */\n\t[key: string]: ContextuallyTypedFieldData;\n}\n\n/**\n * Checks if data might be schema-compatible.\n *\n * @returns false if `data` is incompatible with `type` based on a cheap/shallow check.\n *\n * Note that this may return true for cases where data is incompatible, but it must not return false in cases where the data is compatible.\n */\nfunction shallowCompatibilityTest(\n\tschema: TreeNodeSchema,\n\tdata: ContextuallyTypedNodeData,\n): boolean {\n\tassert(!areCursors(data), 0x6b1 /* cursors cannot be used as contextually typed data. */);\n\tassert(\n\t\tdata !== undefined,\n\t\t0x6b2 /* undefined cannot be used as contextually typed data. Use ContextuallyTypedFieldData. */,\n\t);\n\n\tif (schema instanceof LeafNodeSchema) {\n\t\t// Reject objects with no value from being leaf nodes.\n\t\t// Note that if allowing IFluidHandles without wrapping them in a leaf node object,\n\t\t// this (or the above isPrimitiveValue) would have to change.\n\n\t\tif (isTreeValue(data)) {\n\t\t\treturn allowsValue(schema.leafValue, data);\n\t\t}\n\t\tif ((data as ContextuallyTypedNodeDataObject)[valueSymbol] === undefined) {\n\t\t\treturn false;\n\t\t}\n\t}\n\tif (isTreeValue(data)) {\n\t\treturn false;\n\t}\n\tif (isArrayLike(data)) {\n\t\tif (schema instanceof FieldNodeSchema) {\n\t\t\tconst field = schema.getFieldSchema();\n\t\t\treturn field.kind.multiplicity === Multiplicity.Sequence;\n\t\t} else {\n\t\t\treturn false;\n\t\t}\n\t}\n\tif (data[typeNameSymbol] !== undefined) {\n\t\treturn data[typeNameSymbol] === schema.name;\n\t}\n\t// For now, consider all not explicitly typed objects shallow compatible.\n\t// This will require explicit differentiation in polymorphic cases rather than automatic structural differentiation.\n\n\treturn true;\n}\n\n/**\n * Construct a tree from ContextuallyTypedNodeData.\n *\n * TODO: this should probably be refactored into a `try` function which either returns a Cursor or a SchemaError with a path to the error.\n * @returns a cursor in Nodes mode for a single node containing the provided data.\n * @internal\n */\nexport function cursorFromContextualData(\n\tcontext: TreeDataContext,\n\ttypeSet: AllowedTypeSet,\n\tdata: ContextuallyTypedNodeData,\n): ITreeCursorSynchronous {\n\tconst mapTree = applyTypesFromContext(context, typeSet, data);\n\treturn cursorForMapTreeNode(mapTree);\n}\n\n/**\n * Strongly typed {@link cursorFromContextualData} for a TreeNodeSchema.\n * @returns a cursor in Nodes mode for a single node containing the provided data.\n * @internal\n */\nexport function cursorForTypedTreeData<T extends TreeNodeSchema>(\n\tcontext: TreeDataContext,\n\tschema: T,\n\tdata: InsertableFlexNode<T>,\n): ITreeCursorSynchronous {\n\treturn cursorFromContextualData(context, new Set([schema]), data as ContextuallyTypedNodeData);\n}\n\n/**\n * Strongly typed {@link cursorFromContextualData} for AllowedTypes.\n * @returns a cursor in Nodes mode for a single node containing the provided data.\n * @internal\n */\nexport function cursorForTypedData<T extends AllowedTypes>(\n\tcontext: TreeDataContext,\n\tschema: T,\n\tdata: AllowedTypesToFlexInsertableTree<T>,\n): ITreeCursorSynchronous {\n\treturn cursorFromContextualData(\n\t\tcontext,\n\t\tallowedTypesSchemaSet(schema),\n\t\tdata as unknown as ContextuallyTypedNodeData,\n\t);\n}\n\n/**\n * Construct a tree from ContextuallyTypedNodeData.\n *\n * TODO: this should probably be refactored into a `try` function which either returns a Cursor or a SchemaError with a path to the error.\n * TODO: migrate APIs which take arrays of cursors to take cursors in fields mode.\n */\nexport function cursorsFromContextualData(\n\tcontext: TreeDataContext,\n\tfield: TreeFieldSchema,\n\tdata: ContextuallyTypedNodeData | undefined,\n): ITreeCursorSynchronous[] {\n\tconst mapTrees = applyFieldTypesFromContext(context, field, data);\n\treturn mapTrees.map(cursorForMapTreeNode);\n}\n\n/**\n * Strongly typed {@link cursorsFromContextualData} for a TreeFieldSchema\n * @internal\n */\nexport function cursorsForTypedFieldData<T extends TreeFieldSchema>(\n\tcontext: TreeDataContext,\n\tschema: T,\n\tdata: InsertableFlexField<T>,\n): ITreeCursorSynchronous[] {\n\treturn cursorsFromContextualData(context, schema, data as ContextuallyTypedNodeData);\n}\n\n/**\n * Construct a MapTree from ContextuallyTypedNodeData.\n *\n * TODO: this should probably be refactored into a `try` function which either returns a MapTree or a SchemaError with a path to the error.\n * TODO: test suite.\n *\n * @remarks\n * This version is only exported as a more testable entry point than `cursorFromContextualData` which keeps the use of `MapTree` as an implementation detail.\n * This should not be reexported from the parent module.\n */\nexport function applyTypesFromContext(\n\tcontext: TreeDataContext,\n\ttypeSet: AllowedTypeSet,\n\tdata: ContextuallyTypedNodeData,\n): MapTree {\n\tconst possibleTypes: TreeNodeSchema[] = getPossibleTypes(context.schema, typeSet, data);\n\n\tassert(\n\t\tpossibleTypes.length !== 0,\n\t\t0x4d4 /* data incompatible with all types allowed by the schema */,\n\t);\n\tassert(\n\t\tpossibleTypes.length === 1,\n\t\t0x4d5 /* data compatible with more than one type allowed by the schema */,\n\t);\n\n\tconst schema = possibleTypes[0];\n\n\tif (schema instanceof LeafNodeSchema) {\n\t\tconst value = isTreeValue(data)\n\t\t\t? data\n\t\t\t: (data as ContextuallyTypedNodeDataObject)[valueSymbol];\n\n\t\tassert(\n\t\t\tallowsValue(schema.leafValue, value),\n\t\t\t0x4d3 /* unsupported schema for provided primitive */,\n\t\t);\n\t\treturn { value, type: schema.name, fields: new Map() };\n\t}\n\tassert(!isTreeValue(data), \"leaf value for non leaf\");\n\tif (schema instanceof FieldNodeSchema) {\n\t\tif (isArrayLike(data)) {\n\t\t\tconst children = applyFieldTypesFromContext(context, schema.getFieldSchema(), data);\n\t\t\treturn {\n\t\t\t\tvalue: undefined,\n\t\t\t\ttype: schema.name,\n\t\t\t\tfields: new Map(children.length > 0 ? [[EmptyKey, children]] : []),\n\t\t\t};\n\t\t}\n\t}\n\tassert(!isArrayLike(data), \"array for non field node\");\n\tif (\n\t\tschema instanceof MapNodeSchema ||\n\t\tschema instanceof ObjectNodeSchema ||\n\t\tschema instanceof FieldNodeSchema\n\t) {\n\t\tconst fields: Map<FieldKey, MapTree[]> = new Map();\n\t\tfor (const key of fieldKeysFromData(data)) {\n\t\t\tassert(!fields.has(key), 0x6b3 /* Keys should not be duplicated */);\n\t\t\tconst childSchema = schema.getFieldSchema(key);\n\t\t\tconst children = applyFieldTypesFromContext(context, childSchema, data[key]);\n\n\t\t\tif (children.length > 0) {\n\t\t\t\tfields.set(key, children);\n\t\t\t}\n\t\t}\n\n\t\tif (schema instanceof ObjectNodeSchema) {\n\t\t\tfor (const key of schema.objectNodeFields.keys()) {\n\t\t\t\tif (data[key] === undefined) {\n\t\t\t\t\tsetFieldForKey(key, context, schema, fields);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tconst value = data[valueSymbol];\n\t\tassert(value === undefined, 0x4d7 /* provided value not permitted by the schema */);\n\t\treturn { value, type: schema.name, fields };\n\t} else {\n\t\tfail(\"unexpected node kind\");\n\t}\n}\n\nfunction setFieldForKey(\n\tkey: FieldKey,\n\tcontext: TreeDataContext,\n\tschema: TreeNodeSchema,\n\tfields: Map<FieldKey, MapTree[]>,\n): void {\n\tconst requiredFieldSchema = schema.getFieldSchema(key);\n\tconst multiplicity = getFieldKind(requiredFieldSchema).multiplicity;\n\tif (multiplicity === Multiplicity.Single && context.fieldSource !== undefined) {\n\t\tconst fieldGenerator = context.fieldSource(key, requiredFieldSchema);\n\t\tif (fieldGenerator !== undefined) {\n\t\t\tconst children = fieldGenerator();\n\t\t\tfields.set(key, children);\n\t\t}\n\t}\n}\n\nfunction fieldKeysFromData(data: ContextuallyTypedNodeDataObject): FieldKey[] {\n\tconst keys: (string | symbol)[] = Reflect.ownKeys(data).filter(\n\t\t(key) => typeof key === \"string\",\n\t);\n\treturn keys as FieldKey[];\n}\n\n/**\n * Construct a MapTree from ContextuallyTypedNodeData.\n *\n * TODO: this should probably be refactored into a `try` function which either returns a MapTree or a SchemaError with a path to the error.\n * TODO: test suite.\n *\n * @remarks\n * This version is only exported as a more testable entry point than `cursorsFromContextualData` which keeps the use of `MapTree` as an implementation detail.\n * This should not be reexported from the parent module.\n */\nexport function applyFieldTypesFromContext(\n\tcontext: TreeDataContext,\n\tfield: TreeFieldSchema,\n\tdata: ContextuallyTypedFieldData,\n): MapTree[] {\n\tconst multiplicity = getFieldKind(field).multiplicity;\n\tif (data === undefined) {\n\t\tassert(\n\t\t\tmultiplicity === Multiplicity.Forbidden || multiplicity === Multiplicity.Optional,\n\t\t\t0x4d8 /* `undefined` provided for a field that does not support `undefined` */,\n\t\t);\n\t\treturn [];\n\t}\n\tif (multiplicity === Multiplicity.Sequence) {\n\t\tassert(isArrayLike(data), 0x4d9 /* expected array for a sequence field */);\n\t\tconst children = Array.from(data, (child) =>\n\t\t\tapplyTypesFromContext(context, field.allowedTypeSet, child),\n\t\t);\n\t\treturn children;\n\t}\n\tassert(\n\t\tmultiplicity === Multiplicity.Single || multiplicity === Multiplicity.Optional,\n\t\t0x4da /* single value provided for an unsupported field */,\n\t);\n\treturn [applyTypesFromContext(context, field.allowedTypeSet, data)];\n}\n\n/**\n * Content to use for a field.\n *\n * When used, this content will be deeply copied into the tree, and must comply with the schema.\n *\n * The content must follow the {@link Multiplicity} of the {@link FieldKind}:\n * - use a single cursor for an `optional` or `value` field;\n * - use array of cursors for a `sequence` field;\n *\n * TODO: this should allow a field cursor instead of an array of cursors.\n * TODO: Make this generic so a variant of this type that allows placeholders for detached sequences to consume.\n * @internal\n */\nexport type NewFieldContent =\n\t| ITreeCursorSynchronous\n\t| readonly ITreeCursorSynchronous[]\n\t| ContextuallyTypedFieldData;\n\n/**\n * Convert NewFieldContent into ITreeCursor array.\n */\nexport function normalizeNewFieldContent(\n\tcontext: TreeDataContext,\n\tschema: TreeFieldSchema,\n\tcontent: NewFieldContent,\n): readonly ITreeCursorSynchronous[] {\n\tif (areCursors(content)) {\n\t\tif (getFieldKind(schema).multiplicity === Multiplicity.Sequence) {\n\t\t\tassert(isReadonlyArray(content), 0x6b7 /* sequence fields require array content */);\n\t\t\treturn content;\n\t\t} else {\n\t\t\tif (isReadonlyArray(content)) {\n\t\t\t\tassert(\n\t\t\t\t\tcontent.length === 1,\n\t\t\t\t\t0x6b8 /* non-sequence fields can not be provided content that is multiple cursors */,\n\t\t\t\t);\n\t\t\t\treturn content;\n\t\t\t}\n\t\t\treturn [content];\n\t\t}\n\t}\n\n\treturn cursorsFromContextualData(context, schema, content);\n}\n"]}