@fluidframework/tree 2.3.0-288113 → 2.3.0

package/dist/domains/schemaBuilder.d.ts

@@ -1,103 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { FieldKinds, type FlexFieldSchema, type FlexImplicitAllowedTypes, type FlexImplicitFieldSchema, type FlexObjectNodeSchema, type NormalizeAllowedTypes, SchemaBuilderBase, type SchemaBuilderOptions, type Unenforced } from "../feature-libraries/index.js";
-import type { RestrictiveReadonlyRecord } from "../util/index.js";
-/**
- * Builds schema libraries, and the schema within them.
- *
- * @remarks
- * Fields, when inferred from {@link FlexImplicitFieldSchema}, default to the `Required` {@link FlexFieldKind} (except for in Maps, which default to `Optional`).
- * Implicitly includes `leaf` schema library by default.
- *
- * This type has some built in defaults which impact compatibility.
- * This includes which {@link FlexFieldKind}s it uses.
- * To ensure that these defaults can be updated without compatibility issues,
- * this class is versioned: the number in its name indicates its compatibility,
- * and if its defaults are changed to ones that would not be compatible with a version of the application using the previous versions,
- * this number will be updated to make it impossible for an app to implicitly do a compatibility breaking change by updating this package.
- * Major package version updates are allowed to break API compatibility, but must not break content compatibility unless a corresponding code change is made in the app to opt in.
- *
- * @privateRemarks
- * TODO: Maybe rename to DefaultSchemaBuilder1 because of the versioning implications above.
- * Same applies to SchemaBuilder.
- * TODO: figure out a way to link `leaf` above without breaking API Extractor.
- * @sealed
- * @deprecated Users of this class should either use {@link SchemaBuilderBase} and explicitly work with {@link FlexFieldSchema}, or use SchemaFactory and work at its higher level of abstraction.
- */
-export declare class SchemaBuilder<TScope extends string = string, TName extends string | number = string> extends SchemaBuilderBase<TScope, typeof FieldKinds.required, TName> {
-    constructor(options: SchemaBuilderOptions<TScope>);
-    objectRecursive<const Name extends TName, const T extends Unenforced<RestrictiveReadonlyRecord<string, FlexImplicitFieldSchema>>>(name: Name, t: T): FlexObjectNodeSchema<`${TScope}.${Name}`, T>;
-    /**
-     * Define a schema for an {@link FieldKinds.optional|optional field}.
-     * @remarks
-     * Shorthand for passing `FieldKinds.optional` to {@link FlexFieldSchema.create}.
-     *
-     * This method is also available as an instance method on {@link SchemaBuilder}.
-     */
-    static optional: <const T extends FlexImplicitAllowedTypes>(allowedTypes: T) => FlexFieldSchema<import("../feature-libraries/index.js").Optional, NormalizeAllowedTypes<T>>;
-    /**
-     * Define a schema for an {@link FieldKinds.optional|optional field}.
-     * @remarks
-     * Shorthand for passing `FieldKinds.optional` to {@link FlexFieldSchema.create}.
-     *
-     * Since this creates a {@link FlexFieldSchema} (and not a {@link FlexTreeNodeSchema}), the resulting schema is structurally typed, and not impacted by the {@link SchemaBuilderBase.scope}:
-     * therefore this method is the same as the static version.
-     */
-    readonly optional: <const T extends FlexImplicitAllowedTypes>(allowedTypes: T) => FlexFieldSchema<import("../feature-libraries/index.js").Optional, NormalizeAllowedTypes<T>>;
-    /**
-     * Define a schema for a {@link FieldKinds.required|required field}.
-     * @remarks
-     * Shorthand for passing `FieldKinds.required` to {@link FlexFieldSchema.create}.
-     *
-     * This method is also available as an instance method on {@link SchemaBuilder}.
-     */
-    static required: <const T extends FlexImplicitAllowedTypes>(allowedTypes: T) => FlexFieldSchema<import("../feature-libraries/index.js").Required, NormalizeAllowedTypes<T>>;
-    /**
-     * Define a schema for a {@link FieldKinds.required|required field}.
-     * @remarks
-     * Shorthand for passing `FieldKinds.required` to {@link FlexFieldSchema.create}.
-     * Note that `FieldKinds.required` is the current default field kind, so APIs accepting {@link FlexImplicitFieldSchema}
-     * can be passed the `allowedTypes` and will implicitly wrap it up in a {@link FieldKinds.required|required field}.
-     *
-     * Since this creates a {@link FlexFieldSchema} (and not a {@link FlexTreeNodeSchema}), the resulting schema is structurally typed, and not impacted by the {@link SchemaBuilderBase.scope}:
-     * therefore this method is the same as the static version.
-     */
-    readonly required: <const T extends FlexImplicitAllowedTypes>(allowedTypes: T) => FlexFieldSchema<import("../feature-libraries/index.js").Required, NormalizeAllowedTypes<T>>;
-    /**
-     * Define a schema for a {@link FieldKinds.sequence|sequence field}.
-     * @remarks
-     * Shorthand for passing `FieldKinds.sequence` to {@link FlexFieldSchema.create}.
-     *
-     * This method is also available as an instance method on {@link SchemaBuilder}
-     */
-    static sequence: <const T extends FlexImplicitAllowedTypes>(allowedTypes: T) => FlexFieldSchema<import("../feature-libraries/index.js").Sequence, NormalizeAllowedTypes<T>>;
-    /**
-     * Define a schema for a {@link FieldKinds.sequence|sequence field}.
-     * @remarks
-     * Shorthand for passing `FieldKinds.sequence` to {@link FlexFieldSchema.create}.
-     *
-     * Since this creates a {@link FlexFieldSchema} (and not a {@link FlexTreeNodeSchema}), the resulting schema is structurally typed, and not impacted by the {@link SchemaBuilderBase.scope}:
-     * therefore this method is the same as the static version.
-     */
-    readonly sequence: <const T extends FlexImplicitAllowedTypes>(allowedTypes: T) => FlexFieldSchema<import("../feature-libraries/index.js").Sequence, NormalizeAllowedTypes<T>>;
-    /**
-     * Define a schema for an {@link FieldKinds.identifier|identifier field}.
-     * @remarks
-     * Shorthand for passing `FieldKinds.identifier` to {@link TreeFieldSchema.create}.
-     *
-     * This method is also available as an instance method on {@link SchemaBuilder}
-     */
-    static identifier: <const T extends FlexImplicitAllowedTypes>(allowedTypes: T) => FlexFieldSchema<import("../feature-libraries/index.js").Identifier, NormalizeAllowedTypes<T>>;
-    /**
-     * Define a schema for a {@link FieldKinds.identifier|identifier field}.
-     * @remarks
-     * Shorthand for passing `FieldKinds.identifier` to {@link TreeFieldSchema.create}.
-     *
-     * Since this creates a {@link TreeFieldSchema} (and not a {@link FlexTreeNodeSchema}), the resulting schema is structurally typed, and not impacted by the {@link SchemaBuilderBase.scope}:
-     * therefore this method is the same as the static version.
-     */
-    readonly identifier: <const T extends FlexImplicitAllowedTypes>(allowedTypes: T) => FlexFieldSchema<import("../feature-libraries/index.js").Identifier, NormalizeAllowedTypes<T>>;
-}
-//# sourceMappingURL=schemaBuilder.d.ts.map

