@fluidframework/tree 2.2.0 → 2.3.0

package/lib/domains/leafDomain.js

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

package/lib/domains/leafDomain.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"leafDomain.js","sourceRoot":"","sources":["../../src/domains/leafDomain.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAEtE;;GAEG;AACH,MAAM,OAAO,GAAG,IAAI,qBAAqB,CAAC,EAAE,KAAK,EAAE,yBAAyB,EAAE,CAAC,CAAC;AAEhF,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;AAC1D,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;AAC7D,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;AAC1D,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;AAC/D,MAAM,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;AAE1D,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAU,CAAC;AACtD,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,UAAU,CAAU,CAAC;AAEzD,MAAM,OAAO,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;AAEtC;;GAEG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG;IACnB;;;;;;;;;;;;;OAaG;IACH,MAAM;IAEN;;OAEG;IACH,OAAO;IAEP;;;;;;;;;;;;OAYG;IACH,MAAM;IAEN;;OAEG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,IAAI,EAAE,UAAU;IAEhB;;OAEG;IACH,UAAU;IAEV;;OAEG;IACH,GAAG;IAEH;;;;;OAKG;IACH,OAAO;CACP,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { ValueSchema } from \"../core/index.js\";\nimport { SchemaBuilderInternal } from \"../feature-libraries/index.js\";\n\n/**\n * Names in this domain follow https://en.wikipedia.org/wiki/Reverse_domain_name_notation\n */\nconst builder = new SchemaBuilderInternal({ scope: \"com.fluidframework.leaf\" });\n\nconst number = builder.leaf(\"number\", ValueSchema.Number);\nconst boolean = builder.leaf(\"boolean\", ValueSchema.Boolean);\nconst string = builder.leaf(\"string\", ValueSchema.String);\nconst handle = builder.leaf(\"handle\", ValueSchema.FluidHandle);\nconst nullSchema = builder.leaf(\"null\", ValueSchema.Null);\n\nconst primitives = [number, boolean, string] as const;\nconst all = [handle, nullSchema, ...primitives] as const;\n\nconst library = builder.intoLibrary();\n\n/**\n * Built-in {@link LeafNodeSchema}.\n */\nexport const leaf = {\n\t/**\n\t * {@link LeafNodeSchema} for holding a JavaScript `number`.\n\t *\n\t * @remarks\n\t * The number is a [double-precision 64-bit binary format IEEE 754](https://en.wikipedia.org/wiki/Double-precision_floating-point_format) value, however there are some exceptions:\n\t * - `NaN`, and the infinities should not be used.\n\t * - `-0` may be converted to `0` in some cases.\n\t *\n\t * These limitations match the limitations of JSON.\n\t * @privateRemarks\n\t * TODO:\n\t * We should be much more clear about what happens if you use problematic values.\n\t * We should validate and/or normalize them when inserting content.\n\t */\n\tnumber,\n\n\t/**\n\t * {@link LeafNodeSchema} for holding a boolean.\n\t */\n\tboolean,\n\n\t/**\n\t * {@link LeafNodeSchema} for holding a JavaScript `string`.\n\t *\n\t * @remarks\n\t * Strings containing unpaired UTF-16 surrogate pair code units may not be handled correctly.\n\t *\n\t * These limitations come from the use of UTF-8 encoding of the strings, which requires them to be valid unicode.\n\t * JavaScript does not make this requirement for its strings so not all possible JavaScript strings are supported.\n\t * @privateRemarks\n\t * TODO:\n\t * We should be much more clear about what happens if you use problematic values.\n\t * We should validate and/or normalize them when inserting content.\n\t */\n\tstring,\n\n\t/**\n\t * {@link LeafNodeSchema} for holding an {@link @fluidframework/core-interfaces#(IFluidHandle:interface)}.\n\t */\n\thandle,\n\n\t/**\n\t * {@link LeafNodeSchema} for JavaScript `null`.\n\t *\n\t * @remarks\n\t * There are good [reasons to avoid using null](https://www.npmjs.com/package/%40rushstack/eslint-plugin#rushstackno-new-null) in JavaScript, however sometimes it is desired.\n\t * This {@link LeafNodeSchema} node provides the option to include nulls in trees when desired.\n\t * Unless directly inter-operating with existing data using null, consider other approaches, like wrapping the value in an optional field, or using a more specifically named empty object node.\n\t */\n\tnull: nullSchema,\n\n\t/**\n\t * The set of {@link LeafNodeSchema} which correspond to JavaScript primitive (non-object) types.\n\t */\n\tprimitives,\n\n\t/**\n\t * All {@link LeafNodeSchema} defined in this library..\n\t */\n\tall,\n\n\t/**\n\t * {@link SchemaLibrary} of the {@link LeafNodeSchema}.\n\t *\n\t * @privateRemarks\n\t * This is included by default in schema produced with {@link SchemaBuilder}.\n\t */\n\tlibrary,\n};\n"]}