package/dist/domains/schemaBuilder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemaBuilder.d.ts","sourceRoot":"","sources":["../../src/domains/schemaBuilder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,UAAU,EAEV,KAAK,eAAe,EACpB,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,iBAAiB,EACjB,KAAK,oBAAoB,EACzB,KAAK,UAAU,EACf,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAIlE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,aAAa,CACzB,MAAM,SAAS,MAAM,GAAG,MAAM,EAC9B,KAAK,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,CACrC,SAAQ,iBAAiB,CAAC,MAAM,EAAE,OAAO,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAC;gBAClD,OAAO,EAAE,oBAAoB,CAAC,MAAM,CAAC;IAQxC,eAAe,CAC9B,KAAK,CAAC,IAAI,SAAS,KAAK,EACxB,KAAK,CAAC,CAAC,SAAS,UAAU,CAAC,yBAAyB,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC,EACrF,IAAI,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;IAOlB;;;;;;OAMG;IACH,OAAc,QAAQ,6JAAoC;IAE1D;;;;;;;OAOG;IACH,SAAgB,QAAQ,6JAA0B;IAElD;;;;;;OAMG;IACH,OAAc,QAAQ,6JAAoC;IAE1D;;;;;;;;;OASG;IACH,SAAgB,QAAQ,6JAA0B;IAElD;;;;;;OAMG;IACH,OAAc,QAAQ,6JAAoC;IAE1D;;;;;;;OAOG;IACH,SAAgB,QAAQ,6JAA0B;IAElD;;;;;;OAMG;IACH,OAAc,UAAU,+JAAsC;IAE9D;;;;;;;OAOG;IACH,SAAgB,UAAU,+JAA4B;CACtD"}

package/dist/domains/schemaBuilder.js

@@ -1,121 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaBuilder = void 0;
-const index_js_1 = require("../feature-libraries/index.js");
-const leafDomain_js_1 = require("./leafDomain.js");
-/**
- * Builds schema libraries, and the schema within them.
- *
- * @remarks
- * Fields, when inferred from {@link FlexImplicitFieldSchema}, default to the `Required` {@link FlexFieldKind} (except for in Maps, which default to `Optional`).
- * Implicitly includes `leaf` schema library by default.
- *
- * This type has some built in defaults which impact compatibility.
- * This includes which {@link FlexFieldKind}s it uses.
- * To ensure that these defaults can be updated without compatibility issues,
- * this class is versioned: the number in its name indicates its compatibility,
- * and if its defaults are changed to ones that would not be compatible with a version of the application using the previous versions,
- * this number will be updated to make it impossible for an app to implicitly do a compatibility breaking change by updating this package.
- * Major package version updates are allowed to break API compatibility, but must not break content compatibility unless a corresponding code change is made in the app to opt in.
- *
- * @privateRemarks
- * TODO: Maybe rename to DefaultSchemaBuilder1 because of the versioning implications above.
- * Same applies to SchemaBuilder.
- * TODO: figure out a way to link `leaf` above without breaking API Extractor.
- * @sealed
- * @deprecated Users of this class should either use {@link SchemaBuilderBase} and explicitly work with {@link FlexFieldSchema}, or use SchemaFactory and work at its higher level of abstraction.
- */
-class SchemaBuilder extends index_js_1.SchemaBuilderBase {
-    constructor(options) {
-        super(index_js_1.FieldKinds.required, {
-            ...options,
-            libraries: [...(options.libraries ?? []), leafDomain_js_1.leaf.library],
-        });
-        /**
-         * Define a schema for an {@link FieldKinds.optional|optional field}.
-         * @remarks
-         * Shorthand for passing `FieldKinds.optional` to {@link FlexFieldSchema.create}.
-         *
-         * Since this creates a {@link FlexFieldSchema} (and not a {@link FlexTreeNodeSchema}), the resulting schema is structurally typed, and not impacted by the {@link SchemaBuilderBase.scope}:
-         * therefore this method is the same as the static version.
-         */
-        this.optional = SchemaBuilder.optional;
-        /**
-         * Define a schema for a {@link FieldKinds.required|required field}.
-         * @remarks
-         * Shorthand for passing `FieldKinds.required` to {@link FlexFieldSchema.create}.
-         * Note that `FieldKinds.required` is the current default field kind, so APIs accepting {@link FlexImplicitFieldSchema}
-         * can be passed the `allowedTypes` and will implicitly wrap it up in a {@link FieldKinds.required|required field}.
-         *
-         * Since this creates a {@link FlexFieldSchema} (and not a {@link FlexTreeNodeSchema}), the resulting schema is structurally typed, and not impacted by the {@link SchemaBuilderBase.scope}:
-         * therefore this method is the same as the static version.
-         */
-        this.required = SchemaBuilder.required;
-        /**
-         * Define a schema for a {@link FieldKinds.sequence|sequence field}.
-         * @remarks
-         * Shorthand for passing `FieldKinds.sequence` to {@link FlexFieldSchema.create}.
-         *
-         * Since this creates a {@link FlexFieldSchema} (and not a {@link FlexTreeNodeSchema}), the resulting schema is structurally typed, and not impacted by the {@link SchemaBuilderBase.scope}:
-         * therefore this method is the same as the static version.
-         */
-        this.sequence = SchemaBuilder.sequence;
-        /**
-         * Define a schema for a {@link FieldKinds.identifier|identifier field}.
-         * @remarks
-         * Shorthand for passing `FieldKinds.identifier` to {@link TreeFieldSchema.create}.
-         *
-         * Since this creates a {@link TreeFieldSchema} (and not a {@link FlexTreeNodeSchema}), the resulting schema is structurally typed, and not impacted by the {@link SchemaBuilderBase.scope}:
-         * therefore this method is the same as the static version.
-         */
-        this.identifier = SchemaBuilder.identifier;
-    }
-    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-    objectRecursive(name, t) {
-        return this.object(name, t);
-    }
-}
-exports.SchemaBuilder = SchemaBuilder;
-/**
- * Define a schema for an {@link FieldKinds.optional|optional field}.
- * @remarks
- * Shorthand for passing `FieldKinds.optional` to {@link FlexFieldSchema.create}.
- *
- * This method is also available as an instance method on {@link SchemaBuilder}.
- */
-SchemaBuilder.optional = fieldHelper(index_js_1.FieldKinds.optional);
-/**
- * Define a schema for a {@link FieldKinds.required|required field}.
- * @remarks
- * Shorthand for passing `FieldKinds.required` to {@link FlexFieldSchema.create}.
- *
- * This method is also available as an instance method on {@link SchemaBuilder}.
- */
-SchemaBuilder.required = fieldHelper(index_js_1.FieldKinds.required);
-/**
- * Define a schema for a {@link FieldKinds.sequence|sequence field}.
- * @remarks
- * Shorthand for passing `FieldKinds.sequence` to {@link FlexFieldSchema.create}.
- *
- * This method is also available as an instance method on {@link SchemaBuilder}
- */
-SchemaBuilder.sequence = fieldHelper(index_js_1.FieldKinds.sequence);
-/**
- * Define a schema for an {@link FieldKinds.identifier|identifier field}.
- * @remarks
- * Shorthand for passing `FieldKinds.identifier` to {@link TreeFieldSchema.create}.
- *
- * This method is also available as an instance method on {@link SchemaBuilder}
- */
-SchemaBuilder.identifier = fieldHelper(index_js_1.FieldKinds.identifier);
-/**
- * Returns a wrapper around SchemaBuilder.field for a specific FieldKind.
- */
-function fieldHelper(kind) {
-    return (allowedTypes) => SchemaBuilder.field(kind, allowedTypes);
-}
-//# sourceMappingURL=schemaBuilder.js.map

package/dist/domains/schemaBuilder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemaBuilder.js","sourceRoot":"","sources":["../../src/domains/schemaBuilder.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,4DAWuC;AAGvC,mDAAuC;AAEvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAa,aAGX,SAAQ,4BAA4D;IACrE,YAAmB,OAAqC;QACvD,KAAK,CAAC,qBAAU,CAAC,QAAQ,EAAE;YAC1B,GAAG,OAAO;YACV,SAAS,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC,EAAE,oBAAI,CAAC,OAAO,CAAC;SACvD,CAAC,CAAC;QAuBJ;;;;;;;WAOG;QACa,aAAQ,GAAG,aAAa,CAAC,QAAQ,CAAC;QAWlD;;;;;;;;;WASG;QACa,aAAQ,GAAG,aAAa,CAAC,QAAQ,CAAC;QAWlD;;;;;;;WAOG;QACa,aAAQ,GAAG,aAAa,CAAC,QAAQ,CAAC;QAWlD;;;;;;;WAOG;QACa,eAAU,GAAG,aAAa,CAAC,UAAU,CAAC;IAzFtD,CAAC;IAED,4EAA4E;IAC5D,eAAe,CAG7B,IAAU,EAAE,CAAI;QACjB,OAAO,IAAI,CAAC,MAAM,CACjB,IAAI,EACJ,CAA0E,CACf,CAAC;IAC9D,CAAC;;AApBF,sCAmGC;AA7EA;;;;;;GAMG;AACW,sBAAQ,GAAG,WAAW,CAAC,qBAAU,CAAC,QAAQ,CAAC,AAAnC,CAAoC;AAY1D;;;;;;GAMG;AACW,sBAAQ,GAAG,WAAW,CAAC,qBAAU,CAAC,QAAQ,CAAC,AAAnC,CAAoC;AAc1D;;;;;;GAMG;AACW,sBAAQ,GAAG,WAAW,CAAC,qBAAU,CAAC,QAAQ,CAAC,AAAnC,CAAoC;AAY1D;;;;;;GAMG;AACW,wBAAU,GAAG,WAAW,CAAC,qBAAU,CAAC,UAAU,CAAC,AAArC,CAAsC;AAa/D;;GAEG;AACH,SAAS,WAAW,CAA6B,IAAU;IAC1D,OAAO,CACN,YAAe,EACmC,EAAE,CACpD,aAAa,CAAC,KAAK,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;AAC1C,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport {\n\tFieldKinds,\n\ttype FlexFieldKind,\n\ttype FlexFieldSchema,\n\ttype FlexImplicitAllowedTypes,\n\ttype FlexImplicitFieldSchema,\n\ttype FlexObjectNodeSchema,\n\ttype NormalizeAllowedTypes,\n\tSchemaBuilderBase,\n\ttype SchemaBuilderOptions,\n\ttype Unenforced,\n} from \"../feature-libraries/index.js\";\nimport type { RestrictiveReadonlyRecord } from \"../util/index.js\";\n\nimport { leaf } from \"./leafDomain.js\";\n\n/**\n * Builds schema libraries, and the schema within them.\n *\n * @remarks\n * Fields, when inferred from {@link FlexImplicitFieldSchema}, default to the `Required` {@link FlexFieldKind} (except for in Maps, which default to `Optional`).\n * Implicitly includes `leaf` schema library by default.\n *\n * This type has some built in defaults which impact compatibility.\n * This includes which {@link FlexFieldKind}s it uses.\n * To ensure that these defaults can be updated without compatibility issues,\n * this class is versioned: the number in its name indicates its compatibility,\n * and if its defaults are changed to ones that would not be compatible with a version of the application using the previous versions,\n * this number will be updated to make it impossible for an app to implicitly do a compatibility breaking change by updating this package.\n * Major package version updates are allowed to break API compatibility, but must not break content compatibility unless a corresponding code change is made in the app to opt in.\n *\n * @privateRemarks\n * TODO: Maybe rename to DefaultSchemaBuilder1 because of the versioning implications above.\n * Same applies to SchemaBuilder.\n * TODO: figure out a way to link `leaf` above without breaking API Extractor.\n * @sealed\n * @deprecated Users of this class should either use {@link SchemaBuilderBase} and explicitly work with {@link FlexFieldSchema}, or use SchemaFactory and work at its higher level of abstraction.\n */\nexport class SchemaBuilder<\n\tTScope extends string = string,\n\tTName extends string | number = string,\n> extends SchemaBuilderBase<TScope, typeof FieldKinds.required, TName> {\n\tpublic constructor(options: SchemaBuilderOptions<TScope>) {\n\t\tsuper(FieldKinds.required, {\n\t\t\t...options,\n\t\t\tlibraries: [...(options.libraries ?? []), leaf.library],\n\t\t});\n\t}\n\n\t// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\n\tpublic override objectRecursive<\n\t\tconst Name extends TName,\n\t\tconst T extends Unenforced<RestrictiveReadonlyRecord<string, FlexImplicitFieldSchema>>,\n\t>(name: Name, t: T) {\n\t\treturn this.object(\n\t\t\tname,\n\t\t\tt as unknown as RestrictiveReadonlyRecord<string, FlexImplicitFieldSchema>,\n\t\t) as unknown as FlexObjectNodeSchema<`${TScope}.${Name}`, T>;\n\t}\n\n\t/**\n\t * Define a schema for an {@link FieldKinds.optional|optional field}.\n\t * @remarks\n\t * Shorthand for passing `FieldKinds.optional` to {@link FlexFieldSchema.create}.\n\t *\n\t * This method is also available as an instance method on {@link SchemaBuilder}.\n\t */\n\tpublic static optional = fieldHelper(FieldKinds.optional);\n\n\t/**\n\t * Define a schema for an {@link FieldKinds.optional|optional field}.\n\t * @remarks\n\t * Shorthand for passing `FieldKinds.optional` to {@link FlexFieldSchema.create}.\n\t *\n\t * Since this creates a {@link FlexFieldSchema} (and not a {@link FlexTreeNodeSchema}), the resulting schema is structurally typed, and not impacted by the {@link SchemaBuilderBase.scope}:\n\t * therefore this method is the same as the static version.\n\t */\n\tpublic readonly optional = SchemaBuilder.optional;\n\n\t/**\n\t * Define a schema for a {@link FieldKinds.required|required field}.\n\t * @remarks\n\t * Shorthand for passing `FieldKinds.required` to {@link FlexFieldSchema.create}.\n\t *\n\t * This method is also available as an instance method on {@link SchemaBuilder}.\n\t */\n\tpublic static required = fieldHelper(FieldKinds.required);\n\n\t/**\n\t * Define a schema for a {@link FieldKinds.required|required field}.\n\t * @remarks\n\t * Shorthand for passing `FieldKinds.required` to {@link FlexFieldSchema.create}.\n\t * Note that `FieldKinds.required` is the current default field kind, so APIs accepting {@link FlexImplicitFieldSchema}\n\t * can be passed the `allowedTypes` and will implicitly wrap it up in a {@link FieldKinds.required|required field}.\n\t *\n\t * Since this creates a {@link FlexFieldSchema} (and not a {@link FlexTreeNodeSchema}), the resulting schema is structurally typed, and not impacted by the {@link SchemaBuilderBase.scope}:\n\t * therefore this method is the same as the static version.\n\t */\n\tpublic readonly required = SchemaBuilder.required;\n\n\t/**\n\t * Define a schema for a {@link FieldKinds.sequence|sequence field}.\n\t * @remarks\n\t * Shorthand for passing `FieldKinds.sequence` to {@link FlexFieldSchema.create}.\n\t *\n\t * This method is also available as an instance method on {@link SchemaBuilder}\n\t */\n\tpublic static sequence = fieldHelper(FieldKinds.sequence);\n\n\t/**\n\t * Define a schema for a {@link FieldKinds.sequence|sequence field}.\n\t * @remarks\n\t * Shorthand for passing `FieldKinds.sequence` to {@link FlexFieldSchema.create}.\n\t *\n\t * Since this creates a {@link FlexFieldSchema} (and not a {@link FlexTreeNodeSchema}), the resulting schema is structurally typed, and not impacted by the {@link SchemaBuilderBase.scope}:\n\t * therefore this method is the same as the static version.\n\t */\n\tpublic readonly sequence = SchemaBuilder.sequence;\n\n\t/**\n\t * Define a schema for an {@link FieldKinds.identifier|identifier field}.\n\t * @remarks\n\t * Shorthand for passing `FieldKinds.identifier` to {@link TreeFieldSchema.create}.\n\t *\n\t * This method is also available as an instance method on {@link SchemaBuilder}\n\t */\n\tpublic static identifier = fieldHelper(FieldKinds.identifier);\n\n\t/**\n\t * Define a schema for a {@link FieldKinds.identifier|identifier field}.\n\t * @remarks\n\t * Shorthand for passing `FieldKinds.identifier` to {@link TreeFieldSchema.create}.\n\t *\n\t * Since this creates a {@link TreeFieldSchema} (and not a {@link FlexTreeNodeSchema}), the resulting schema is structurally typed, and not impacted by the {@link SchemaBuilderBase.scope}:\n\t * therefore this method is the same as the static version.\n\t */\n\tpublic readonly identifier = SchemaBuilder.identifier;\n}\n\n/**\n * Returns a wrapper around SchemaBuilder.field for a specific FieldKind.\n */\nfunction fieldHelper<Kind extends FlexFieldKind>(kind: Kind) {\n\treturn <const T extends FlexImplicitAllowedTypes>(\n\t\tallowedTypes: T,\n\t): FlexFieldSchema<Kind, NormalizeAllowedTypes<T>> =>\n\t\tSchemaBuilder.field(kind, allowedTypes);\n}\n"]}