package/lib/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/lib/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/lib/domains/schemaBuilder.js

@@ -1,117 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { FieldKinds, SchemaBuilderBase, } from "../feature-libraries/index.js";
-import { leaf } from "./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.
- */
-export class SchemaBuilder extends SchemaBuilderBase {
-    constructor(options) {
-        super(FieldKinds.required, {
-            ...options,
-            libraries: [...(options.libraries ?? []), 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);
-    }
-}
-/**
- * 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(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(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(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(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/lib/domains/schemaBuilder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemaBuilder.js","sourceRoot":"","sources":["../../src/domains/schemaBuilder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,UAAU,EAOV,iBAAiB,GAGjB,MAAM,+BAA+B,CAAC;AAGvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,aAGX,SAAQ,iBAA4D;IACrE,YAAmB,OAAqC;QACvD,KAAK,CAAC,UAAU,CAAC,QAAQ,EAAE;YAC1B,GAAG,OAAO;YACV,SAAS,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC,EAAE,IAAI,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;;AAED;;;;;;GAMG;AACW,sBAAQ,GAAG,WAAW,CAAC,UAAU,CAAC,QAAQ,CAAC,AAAnC,CAAoC;AAY1D;;;;;;GAMG;AACW,sBAAQ,GAAG,WAAW,CAAC,UAAU,CAAC,QAAQ,CAAC,AAAnC,CAAoC;AAc1D;;;;;;GAMG;AACW,sBAAQ,GAAG,WAAW,CAAC,UAAU,CAAC,QAAQ,CAAC,AAAnC,CAAoC;AAY1D;;;;;;GAMG;AACW,wBAAU,GAAG,WAAW,CAAC,UAAU,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/lib/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/lib/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/lib/domains/testRecursiveDomain.js

@@ -1,32 +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 { FieldKinds, FlexFieldSchema, SchemaBuilderBase } from "../feature-libraries/index.js";
-import { leaf } from "./leafDomain.js";
-const builder = new SchemaBuilderBase(FieldKinds.optional, { scope: "Test Recursive Domain" });
-export const recursiveObject = builder.objectRecursive("object", {
-    recursive: FlexFieldSchema.createUnsafe(FieldKinds.optional, [() => recursiveObject]),
-    number: leaf.number,
-});
-export const library = builder.intoLibrary();
-{
-    const b = new SchemaBuilderBase(FieldKinds.optional, { scope: "Test Recursive Domain" });
-    const node = b.objectRecursive("object", {
-        child: FlexFieldSchema.createUnsafe(FieldKinds.optional, [() => node]),
-    });
-    const _field = FlexFieldSchema.createUnsafe(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/lib/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,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAE/F,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,MAAM,OAAO,GAAG,IAAI,iBAAiB,CAAC,UAAU,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,uBAAuB,EAAE,CAAC,CAAC;AAE/F,MAAM,CAAC,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,QAAQ,EAAE;IAChE,SAAS,EAAE,eAAe,CAAC,YAAY,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,eAAe,CAAC,CAAC;IACrF,MAAM,EAAE,IAAI,CAAC,MAAM;CACnB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;AAE7C,CAAC;IACA,MAAM,CAAC,GAAG,IAAI,iBAAiB,CAAC,UAAU,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,uBAAuB,EAAE,CAAC,CAAC;IACzF,MAAM,IAAI,GAAG,CAAC,CAAC,eAAe,CAAC,QAAQ,EAAE;QACxC,KAAK,EAAE,eAAe,CAAC,YAAY,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;KACtE,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,eAAe,CAAC,YAAY,CAAC,UAAU,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/lib/events/events.d.ts

@@ -1,201 +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.
- */
-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.
- */
-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.
- */
-export type NoListenersCallback<TListeners extends object> = (eventName: keyof Listeners<TListeners>) => void;
-/**
- */
-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 = EventEmitter.create<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);
- *   }
- * }
- * ```
- */
-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/lib/events/events.d.ts.map

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