package/dist/domains/testRecursiveDomain.d.ts

@@ -1,17 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * This file exists and is package exported to aid in testing of exporting recursive types across package boundaries.
- * Sometimes when TypeScript generates d.ts files, they type check significantly differently than the original source (One example of this: https://github.com/microsoft/TypeScript/issues/20979).
- * Unfortunately our recursive schema types are an example of types that have this kind of issue: the d.ts files tend to get "any" instead of the recursive type reference.
- * Currently we do not have tooling in place to test this in our test suite, and exporting these types here is a temporary crutch to aid in diagnosing this issue.
- */
-import { FlexFieldSchema } from "../feature-libraries/index.js";
-export declare const recursiveObject: import("../feature-libraries/index.js").FlexObjectNodeSchema<"Test Recursive Domain.object", {
-    readonly recursive: FlexFieldSchema<import("../feature-libraries/index.js").Optional, readonly [() => import("../feature-libraries/index.js").FlexObjectNodeSchema<"Test Recursive Domain.object", any>]>;
-    readonly number: import("../feature-libraries/index.js").LeafNodeSchema<"com.fluidframework.leaf.number", import("../index.js").ValueSchema.Number>;
-}>;
-export declare const library: import("../feature-libraries/schemaBuilderBase.js").SchemaLibrary;
-//# sourceMappingURL=testRecursiveDomain.d.ts.map

package/dist/domains/testRecursiveDomain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"testRecursiveDomain.d.ts","sourceRoot":"","sources":["../../src/domains/testRecursiveDomain.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AAEH,OAAO,EAAc,eAAe,EAAqB,MAAM,+BAA+B,CAAC;AAM/F,eAAO,MAAM,eAAe;;;EAG1B,CAAC;AAEH,eAAO,MAAM,OAAO,mEAAwB,CAAC"}

package/dist/domains/testRecursiveDomain.js

@@ -1,35 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.library = exports.recursiveObject = void 0;
-/**
- * This file exists and is package exported to aid in testing of exporting recursive types across package boundaries.
- * Sometimes when TypeScript generates d.ts files, they type check significantly differently than the original source (One example of this: https://github.com/microsoft/TypeScript/issues/20979).
- * Unfortunately our recursive schema types are an example of types that have this kind of issue: the d.ts files tend to get "any" instead of the recursive type reference.
- * Currently we do not have tooling in place to test this in our test suite, and exporting these types here is a temporary crutch to aid in diagnosing this issue.
- */
-const index_js_1 = require("../feature-libraries/index.js");
-const leafDomain_js_1 = require("./leafDomain.js");
-const builder = new index_js_1.SchemaBuilderBase(index_js_1.FieldKinds.optional, { scope: "Test Recursive Domain" });
-exports.recursiveObject = builder.objectRecursive("object", {
-    recursive: index_js_1.FlexFieldSchema.createUnsafe(index_js_1.FieldKinds.optional, [() => exports.recursiveObject]),
-    number: leafDomain_js_1.leaf.number,
-});
-exports.library = builder.intoLibrary();
-{
-    const b = new index_js_1.SchemaBuilderBase(index_js_1.FieldKinds.optional, { scope: "Test Recursive Domain" });
-    const node = b.objectRecursive("object", {
-        child: index_js_1.FlexFieldSchema.createUnsafe(index_js_1.FieldKinds.optional, [() => node]),
-    });
-    const _field = index_js_1.FlexFieldSchema.createUnsafe(index_js_1.FieldKinds.optional, [node]);
-    // All these cause TSC to "RangeError: Maximum call stack size exceeded"
-    // const _field4 = FlexFieldSchema.create(FieldKinds.optional, [node]);
-    // const _field2 = b.optional(node);
-    // const _field3 = SchemaBuilder.optional(node);
-    // const schema = b.intoSchema(field);
-    // const schema = b.intoSchema(_field);
-}
-//# sourceMappingURL=testRecursiveDomain.js.map

package/dist/domains/testRecursiveDomain.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"testRecursiveDomain.js","sourceRoot":"","sources":["../../src/domains/testRecursiveDomain.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH;;;;;GAKG;AAEH,4DAA+F;AAE/F,mDAAuC;AAEvC,MAAM,OAAO,GAAG,IAAI,4BAAiB,CAAC,qBAAU,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,uBAAuB,EAAE,CAAC,CAAC;AAElF,QAAA,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,QAAQ,EAAE;IAChE,SAAS,EAAE,0BAAe,CAAC,YAAY,CAAC,qBAAU,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,uBAAe,CAAC,CAAC;IACrF,MAAM,EAAE,oBAAI,CAAC,MAAM;CACnB,CAAC,CAAC;AAEU,QAAA,OAAO,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;AAE7C,CAAC;IACA,MAAM,CAAC,GAAG,IAAI,4BAAiB,CAAC,qBAAU,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,uBAAuB,EAAE,CAAC,CAAC;IACzF,MAAM,IAAI,GAAG,CAAC,CAAC,eAAe,CAAC,QAAQ,EAAE;QACxC,KAAK,EAAE,0BAAe,CAAC,YAAY,CAAC,qBAAU,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;KACtE,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,0BAAe,CAAC,YAAY,CAAC,qBAAU,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;IACzE,wEAAwE;IACxE,uEAAuE;IACvE,oCAAoC;IACpC,gDAAgD;IAChD,sCAAsC;IACtC,uCAAuC;AACxC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * This file exists and is package exported to aid in testing of exporting recursive types across package boundaries.\n * Sometimes when TypeScript generates d.ts files, they type check significantly differently than the original source (One example of this: https://github.com/microsoft/TypeScript/issues/20979).\n * Unfortunately our recursive schema types are an example of types that have this kind of issue: the d.ts files tend to get \"any\" instead of the recursive type reference.\n * Currently we do not have tooling in place to test this in our test suite, and exporting these types here is a temporary crutch to aid in diagnosing this issue.\n */\n\nimport { FieldKinds, FlexFieldSchema, SchemaBuilderBase } from \"../feature-libraries/index.js\";\n\nimport { leaf } from \"./leafDomain.js\";\n\nconst builder = new SchemaBuilderBase(FieldKinds.optional, { scope: \"Test Recursive Domain\" });\n\nexport const recursiveObject = builder.objectRecursive(\"object\", {\n\trecursive: FlexFieldSchema.createUnsafe(FieldKinds.optional, [() => recursiveObject]),\n\tnumber: leaf.number,\n});\n\nexport const library = builder.intoLibrary();\n\n{\n\tconst b = new SchemaBuilderBase(FieldKinds.optional, { scope: \"Test Recursive Domain\" });\n\tconst node = b.objectRecursive(\"object\", {\n\t\tchild: FlexFieldSchema.createUnsafe(FieldKinds.optional, [() => node]),\n\t});\n\tconst _field = FlexFieldSchema.createUnsafe(FieldKinds.optional, [node]);\n\t// All these cause TSC to \"RangeError: Maximum call stack size exceeded\"\n\t// const _field4 = FlexFieldSchema.create(FieldKinds.optional, [node]);\n\t// const _field2 = b.optional(node);\n\t// const _field3 = SchemaBuilder.optional(node);\n\t// const schema = b.intoSchema(field);\n\t// const schema = b.intoSchema(_field);\n}\n"]}

package/dist/events/events.d.ts

@@ -1,207 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { IEvent } from "@fluidframework/core-interfaces";
-/**
- * Convert a union of types to an intersection of those types. Useful for `TransformEvents`.
- * @privateRemarks
- * First an always true extends clause is used (T extends T) to distribute T into to a union of types contravariant over each member of the T union.
- * Then the constraint on the type parameter in this new context is inferred, giving the intersection.
- */
-export type UnionToIntersection<T> = (T extends T ? (k: T) => unknown : never) extends (k: infer U) => unknown ? U : never;
-/**
- * `true` iff the given type is an acceptable shape for a {@link Listeners | event} listener
- * @public
- */
-export type IsListener<TListener> = TListener extends (...args: any[]) => void ? true : false;
-/**
- * Used to specify the kinds of events emitted by a {@link Listenable}.
- *
- * @remarks
- * Any object type is a valid {@link Listeners}, but only the {@link IsListener | event-like} properties of that
- * type will be included.
- *
- * @example
- * ```typescript
- * interface MyEvents {
- *   load: (user: string, data: IUserData) => void;
- *   error: (errorCode: number) => void;
- * }
- * ```
- *
- * @public
- */
-export type Listeners<T extends object> = {
-    [P in (string | symbol) & keyof T as IsListener<T[P]> extends true ? P : never]: T[P];
-};
-/**
- * Converts a {@link Listeners} type (i.e. the event registry for a {@link Listenable}) into a type consumable
- * by an IEventProvider from `@fluidframework/core-interfaces`.
- * @param E - the `Events` type to transform
- * @param Target - an optional `IEvent` type that will be merged into the result along with the transformed `E`
- *
- * @example
- *
- * ```typescript
- * interface MyEvents {
- *   load: (user: string, data: IUserData) => void;
- *   error: (errorCode: number) => void;
- * }
- *
- * class MySharedObject extends SharedObject<TransformEvents<MyEvents, ISharedObjectEvents>> {
- *    // ...
- * }
- * ```
- */
-export type TransformListeners<TListeners extends Listeners<TListeners>, TTarget extends IEvent = IEvent> = {
-    [P in keyof Listeners<TListeners>]: (event: P, listener: TListeners[P]) => void;
-} extends Record<string | number | symbol, infer Z> ? UnionToIntersection<Z> & TTarget : never;
-/**
- * An object which allows the registration of listeners so that subscribers can be notified when an event happens.
- * @param TListeners - All the {@link Listeners | events} that this subscribable supports
- *
- * @privateRemarks
- * `EventEmitter` can be used as a base class to implement this via extension.
- * ```ts
- * type MyEventEmitter = IEventEmitter<{
- *   load: (user: string, data: IUserData) => void;
- *   error: (errorCode: number) => void;
- * }>
- * ```
- * {@link createEmitter} can help implement this interface via delegation.
- *
- * @sealed @public
- */
-export interface Listenable<TListeners extends object> {
-    /**
-     * Register an event listener.
-     * @param eventName - the name of the event
-     * @param listener - the handler to run when the event is fired by the emitter
-     * @returns a {@link Off | function} which will deregister the listener when called.
-     * This deregistration function is idempotent and therefore may be safely called more than once with no effect.
-     * @remarks Do not register the exact same `listener` object for the same event more than once.
-     * Doing so will result in undefined behavior, and is not guaranteed to behave the same in future versions of this library.
-     */
-    on<K extends keyof Listeners<TListeners>>(eventName: K, listener: TListeners[K]): Off;
-}
-/**
- * A function that, when called, will deregister an event listener subscription that was previously registered.
- * @remarks
- * It is returned by the {@link Listenable.on | event registration function} when event registration occurs.
- * @public
- */
-export type Off = () => void;
-/**
- * Interface for an event emitter that can emit typed events to subscribed listeners.
- * @sealed @alpha
- */
-export interface IEmitter<TListeners extends Listeners<TListeners>> {
-    /**
-     * Emits an event with the specified name and arguments, notifying all subscribers by calling their registered listener functions.
-     * @param eventName - the name of the event to fire
-     * @param args - the arguments passed to the event listener functions
-     */
-    emit<K extends keyof Listeners<TListeners>>(eventName: K, ...args: Parameters<TListeners[K]>): void;
-    /**
-     * Emits an event with the specified name and arguments, notifying all subscribers by calling their registered listener functions.
-     * It also collects the return values of all listeners into an array.
-     *
-     * Warning: This method should be used with caution. It deviates from the standard event-based integration pattern as creates substantial coupling between the emitter and its listeners.
-     * For the majority of use-cases it is recommended to use the standard {@link IEmitter.emit} functionality.
-     * @param eventName - the name of the event to fire
-     * @param args - the arguments passed to the event listener functions
-     * @returns An array of the return values of each listener, preserving the order listeners were called.
-     */
-    emitAndCollect<K extends keyof Listeners<TListeners>>(eventName: K, ...args: Parameters<TListeners[K]>): ReturnType<TListeners[K]>[];
-}
-/**
- * Create a {@link Listenable} that can be instructed to emit events via the {@link IEmitter} interface.
- *
- * A class can delegate handling {@link Listenable} to the returned value while using it to emit the events.
- * See also `EventEmitter` which be used as a base class to implement {@link Listenable} via extension.
- * @alpha
- */
-export declare function createEmitter<TListeners extends object>(noListeners?: NoListenersCallback<TListeners>): Listenable<TListeners> & IEmitter<TListeners> & HasListeners<TListeners>;
-/**
- * Called when the last listener for `eventName` is removed.
- * Useful for determining when to clean up resources related to detecting when the event might occurs.
- * @alpha
- */
-export type NoListenersCallback<TListeners extends object> = (eventName: keyof Listeners<TListeners>) => void;
-/**
- * Allows querying if an object has listeners.
- * @sealed @alpha
- */
-export interface HasListeners<TListeners extends Listeners<TListeners>> {
-    /**
-     * When no `eventName` is provided, returns true iff there are any listeners.
-     *
-     * When `eventName` is provided, returns true iff there are listeners for that event.
-     *
-     * @remarks
-     * This can be used to know when its safe to cleanup data-structures which only exist to fire events for their listeners.
-     */
-    hasListeners(eventName?: keyof Listeners<TListeners>): boolean;
-}
-/**
- * Provides an API for subscribing to and listening to events.
- *
- * @remarks Classes wishing to emit events may either extend this class or compose over it.
- *
- * @example Extending this class
- *
- * ```typescript
- * interface MyEvents {
- *   "loaded": () => void;
- * }
- *
- * class MyClass extends EventEmitter<MyEvents> {
- *   private load() {
- *     this.emit("loaded");
- *   }
- * }
- * ```
- *
- * @example Composing over this class
- *
- * ```typescript
- * class MyClass implements ISubscribable<MyEvents> {
- *   private readonly events = createEmitter<MyEvents>();
- *
- *   private load() {
- *     this.events.emit("loaded");
- *   }
- *
- *   public on<K extends keyof MyEvents>(eventName: K, listener: MyEvents[K]): Off {
- *     return this.events.on(eventName, listener);
- *   }
- * }
- * ```
- * @alpha
- */
-export declare class EventEmitter<TListeners extends Listeners<TListeners>> implements Listenable<TListeners>, HasListeners<TListeners> {
-    private readonly noListeners?;
-    protected readonly listeners: Map<keyof TListeners, Map<Off, (...args: any[]) => TListeners[keyof TListeners]>>;
-    protected constructor(noListeners?: NoListenersCallback<TListeners> | undefined);
-    protected emit<K extends keyof TListeners>(eventName: K, ...args: Parameters<TListeners[K]>): void;
-    protected emitAndCollect<K extends keyof TListeners>(eventName: K, ...args: Parameters<TListeners[K]>): ReturnType<TListeners[K]>[];
-    /**
-     * Register an event listener.
-     * @param eventName - the name of the event
-     * @param listener - the handler to run when the event is fired by the emitter
-     * @returns a function which will deregister the listener when run.
-     * This function will error if called more than once.
-     */
-    on<K extends keyof Listeners<TListeners>>(eventName: K, listener: TListeners[K]): Off;
-    hasListeners(eventName?: keyof TListeners): boolean;
-}
-/**
- * This class exposes the constructor and the `emit` method of `EventEmitter`, elevating them from protected to public
- */
-export declare class ComposableEventEmitter<TListeners extends Listeners<TListeners>> extends EventEmitter<TListeners> implements IEmitter<TListeners> {
-    constructor(noListeners?: NoListenersCallback<TListeners>);
-    emit<K extends keyof TListeners>(eventName: K, ...args: Parameters<TListeners[K]>): void;
-    emitAndCollect<K extends keyof TListeners>(eventName: K, ...args: Parameters<TListeners[K]>): ReturnType<TListeners[K]>[];
-}
-//# sourceMappingURL=events.d.ts.map

package/dist/events/events.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/events/events.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAC;AAG9D;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,KAAK,CAAC,SAAS,CACtF,CAAC,EAAE,MAAM,CAAC,KACN,OAAO,GACT,CAAC,GACD,KAAK,CAAC;AAET;;;GAGG;AACH,MAAM,MAAM,UAAU,CAAC,SAAS,IAAI,SAAS,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC;AAE9F;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,MAAM,IAAI;KACxC,CAAC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;CACrF,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,kBAAkB,CAC7B,UAAU,SAAS,SAAS,CAAC,UAAU,CAAC,EACxC,OAAO,SAAS,MAAM,GAAG,MAAM,IAC5B;KACF,CAAC,IAAI,MAAM,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI;CAC/E,SAAS,MAAM,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,CAAC,GAChD,mBAAmB,CAAC,CAAC,CAAC,GAAG,OAAO,GAChC,KAAK,CAAC;AAET;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,UAAU,CAAC,UAAU,SAAS,MAAM;IACpD;;;;;;;;OAQG;IACH,EAAE,CAAC,CAAC,SAAS,MAAM,SAAS,CAAC,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;CACtF;AAED;;;;;GAKG;AACH,MAAM,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC;AAE7B;;;GAGG;AACH,MAAM,WAAW,QAAQ,CAAC,UAAU,SAAS,SAAS,CAAC,UAAU,CAAC;IACjE;;;;OAIG;IACH,IAAI,CAAC,CAAC,SAAS,MAAM,SAAS,CAAC,UAAU,CAAC,EACzC,SAAS,EAAE,CAAC,EACZ,GAAG,IAAI,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAChC,IAAI,CAAC;IAER;;;;;;;;;OASG;IACH,cAAc,CAAC,CAAC,SAAS,MAAM,SAAS,CAAC,UAAU,CAAC,EACnD,SAAS,EAAE,CAAC,EACZ,GAAG,IAAI,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAChC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,UAAU,SAAS,MAAM,EACtD,WAAW,CAAC,EAAE,mBAAmB,CAAC,UAAU,CAAC,GAC3C,UAAU,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,GAAG,YAAY,CAAC,UAAU,CAAC,CAE1E;AAED;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,CAAC,UAAU,SAAS,MAAM,IAAI,CAC5D,SAAS,EAAE,MAAM,SAAS,CAAC,UAAU,CAAC,KAClC,IAAI,CAAC;AAEV;;;GAGG;AACH,MAAM,WAAW,YAAY,CAAC,UAAU,SAAS,SAAS,CAAC,UAAU,CAAC;IACrE;;;;;;;OAOG;IACH,YAAY,CAAC,SAAS,CAAC,EAAE,MAAM,SAAS,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC;CAC/D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAAa,YAAY,CAAC,UAAU,SAAS,SAAS,CAAC,UAAU,CAAC,CACjE,YAAW,UAAU,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC,UAAU,CAAC;IASrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;IAPnD,SAAS,CAAC,QAAQ,CAAC,SAAS,2CAER,GAAG,EAAE,KAAK,UAAU,CAAC,MAAM,UAAU,CAAC,GACtD;IAIJ,SAAS,aAA8B,WAAW,CAAC,6CAAiC;IAEpF,SAAS,CAAC,IAAI,CAAC,CAAC,SAAS,MAAM,UAAU,EACxC,SAAS,EAAE,CAAC,EACZ,GAAG,IAAI,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAChC,IAAI;IAgBP,SAAS,CAAC,cAAc,CAAC,CAAC,SAAS,MAAM,UAAU,EAClD,SAAS,EAAE,CAAC,EACZ,GAAG,IAAI,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAChC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE;IAa9B;;;;;;OAMG;IACI,EAAE,CAAC,CAAC,SAAS,MAAM,SAAS,CAAC,UAAU,CAAC,EAC9C,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC,GACrB,GAAG;IAeC,YAAY,CAAC,SAAS,CAAC,EAAE,MAAM,UAAU,GAAG,OAAO;CAM1D;AAED;;GAEG;AACH,qBAAa,sBAAsB,CAAC,UAAU,SAAS,SAAS,CAAC,UAAU,CAAC,CAC3E,SAAQ,YAAY,CAAC,UAAU,CAC/B,YAAW,QAAQ,CAAC,UAAU,CAAC;gBAEZ,WAAW,CAAC,EAAE,mBAAmB,CAAC,UAAU,CAAC;IAIhD,IAAI,CAAC,CAAC,SAAS,MAAM,UAAU,EAC9C,SAAS,EAAE,CAAC,EACZ,GAAG,IAAI,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAChC,IAAI;IAIS,cAAc,CAAC,CAAC,SAAS,MAAM,UAAU,EACxD,SAAS,EAAE,CAAC,EACZ,GAAG,IAAI,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GAChC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE;CAG9B"}

package/dist/events/events.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/events/events.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 type { IEvent } from \"@fluidframework/core-interfaces\";\nimport { getOrCreate } from \"../util/index.js\";\n\n/**\n * Convert a union of types to an intersection of those types. Useful for `TransformEvents`.\n * @privateRemarks\n * First an always true extends clause is used (T extends T) to distribute T into to a union of types contravariant over each member of the T union.\n * Then the constraint on the type parameter in this new context is inferred, giving the intersection.\n */\nexport type UnionToIntersection<T> = (T extends T ? (k: T) => unknown : never) extends (\n\tk: infer U,\n) => unknown\n\t? U\n\t: never;\n\n/**\n * `true` iff the given type is an acceptable shape for a {@link Listeners | event} listener\n * @public\n */\nexport type IsListener<TListener> = TListener extends (...args: any[]) => void ? true : false;\n\n/**\n * Used to specify the kinds of events emitted by a {@link Listenable}.\n *\n * @remarks\n * Any object type is a valid {@link Listeners}, but only the {@link IsListener | event-like} properties of that\n * type will be included.\n *\n * @example\n * ```typescript\n * interface MyEvents {\n *   load: (user: string, data: IUserData) => void;\n *   error: (errorCode: number) => void;\n * }\n * ```\n *\n * @public\n */\nexport type Listeners<T extends object> = {\n\t[P in (string | symbol) & keyof T as IsListener<T[P]> extends true ? P : never]: T[P];\n};\n\n/**\n * Converts a {@link Listeners} type (i.e. the event registry for a {@link Listenable}) into a type consumable\n * by an IEventProvider from `@fluidframework/core-interfaces`.\n * @param E - the `Events` type to transform\n * @param Target - an optional `IEvent` type that will be merged into the result along with the transformed `E`\n *\n * @example\n *\n * ```typescript\n * interface MyEvents {\n *   load: (user: string, data: IUserData) => void;\n *   error: (errorCode: number) => void;\n * }\n *\n * class MySharedObject extends SharedObject<TransformEvents<MyEvents, ISharedObjectEvents>> {\n *    // ...\n * }\n * ```\n */\nexport type TransformListeners<\n\tTListeners extends Listeners<TListeners>,\n\tTTarget extends IEvent = IEvent,\n> = {\n\t[P in keyof Listeners<TListeners>]: (event: P, listener: TListeners[P]) => void;\n} extends Record<string | number | symbol, infer Z>\n\t? UnionToIntersection<Z> & TTarget\n\t: never;\n\n/**\n * An object which allows the registration of listeners so that subscribers can be notified when an event happens.\n * @param TListeners - All the {@link Listeners | events} that this subscribable supports\n *\n * @privateRemarks\n * `EventEmitter` can be used as a base class to implement this via extension.\n * ```ts\n * type MyEventEmitter = IEventEmitter<{\n *   load: (user: string, data: IUserData) => void;\n *   error: (errorCode: number) => void;\n * }>\n * ```\n * {@link createEmitter} can help implement this interface via delegation.\n *\n * @sealed @public\n */\nexport interface Listenable<TListeners extends object> {\n\t/**\n\t * Register an event listener.\n\t * @param eventName - the name of the event\n\t * @param listener - the handler to run when the event is fired by the emitter\n\t * @returns a {@link Off | function} which will deregister the listener when called.\n\t * This deregistration function is idempotent and therefore may be safely called more than once with no effect.\n\t * @remarks Do not register the exact same `listener` object for the same event more than once.\n\t * Doing so will result in undefined behavior, and is not guaranteed to behave the same in future versions of this library.\n\t */\n\ton<K extends keyof Listeners<TListeners>>(eventName: K, listener: TListeners[K]): Off;\n}\n\n/**\n * A function that, when called, will deregister an event listener subscription that was previously registered.\n * @remarks\n * It is returned by the {@link Listenable.on | event registration function} when event registration occurs.\n * @public\n */\nexport type Off = () => void;\n\n/**\n * Interface for an event emitter that can emit typed events to subscribed listeners.\n * @sealed @alpha\n */\nexport interface IEmitter<TListeners extends Listeners<TListeners>> {\n\t/**\n\t * Emits an event with the specified name and arguments, notifying all subscribers by calling their registered listener functions.\n\t * @param eventName - the name of the event to fire\n\t * @param args - the arguments passed to the event listener functions\n\t */\n\temit<K extends keyof Listeners<TListeners>>(\n\t\teventName: K,\n\t\t...args: Parameters<TListeners[K]>\n\t): void;\n\n\t/**\n\t * Emits an event with the specified name and arguments, notifying all subscribers by calling their registered listener functions.\n\t * It also collects the return values of all listeners into an array.\n\t *\n\t * Warning: This method should be used with caution. It deviates from the standard event-based integration pattern as creates substantial coupling between the emitter and its listeners.\n\t * For the majority of use-cases it is recommended to use the standard {@link IEmitter.emit} functionality.\n\t * @param eventName - the name of the event to fire\n\t * @param args - the arguments passed to the event listener functions\n\t * @returns An array of the return values of each listener, preserving the order listeners were called.\n\t */\n\temitAndCollect<K extends keyof Listeners<TListeners>>(\n\t\teventName: K,\n\t\t...args: Parameters<TListeners[K]>\n\t): ReturnType<TListeners[K]>[];\n}\n\n/**\n * Create a {@link Listenable} that can be instructed to emit events via the {@link IEmitter} interface.\n *\n * A class can delegate handling {@link Listenable} to the returned value while using it to emit the events.\n * See also `EventEmitter` which be used as a base class to implement {@link Listenable} via extension.\n * @alpha\n */\nexport function createEmitter<TListeners extends object>(\n\tnoListeners?: NoListenersCallback<TListeners>,\n): Listenable<TListeners> & IEmitter<TListeners> & HasListeners<TListeners> {\n\treturn new ComposableEventEmitter<TListeners>(noListeners);\n}\n\n/**\n * Called when the last listener for `eventName` is removed.\n * Useful for determining when to clean up resources related to detecting when the event might occurs.\n * @alpha\n */\nexport type NoListenersCallback<TListeners extends object> = (\n\teventName: keyof Listeners<TListeners>,\n) => void;\n\n/**\n * Allows querying if an object has listeners.\n * @sealed @alpha\n */\nexport interface HasListeners<TListeners extends Listeners<TListeners>> {\n\t/**\n\t * When no `eventName` is provided, returns true iff there are any listeners.\n\t *\n\t * When `eventName` is provided, returns true iff there are listeners for that event.\n\t *\n\t * @remarks\n\t * This can be used to know when its safe to cleanup data-structures which only exist to fire events for their listeners.\n\t */\n\thasListeners(eventName?: keyof Listeners<TListeners>): boolean;\n}\n\n/**\n * Provides an API for subscribing to and listening to events.\n *\n * @remarks Classes wishing to emit events may either extend this class or compose over it.\n *\n * @example Extending this class\n *\n * ```typescript\n * interface MyEvents {\n *   \"loaded\": () => void;\n * }\n *\n * class MyClass extends EventEmitter<MyEvents> {\n *   private load() {\n *     this.emit(\"loaded\");\n *   }\n * }\n * ```\n *\n * @example Composing over this class\n *\n * ```typescript\n * class MyClass implements ISubscribable<MyEvents> {\n *   private readonly events = createEmitter<MyEvents>();\n *\n *   private load() {\n *     this.events.emit(\"loaded\");\n *   }\n *\n *   public on<K extends keyof MyEvents>(eventName: K, listener: MyEvents[K]): Off {\n *     return this.events.on(eventName, listener);\n *   }\n * }\n * ```\n * @alpha\n */\nexport class EventEmitter<TListeners extends Listeners<TListeners>>\n\timplements Listenable<TListeners>, HasListeners<TListeners>\n{\n\tprotected readonly listeners = new Map<\n\t\tkeyof TListeners,\n\t\tMap<Off, (...args: any[]) => TListeners[keyof TListeners]>\n\t>();\n\n\t// Because this is protected and not public, calling this externally (not from a subclass) makes sending events to the constructed instance impossible.\n\t// Instead, use the static `create` function to get an instance which allows emitting events.\n\tprotected constructor(private readonly noListeners?: NoListenersCallback<TListeners>) {}\n\n\tprotected emit<K extends keyof TListeners>(\n\t\teventName: K,\n\t\t...args: Parameters<TListeners[K]>\n\t): void {\n\t\tconst listeners = this.listeners.get(eventName);\n\t\tif (listeners !== undefined) {\n\t\t\t// Current TS (5.4.5) cannot spread `args` into `listener()`, but assigning to an array first makes it work.\n\t\t\tconst argArray: unknown[] = args;\n\n\t\t\t// This explicitly copies listeners so that new listeners added during this call to emit will not receive this event.\n\t\t\tfor (const [off, listener] of [...listeners]) {\n\t\t\t\t// If listener has been unsubscribed while invoking other listeners, skip it.\n\t\t\t\tif (listeners.has(off)) {\n\t\t\t\t\tlistener(...argArray);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tprotected emitAndCollect<K extends keyof TListeners>(\n\t\teventName: K,\n\t\t...args: Parameters<TListeners[K]>\n\t): ReturnType<TListeners[K]>[] {\n\t\tconst listeners = this.listeners.get(eventName);\n\t\tif (listeners !== undefined) {\n\t\t\tconst argArray: unknown[] = args;\n\t\t\tconst resultArray: ReturnType<TListeners[K]>[] = [];\n\t\t\tfor (const listener of [...listeners.values()]) {\n\t\t\t\tresultArray.push(listener(...argArray));\n\t\t\t}\n\t\t\treturn resultArray;\n\t\t}\n\t\treturn [];\n\t}\n\n\t/**\n\t * Register an event listener.\n\t * @param eventName - the name of the event\n\t * @param listener - the handler to run when the event is fired by the emitter\n\t * @returns a function which will deregister the listener when run.\n\t * This function will error if called more than once.\n\t */\n\tpublic on<K extends keyof Listeners<TListeners>>(\n\t\teventName: K,\n\t\tlistener: TListeners[K],\n\t): Off {\n\t\tconst off: Off = () => {\n\t\t\tconst currentListeners = this.listeners.get(eventName);\n\t\t\tif (currentListeners?.delete(off) === true) {\n\t\t\t\tif (currentListeners.size === 0) {\n\t\t\t\t\tthis.listeners.delete(eventName);\n\t\t\t\t\tthis.noListeners?.(eventName);\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\tgetOrCreate(this.listeners, eventName, () => new Map()).set(off, listener);\n\t\treturn off;\n\t}\n\n\tpublic hasListeners(eventName?: keyof TListeners): boolean {\n\t\tif (eventName === undefined) {\n\t\t\treturn this.listeners.size !== 0;\n\t\t}\n\t\treturn this.listeners.has(eventName);\n\t}\n}\n\n/**\n * This class exposes the constructor and the `emit` method of `EventEmitter`, elevating them from protected to public\n */\nexport class ComposableEventEmitter<TListeners extends Listeners<TListeners>>\n\textends EventEmitter<TListeners>\n\timplements IEmitter<TListeners>\n{\n\tpublic constructor(noListeners?: NoListenersCallback<TListeners>) {\n\t\tsuper(noListeners);\n\t}\n\n\tpublic override emit<K extends keyof TListeners>(\n\t\teventName: K,\n\t\t...args: Parameters<TListeners[K]>\n\t): void {\n\t\treturn super.emit(eventName, ...args);\n\t}\n\n\tpublic override emitAndCollect<K extends keyof TListeners>(\n\t\teventName: K,\n\t\t...args: Parameters<TListeners[K]>\n\t): ReturnType<TListeners[K]>[] {\n\t\treturn super.emitAndCollect(eventName, ...args);\n\t}\n}\n"]}

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

@@ -1,31 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { ValueSchema } from "../core/index.js";
-import { FieldKinds } from "./default-schema/index.js";
-import { SchemaBuilderBase, type SchemaBuilderOptions } from "./schemaBuilderBase.js";
-import { LeafNodeSchema } from "./typed-schema/index.js";
-/**
- * Extends {@link SchemaBuilderBase} with functionality only used to create built in special libraries.
- * Defaults to "required" fields.
- * @privateRemarks Should not be package exported.
- */
-export declare class SchemaBuilderInternal<TScope extends `com.fluidframework.${string}`> extends SchemaBuilderBase<TScope, typeof FieldKinds.required> {
-    constructor(options: SchemaBuilderOptions<TScope>);
-    /**
-     * Define (and add to this library) a {@link TreeNodeSchema} for a node that wraps a value.
-     * Such nodes will be implicitly unwrapped to the value in some APIs.
-     *
-     * The name must be unique among all TreeNodeSchema in the the document schema.
-     *
-     * In addition to the normal properties of all nodes (having a schema for example),
-     * Leaf nodes only contain a value.
-     * Leaf nodes cannot have fields.
-     *
-     * TODO: Maybe ban undefined from allowed values here.
-     * TODO: Decide and document how unwrapping works for non-primitive terminals.
-     */
-    leaf<Name extends string, const T extends ValueSchema>(name: Name, t: T): LeafNodeSchema<`${TScope}.${Name}`, T>;
-}
-//# sourceMappingURL=schemaBuilder.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemaBuilder.d.ts","sourceRoot":"","sources":["../../src/feature-libraries/schemaBuilder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,KAAK,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACtF,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEzD;;;;GAIG;AACH,qBAAa,qBAAqB,CACjC,MAAM,SAAS,sBAAsB,MAAM,EAAE,CAC5C,SAAQ,iBAAiB,CAAC,MAAM,EAAE,OAAO,UAAU,CAAC,QAAQ,CAAC;gBAC3C,OAAO,EAAE,oBAAoB,CAAC,MAAM,CAAC;IAIxD;;;;;;;;;;;;OAYG;IACI,IAAI,CAAC,IAAI,SAAS,MAAM,EAAE,KAAK,CAAC,CAAC,SAAS,WAAW,EAC3D,IAAI,EAAE,IAAI,EACV,CAAC,EAAE,CAAC,GACF,cAAc,CAAC,GAAG,MAAM,IAAI,IAAI,EAAE,EAAE,CAAC,CAAC;CAKzC"}