@fluidframework/presence 2.10.0-307399

package/dist/core-interfaces/jsonDeserialized.d.ts

@@ -0,0 +1,109 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import type { InternalUtilityTypes } from "./exposedUtilityTypes.js";
+/**
+ * Options for {@link JsonDeserialized}.
+ *
+ * @alpha
+ */
+export interface JsonDeserializedOptions {
+    /**
+     * Exact types that are managed by custom deserialization logic (beyond
+     * {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse|JSON.parse}
+     * without a reviver). Only exact types matching specification will be
+     * preserved unaltered.
+     *
+     * The default value is `never`.
+     */
+    AllowExactly?: unknown;
+    /**
+     * General types that are managed by custom deserialization logic (beyond
+     * {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse|JSON.parse}
+     * without a reviver). Any type satisfying specification will be preserved
+     * unaltered.
+     *
+     * The default value is `never`.
+     */
+    AllowExtensionOf?: unknown;
+}
+/**
+ * Produces a type that results from a type `T` serialized and deserialized
+ * through JSON using {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify|JSON.stringify}
+ * (without replacer) and {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse|JSON.parse}
+ * (without reviver), respectively as base model.
+ *
+ * @typeParam T - The type that was serialized.
+ * @typeParam Options - Options for the filter. See {@link JsonDeserializedOptions}.
+ *
+ * @remarks
+ * Before adding use of this utility type, consider using a utility like
+ * {@link https://github.com/sinclairzx81/typebox#readme | TypeBox} that allows
+ * for runtime validation.
+ *
+ * This filter can be used to derive the expected type of a JSON deserialized
+ * value whether or not the type of value serialized meets serialization
+ * constraints (see {@link JsonSerializable} including serialization pitfalls).
+ *
+ * When used as a filter to inferred generic `T`, a compile-time error can be
+ * produced trying to assign `JsonDeserialized<T>` to `T`.
+ *
+ * Simply deserialized JSON never contains `bigint`, `undefined`, `symbol`,
+ * or function values. (Object properties which had those types before encoding
+ * are omitted during serialization and thus won't be present after
+ * deserialization.) Therefore, through this filter, such properties:
+ *
+ * - become optional with those types excluded (when there are other supported
+ * types in union)
+ *
+ * - are removed (when nothing else in union is supported)
+ *
+ * - in an array are (1) replaced with `null` if `undefined`, `symbol`, and
+ * function values or (2) simply removed (become `never`) if `bigint` value as
+ * serialization attempts will throw.
+ *
+ * Examples results:
+ *
+ * | Before serialization  | After deserialization | After in record    |       After in array |
+ * | --------------------- | --------------------- | ------------------ | --------------------:|
+ * | `undefined \| number` | `number`              | `prop?: number`    | `(number \| null)[]` |
+ * | `symbol \| number`    | `number`              | `prop?: number`    | `(number \| null)[]` |
+ * | `bigint \| number`    | `number`              | `prop: number`     |           `number[]` |
+ * | `undefined`           | N/A `never`           | (prop not present) |             `null[]` |
+ * | `symbol`              | N/A `never`           | (prop not present) |             `null[]` |
+ * | `bigint`              | N/A `never`           | N/A (prop not present) |    N/A `never[]` |
+ * | `bigint \| symbol`    | N/A `never`           | (prop not present) |             `null[]` |
+ * | `bigint \| number \| symbol` | `number`       | `prop?: number`    | `(number \| null)[]` |
+ *
+ * Setter and getter properties become value properties after filtering
+ * although no data will be persisted assuming those properties are backed
+ * by functions. If an implementation of getter/setter interface uses a
+ * simple data member (of supported type), that will persist.
+ *
+ * Recursive types without any required modification are preserved intact.
+ * Recursive types that require modification are unrolled a limited number of
+ * times (currently 4) and then further instances of recursion are replaced with
+ * {@link JsonTypeWith|JsonTypeWith<Options.AllowExactly "or" Options.AllowExtensionOf>}.
+ *
+ * Under basic serialization, class instances become simple data objects that
+ * lose hidden properties and prototypes that are required for `instanceof`
+ * runtime checks.
+ *
+ * The optional 'Options.AllowExactly' and 'Options.AllowExtensionOf'
+ * parameters may be used to permit additional leaf types handled by custom
+ * serialization/deserialization logic.
+ *
+ * @example Example usage
+ *
+ * ```typescript
+ * function foo<T>(): JsonDeserialized<T> { ... }
+ * ```
+ *
+ * @alpha
+ */
+export type JsonDeserialized<T, Options extends JsonDeserializedOptions = {
+    AllowExactly: never;
+    AllowExtensionOf: never;
+}> = InternalUtilityTypes.JsonDeserializedImpl<T, Options>;
+//# sourceMappingURL=jsonDeserialized.d.ts.map

package/dist/core-interfaces/jsonDeserialized.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonDeserialized.d.ts","sourceRoot":"","sources":["../../src/core-interfaces/jsonDeserialized.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACvC;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,MAAM,MAAM,gBAAgB,CAC3B,CAAC,EACD,OAAO,SAAS,uBAAuB,GAAG;IACzC,YAAY,EAAE,KAAK,CAAC;IACpB,gBAAgB,EAAE,KAAK,CAAC;CACxB,IACE,oBAAoB,CAAC,oBAAoB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC"}

package/dist/core-interfaces/jsonDeserialized.js

@@ -0,0 +1,7 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=jsonDeserialized.js.map

package/dist/core-interfaces/jsonDeserialized.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonDeserialized.js","sourceRoot":"","sources":["../../src/core-interfaces/jsonDeserialized.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { InternalUtilityTypes } from \"./exposedUtilityTypes.js\";\n\n/**\n * Options for {@link JsonDeserialized}.\n *\n * @alpha\n */\nexport interface JsonDeserializedOptions {\n\t/**\n\t * Exact types that are managed by custom deserialization logic (beyond\n\t * {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse|JSON.parse}\n\t * without a reviver). Only exact types matching specification will be\n\t * preserved unaltered.\n\t *\n\t * The default value is `never`.\n\t */\n\tAllowExactly?: unknown;\n\n\t/**\n\t * General types that are managed by custom deserialization logic (beyond\n\t * {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse|JSON.parse}\n\t * without a reviver). Any type satisfying specification will be preserved\n\t * unaltered.\n\t *\n\t * The default value is `never`.\n\t */\n\tAllowExtensionOf?: unknown;\n}\n\n/**\n * Produces a type that results from a type `T` serialized and deserialized\n * through JSON using {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify|JSON.stringify}\n * (without replacer) and {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse|JSON.parse}\n * (without reviver), respectively as base model.\n *\n * @typeParam T - The type that was serialized.\n * @typeParam Options - Options for the filter. See {@link JsonDeserializedOptions}.\n *\n * @remarks\n * Before adding use of this utility type, consider using a utility like\n * {@link https://github.com/sinclairzx81/typebox#readme | TypeBox} that allows\n * for runtime validation.\n *\n * This filter can be used to derive the expected type of a JSON deserialized\n * value whether or not the type of value serialized meets serialization\n * constraints (see {@link JsonSerializable} including serialization pitfalls).\n *\n * When used as a filter to inferred generic `T`, a compile-time error can be\n * produced trying to assign `JsonDeserialized<T>` to `T`.\n *\n * Simply deserialized JSON never contains `bigint`, `undefined`, `symbol`,\n * or function values. (Object properties which had those types before encoding\n * are omitted during serialization and thus won't be present after\n * deserialization.) Therefore, through this filter, such properties:\n *\n * - become optional with those types excluded (when there are other supported\n * types in union)\n *\n * - are removed (when nothing else in union is supported)\n *\n * - in an array are (1) replaced with `null` if `undefined`, `symbol`, and\n * function values or (2) simply removed (become `never`) if `bigint` value as\n * serialization attempts will throw.\n *\n * Examples results:\n *\n * | Before serialization  | After deserialization | After in record    |       After in array |\n * | --------------------- | --------------------- | ------------------ | --------------------:|\n * | `undefined \\| number` | `number`              | `prop?: number`    | `(number \\| null)[]` |\n * | `symbol \\| number`    | `number`              | `prop?: number`    | `(number \\| null)[]` |\n * | `bigint \\| number`    | `number`              | `prop: number`     |           `number[]` |\n * | `undefined`           | N/A `never`           | (prop not present) |             `null[]` |\n * | `symbol`              | N/A `never`           | (prop not present) |             `null[]` |\n * | `bigint`              | N/A `never`           | N/A (prop not present) |    N/A `never[]` |\n * | `bigint \\| symbol`    | N/A `never`           | (prop not present) |             `null[]` |\n * | `bigint \\| number \\| symbol` | `number`       | `prop?: number`    | `(number \\| null)[]` |\n *\n * Setter and getter properties become value properties after filtering\n * although no data will be persisted assuming those properties are backed\n * by functions. If an implementation of getter/setter interface uses a\n * simple data member (of supported type), that will persist.\n *\n * Recursive types without any required modification are preserved intact.\n * Recursive types that require modification are unrolled a limited number of\n * times (currently 4) and then further instances of recursion are replaced with\n * {@link JsonTypeWith|JsonTypeWith<Options.AllowExactly \"or\" Options.AllowExtensionOf>}.\n *\n * Under basic serialization, class instances become simple data objects that\n * lose hidden properties and prototypes that are required for `instanceof`\n * runtime checks.\n *\n * The optional 'Options.AllowExactly' and 'Options.AllowExtensionOf'\n * parameters may be used to permit additional leaf types handled by custom\n * serialization/deserialization logic.\n *\n * @example Example usage\n *\n * ```typescript\n * function foo<T>(): JsonDeserialized<T> { ... }\n * ```\n *\n * @alpha\n */\nexport type JsonDeserialized<\n\tT,\n\tOptions extends JsonDeserializedOptions = {\n\t\tAllowExactly: never;\n\t\tAllowExtensionOf: never;\n\t},\n> = InternalUtilityTypes.JsonDeserializedImpl<T, Options>;\n"]}

package/dist/core-interfaces/jsonSerializable.d.ts

@@ -0,0 +1,120 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import type { InternalUtilityTypes } from "./exposedUtilityTypes.js";
+/**
+ * Options for {@link JsonSerializable}.
+ *
+ * @alpha
+ */
+export interface JsonSerializableOptions {
+    /**
+     * Exact types that are managed by custom serialization logic (beyond
+     * {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify|JSON.stringify}
+     * without a replacer). Only exact types matching specification will be
+     * preserved unaltered.
+     *
+     * The default value is `never`.
+     */
+    AllowExactly?: unknown;
+    /**
+     * General types that are managed by custom serialization logic (beyond
+     * {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify|JSON.stringify}
+     * without a replacer). Any type satisfying specification will be preserved
+     * unaltered.
+     *
+     * The default value is `never`.
+     */
+    AllowExtensionOf?: unknown;
+    /**
+     * When set, inaccessible (protected and private) members throughout type T are
+     * ignored as if not present.
+     *
+     * The default value is not present.
+     */
+    IgnoreInaccessibleMembers?: "ignore-inaccessible-members";
+}
+/**
+ * Used to constrain a type `T` to types that are serializable as JSON
+ * using {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify|JSON.stringify}
+ * (without a replacer) as base model.
+ *
+ * Under typical use a compile-time error is produced if `T` contains
+ * non-JsonSerializable members.
+ *
+ * @typeParam T - The type to be constrained.
+ * @typeParam Options - Options for the filter. See {@link JsonSerializableOptions}.
+ *
+ * @remarks
+ * Before adding use of this utility type, consider using a utility like
+ * {@link https://github.com/sinclairzx81/typebox#readme | TypeBox} that allows
+ * for runtime validation.
+ *
+ * Note that this does NOT prevent use of values with non-JSON compatible data,
+ * it only prevents using values with types that include non-JSON compatible data.
+ * This means that one can, for example, pass in a value typed with JSON compatible
+ * interface into this filter, that could actually be a class with lots on non-JSON
+ * compatible fields and methods.
+ *
+ * Important: `T extends JsonSerializable<T>` is incorrect (does not even compile).
+ *
+ * The optional `Options.Allow*` parameters may be used to permit additional leaf types
+ * to support situations where a `replacer` is used to handle special values (e.g.,
+ * `JsonSerializable<{ x: IFluidHandle }, { AllowExtensionOf: IFluidHandle }>`).
+ *
+ * Note that `JsonSerializable<T>` does not protect against the following pitfalls
+ * when serializing with JSON.stringify():
+ *
+ * - Non-finite numbers (`NaN`, `+/-Infinity`) are coerced to `null`.
+ *
+ * - Prototypes and non-enumerable properties are lost.
+ *
+ * - `ArrayLike` types that are not arrays and are serialized as `{ length: number }`.
+ *
+ * - Getter and setters properties are lost. (Though appear supported.)
+ *
+ * - Functions with properties may be absent or the properties may be perserved
+ * depending on the runtime typo of the value. (If built via Object.assign the
+ * target member's type is preserved.) typeof =\> 'function' is lost whereas when
+ * typeof =\> 'object' the properties are preserved.
+ *
+ * - Sparse arrays are filled with `null`.
+ *
+ * Also, `JsonSerializable<T>` does not prevent the construction of circular references.
+ *
+ * Specifying `JsonSerializable<unknown>` or `JsonSerializable<any>` yields a type
+ * alias for {@link JsonTypeWith}`<never>` and should not be used if precise type
+ * safety is desired.
+ *
+ * Class instances are indistinguishable from general objects by type checking
+ * unless they have non-public members.
+ * Unless `Option.IgnoreInaccessibleMembers` is used, types with non-public
+ * members will result in {@link SerializationErrorPerNonPublicProperties}.
+ * When `Option.IgnoreInaccessibleMembers` is `ignore-inaccessible-members`,
+ * non-public (non-function) members are preserved without error, but they are
+ * filtered away by the type filters and thus produce an incorrectly narrowed
+ * type compared to actual data. Though such a result may be customer desired.
+ *
+ * Perhaps a https://github.com/microsoft/TypeScript/issues/22677 fix will
+ * enable better support.
+ *
+ * @example Typical usage
+ *
+ * ```typescript
+ * function foo<T>(value: JsonSerializable<T>) { ... }
+ * ```
+ *
+ * @privateRemarks
+ * Upon recursion, the original type T is preserved intact. This is done to prevent
+ * infinite recursion and produces a technically incorrect result type. However, with
+ * proper use, that will never be an issue as any filtering of types will happen
+ * before T recursion.
+ *
+ * @alpha
+ */
+export type JsonSerializable<T, Options extends JsonSerializableOptions = {
+    AllowExactly: never;
+    AllowExtensionOf: never;
+}> = InternalUtilityTypes.JsonSerializableImpl<T, Options>;
+//# sourceMappingURL=jsonSerializable.d.ts.map

package/dist/core-interfaces/jsonSerializable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonSerializable.d.ts","sourceRoot":"","sources":["../../src/core-interfaces/jsonSerializable.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACvC;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;;;;OAKG;IACH,yBAAyB,CAAC,EAAE,6BAA6B,CAAC;CAC1D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AACH,MAAM,MAAM,gBAAgB,CAC3B,CAAC,EACD,OAAO,SAAS,uBAAuB,GAAG;IACzC,YAAY,EAAE,KAAK,CAAC;IACpB,gBAAgB,EAAE,KAAK,CAAC;CACxB,IACE,oBAAoB,CAAC,oBAAoB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC"}

package/dist/core-interfaces/jsonSerializable.js

@@ -0,0 +1,7 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=jsonSerializable.js.map

package/dist/core-interfaces/jsonSerializable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonSerializable.js","sourceRoot":"","sources":["../../src/core-interfaces/jsonSerializable.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { InternalUtilityTypes } from \"./exposedUtilityTypes.js\";\n\n/**\n * Options for {@link JsonSerializable}.\n *\n * @alpha\n */\nexport interface JsonSerializableOptions {\n\t/**\n\t * Exact types that are managed by custom serialization logic (beyond\n\t * {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify|JSON.stringify}\n\t * without a replacer). Only exact types matching specification will be\n\t * preserved unaltered.\n\t *\n\t * The default value is `never`.\n\t */\n\tAllowExactly?: unknown;\n\n\t/**\n\t * General types that are managed by custom serialization logic (beyond\n\t * {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify|JSON.stringify}\n\t * without a replacer). Any type satisfying specification will be preserved\n\t * unaltered.\n\t *\n\t * The default value is `never`.\n\t */\n\tAllowExtensionOf?: unknown;\n\n\t/**\n\t * When set, inaccessible (protected and private) members throughout type T are\n\t * ignored as if not present.\n\t *\n\t * The default value is not present.\n\t */\n\tIgnoreInaccessibleMembers?: \"ignore-inaccessible-members\";\n}\n\n/**\n * Used to constrain a type `T` to types that are serializable as JSON\n * using {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify|JSON.stringify}\n * (without a replacer) as base model.\n *\n * Under typical use a compile-time error is produced if `T` contains\n * non-JsonSerializable members.\n *\n * @typeParam T - The type to be constrained.\n * @typeParam Options - Options for the filter. See {@link JsonSerializableOptions}.\n *\n * @remarks\n * Before adding use of this utility type, consider using a utility like\n * {@link https://github.com/sinclairzx81/typebox#readme | TypeBox} that allows\n * for runtime validation.\n *\n * Note that this does NOT prevent use of values with non-JSON compatible data,\n * it only prevents using values with types that include non-JSON compatible data.\n * This means that one can, for example, pass in a value typed with JSON compatible\n * interface into this filter, that could actually be a class with lots on non-JSON\n * compatible fields and methods.\n *\n * Important: `T extends JsonSerializable<T>` is incorrect (does not even compile).\n *\n * The optional `Options.Allow*` parameters may be used to permit additional leaf types\n * to support situations where a `replacer` is used to handle special values (e.g.,\n * `JsonSerializable<{ x: IFluidHandle }, { AllowExtensionOf: IFluidHandle }>`).\n *\n * Note that `JsonSerializable<T>` does not protect against the following pitfalls\n * when serializing with JSON.stringify():\n *\n * - Non-finite numbers (`NaN`, `+/-Infinity`) are coerced to `null`.\n *\n * - Prototypes and non-enumerable properties are lost.\n *\n * - `ArrayLike` types that are not arrays and are serialized as `{ length: number }`.\n *\n * - Getter and setters properties are lost. (Though appear supported.)\n *\n * - Functions with properties may be absent or the properties may be perserved\n * depending on the runtime typo of the value. (If built via Object.assign the\n * target member's type is preserved.) typeof =\\> 'function' is lost whereas when\n * typeof =\\> 'object' the properties are preserved.\n *\n * - Sparse arrays are filled with `null`.\n *\n * Also, `JsonSerializable<T>` does not prevent the construction of circular references.\n *\n * Specifying `JsonSerializable<unknown>` or `JsonSerializable<any>` yields a type\n * alias for {@link JsonTypeWith}`<never>` and should not be used if precise type\n * safety is desired.\n *\n * Class instances are indistinguishable from general objects by type checking\n * unless they have non-public members.\n * Unless `Option.IgnoreInaccessibleMembers` is used, types with non-public\n * members will result in {@link SerializationErrorPerNonPublicProperties}.\n * When `Option.IgnoreInaccessibleMembers` is `ignore-inaccessible-members`,\n * non-public (non-function) members are preserved without error, but they are\n * filtered away by the type filters and thus produce an incorrectly narrowed\n * type compared to actual data. Though such a result may be customer desired.\n *\n * Perhaps a https://github.com/microsoft/TypeScript/issues/22677 fix will\n * enable better support.\n *\n * @example Typical usage\n *\n * ```typescript\n * function foo<T>(value: JsonSerializable<T>) { ... }\n * ```\n *\n * @privateRemarks\n * Upon recursion, the original type T is preserved intact. This is done to prevent\n * infinite recursion and produces a technically incorrect result type. However, with\n * proper use, that will never be an issue as any filtering of types will happen\n * before T recursion.\n *\n * @alpha\n */\nexport type JsonSerializable<\n\tT,\n\tOptions extends JsonSerializableOptions = {\n\t\tAllowExactly: never;\n\t\tAllowExtensionOf: never;\n\t},\n> = InternalUtilityTypes.JsonSerializableImpl<T, Options>;\n"]}

package/dist/core-interfaces/jsonSerializationErrors.d.ts

@@ -0,0 +1,31 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Type resulting from {@link JsonSerializable} use given an array with
+ * `undefined` elements.
+ *
+ * @privateRemarks type is used over interface; so inspection of type
+ * result can be more informative than just the type name.
+ *
+ * @alpha
+ * @system
+ */
+export type SerializationErrorPerUndefinedArrayElement = {
+    "array serialization error": "undefined elements are not supported";
+};
+/**
+ * Type resulting from {@link JsonSerializable} use given a class with
+ * non-public properties.
+ *
+ * @privateRemarks type is used over interface; so inspection of type
+ * result can be more informative than just the type name.
+ *
+ * @alpha
+ * @system
+ */
+export type SerializationErrorPerNonPublicProperties = {
+    "object serialization error": "non-public properties are not supported";
+};
+//# sourceMappingURL=jsonSerializationErrors.d.ts.map

package/dist/core-interfaces/jsonSerializationErrors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonSerializationErrors.d.ts","sourceRoot":"","sources":["../../src/core-interfaces/jsonSerializationErrors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;GASG;AAEH,MAAM,MAAM,0CAA0C,GAAG;IACxD,2BAA2B,EAAE,sCAAsC,CAAC;CACpE,CAAC;AAEF;;;;;;;;;GASG;AAEH,MAAM,MAAM,wCAAwC,GAAG;IACtD,4BAA4B,EAAE,yCAAyC,CAAC;CACxE,CAAC"}

package/dist/core-interfaces/jsonSerializationErrors.js

@@ -0,0 +1,7 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=jsonSerializationErrors.js.map

package/dist/core-interfaces/jsonSerializationErrors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonSerializationErrors.js","sourceRoot":"","sources":["../../src/core-interfaces/jsonSerializationErrors.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Type resulting from {@link JsonSerializable} use given an array with\n * `undefined` elements.\n *\n * @privateRemarks type is used over interface; so inspection of type\n * result can be more informative than just the type name.\n *\n * @alpha\n * @system\n */\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\nexport type SerializationErrorPerUndefinedArrayElement = {\n\t\"array serialization error\": \"undefined elements are not supported\";\n};\n\n/**\n * Type resulting from {@link JsonSerializable} use given a class with\n * non-public properties.\n *\n * @privateRemarks type is used over interface; so inspection of type\n * result can be more informative than just the type name.\n *\n * @alpha\n * @system\n */\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\nexport type SerializationErrorPerNonPublicProperties = {\n\t\"object serialization error\": \"non-public properties are not supported\";\n};\n"]}

package/dist/core-interfaces/jsonType.d.ts

@@ -0,0 +1,29 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Type constraint for types that are likely encodable as JSON, deserializable from JSON,
+ * or have a custom alternate type.
+ *
+ * @remarks
+ * Use `JsonTypeWith<never>` for just JSON encodable/deserializable types.
+ * See {@link JsonSerializable} for encoding pitfalls.
+ *
+ * @privateRemarks
+ * Prefer using `JsonSerializable<unknown>` or `JsonDeserialized<unknown>` over this type that
+ * is an implementation detail.
+ * @alpha
+ */
+export type JsonTypeWith<T> = null | boolean | number | string | T | {
+    [key: string | number]: JsonTypeWith<T>;
+} | JsonTypeWith<T>[];
+/**
+ * Portion of {@link JsonTypeWith} that is an object (including array) and not null.
+ *
+ * @alpha
+ */
+export type NonNullJsonObjectWith<T> = {
+    [key: string | number]: JsonTypeWith<T>;
+} | JsonTypeWith<T>[];
+//# sourceMappingURL=jsonType.d.ts.map

package/dist/core-interfaces/jsonType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonType.d.ts","sourceRoot":"","sources":["../../src/core-interfaces/jsonType.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAEvB,IAAI,GACJ,OAAO,GACP,MAAM,GACN,MAAM,GACN,CAAC,GACD;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAA;CAAE,GAC3C,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC;AAErB;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,CAAC,CAAC,IAChC;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAA;CAAE,GAC3C,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC"}

package/dist/core-interfaces/jsonType.js

@@ -0,0 +1,7 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=jsonType.js.map

package/dist/core-interfaces/jsonType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonType.js","sourceRoot":"","sources":["../../src/core-interfaces/jsonType.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Type constraint for types that are likely encodable as JSON, deserializable from JSON,\n * or have a custom alternate type.\n *\n * @remarks\n * Use `JsonTypeWith<never>` for just JSON encodable/deserializable types.\n * See {@link JsonSerializable} for encoding pitfalls.\n *\n * @privateRemarks\n * Prefer using `JsonSerializable<unknown>` or `JsonDeserialized<unknown>` over this type that\n * is an implementation detail.\n * @alpha\n */\nexport type JsonTypeWith<T> =\n\t// eslint-disable-next-line @rushstack/no-new-null\n\t| null\n\t| boolean\n\t| number\n\t| string\n\t| T\n\t| { [key: string | number]: JsonTypeWith<T> }\n\t| JsonTypeWith<T>[];\n\n/**\n * Portion of {@link JsonTypeWith} that is an object (including array) and not null.\n *\n * @alpha\n */\nexport type NonNullJsonObjectWith<T> =\n\t| { [key: string | number]: JsonTypeWith<T> }\n\t| JsonTypeWith<T>[];\n"]}

package/dist/datastorePresenceManagerFactory.d.ts

@@ -0,0 +1,48 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import type { IFluidLoadable } from "@fluidframework/core-interfaces";
+import type { SharedObjectKind } from "@fluidframework/shared-object-base";
+import type { IPresence } from "./presence.js";
+/**
+ * Brand for Experimental Presence Data Object.
+ *
+ * @remarks
+ * See {@link acquirePresenceViaDataObject} for example usage.
+ *
+ * @sealed
+ * @alpha
+ */
+export declare class ExperimentalPresenceDO {
+    private readonly _self;
+}
+/**
+ * DataStore based Presence Manager that is used as fallback for preferred Container
+ * Extension based version requires registration. Export SharedObjectKind for registration.
+ *
+ * @alpha
+ */
+export declare const ExperimentalPresenceManager: SharedObjectKind<IFluidLoadable & ExperimentalPresenceDO>;
+/**
+ * Acquire IPresence from a DataStore based Presence Manager
+ *
+ * @example
+ * ```typescript
+ * const containerSchema = {
+ * 	initialObjects: {
+ * 		experimentalPresence: ExperimentalPresenceDO,
+ * 	},
+ * } satisfies ContainerSchema;
+ * ```
+ * then
+ * ```typescript
+ * const presence = acquirePresenceViaDataObject(
+ * 	container.initialObjects.experimentalPresence,
+ * 	);
+ * ```
+ *
+ * @alpha
+ */
+export declare function acquirePresenceViaDataObject(fluidLoadable: ExperimentalPresenceDO): IPresence;
+//# sourceMappingURL=datastorePresenceManagerFactory.d.ts.map

package/dist/datastorePresenceManagerFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datastorePresenceManagerFactory.d.ts","sourceRoot":"","sources":["../src/datastorePresenceManagerFactory.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAGtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAG3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAkD/C;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,OAAO,sBAAsB;IAC1C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAyB;CAC/C;AAED;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,2DAGtC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,4BAA4B,CAC3C,aAAa,EAAE,sBAAsB,GACnC,SAAS,CAMX"}

package/dist/datastorePresenceManagerFactory.js

@@ -0,0 +1,79 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acquirePresenceViaDataObject = exports.ExperimentalPresenceManager = void 0;
+const internal_1 = require("@fluidframework/core-utils/internal");
+const datastoreSupport_js_1 = require("./datastoreSupport.js");
+const presenceManager_js_1 = require("./presenceManager.js");
+function assertSignalMessageIsValid(message) {
+    (0, internal_1.assert)(message.clientId !== null, 0xa58 /* Signal must have a client ID */);
+    // The other difference between messages is that `content` for
+    // IExtensionMessage is JsonDeserialized and we are fine assuming that.
+}
+/**
+ * Simple FluidObject holding Presence Manager.
+ */
+class PresenceManagerDataObject extends datastoreSupport_js_1.LoadableFluidObject {
+    presenceManager() {
+        if (!this._presenceManager) {
+            // TODO: investigate if ContainerExtensionStore (path-based address routing for
+            // Signals) is readily detectable here and use that presence manager directly.
+            const manager = (0, presenceManager_js_1.createPresenceManager)(this.runtime);
+            this.runtime.on("signal", (message, local) => {
+                assertSignalMessageIsValid(message);
+                manager.processSignal("", message, local);
+            });
+            this._presenceManager = manager;
+        }
+        return this._presenceManager;
+    }
+}
+/**
+ * Factory class to create {@link IPresence} in own data store.
+ */
+class PresenceManagerFactory {
+    constructor() {
+        this.factory = new datastoreSupport_js_1.BasicDataStoreFactory("@fluidframework/presence", PresenceManagerDataObject);
+    }
+    is(value) {
+        return value instanceof PresenceManagerDataObject;
+    }
+}
+/**
+ * DataStore based Presence Manager that is used as fallback for preferred Container
+ * Extension based version requires registration. Export SharedObjectKind for registration.
+ *
+ * @alpha
+ */
+exports.ExperimentalPresenceManager = new PresenceManagerFactory();
+/**
+ * Acquire IPresence from a DataStore based Presence Manager
+ *
+ * @example
+ * ```typescript
+ * const containerSchema = {
+ * 	initialObjects: {
+ * 		experimentalPresence: ExperimentalPresenceDO,
+ * 	},
+ * } satisfies ContainerSchema;
+ * ```
+ * then
+ * ```typescript
+ * const presence = acquirePresenceViaDataObject(
+ * 	container.initialObjects.experimentalPresence,
+ * 	);
+ * ```
+ *
+ * @alpha
+ */
+function acquirePresenceViaDataObject(fluidLoadable) {
+    if (fluidLoadable instanceof PresenceManagerDataObject) {
+        return fluidLoadable.presenceManager();
+    }
+    throw new Error("Incompatible loadable; make sure to use ExperimentalPresenceManager");
+}
+exports.acquirePresenceViaDataObject = acquirePresenceViaDataObject;
+//# sourceMappingURL=datastorePresenceManagerFactory.js.map

package/dist/datastorePresenceManagerFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"datastorePresenceManagerFactory.js","sourceRoot":"","sources":["../src/datastorePresenceManagerFactory.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAOH,kEAA6D;AAI7D,+DAAmF;AAEnF,6DAA6D;AAI7D,SAAS,0BAA0B,CAClC,OAAkD;IAElD,IAAA,iBAAM,EAAC,OAAO,CAAC,QAAQ,KAAK,IAAI,EAAE,KAAK,CAAC,kCAAkC,CAAC,CAAC;IAC5E,8DAA8D;IAC9D,uEAAuE;AACxE,CAAC;AAED;;GAEG;AACH,MAAM,yBAA0B,SAAQ,yCAAmB;IAKnD,eAAe;QACrB,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC5B,+EAA+E;YAC/E,8EAA8E;YAC9E,MAAM,OAAO,GAAG,IAAA,0CAAqB,EAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACpD,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,OAA8B,EAAE,KAAc,EAAE,EAAE;gBAC5E,0BAA0B,CAAC,OAAO,CAAC,CAAC;gBACpC,OAAO,CAAC,aAAa,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;YAC3C,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC;QACjC,CAAC;QACD,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC9B,CAAC;CACD;AAED;;GAEG;AACH,MAAM,sBAAsB;IAA5B;QAKiB,YAAO,GAAG,IAAI,2CAAqB,CAClD,0BAA0B,EAC1B,yBAAyB,CACzB,CAAC;IACH,CAAC;IARO,EAAE,CAAC,KAA8C;QACvD,OAAO,KAAK,YAAY,yBAAyB,CAAC;IACnD,CAAC;CAMD;AAeD;;;;;GAKG;AACU,QAAA,2BAA2B,GACvC,IAAI,sBAAsB,EAEzB,CAAC;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,4BAA4B,CAC3C,aAAqC;IAErC,IAAI,aAAa,YAAY,yBAAyB,EAAE,CAAC;QACxD,OAAO,aAAa,CAAC,eAAe,EAAE,CAAC;IACxC,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;AACxF,CAAC;AARD,oEAQC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/*\n * Hacky support for internal datastore based usages.\n */\n\nimport type { IFluidLoadable } from \"@fluidframework/core-interfaces\";\nimport { assert } from \"@fluidframework/core-utils/internal\";\nimport type { IInboundSignalMessage } from \"@fluidframework/runtime-definitions/internal\";\nimport type { SharedObjectKind } from \"@fluidframework/shared-object-base\";\n\nimport { BasicDataStoreFactory, LoadableFluidObject } from \"./datastoreSupport.js\";\nimport type { IPresence } from \"./presence.js\";\nimport { createPresenceManager } from \"./presenceManager.js\";\n\nimport type { IExtensionMessage } from \"@fluidframework/presence/internal/container-definitions/internal\";\n\nfunction assertSignalMessageIsValid(\n\tmessage: IInboundSignalMessage | IExtensionMessage,\n): asserts message is IExtensionMessage {\n\tassert(message.clientId !== null, 0xa58 /* Signal must have a client ID */);\n\t// The other difference between messages is that `content` for\n\t// IExtensionMessage is JsonDeserialized and we are fine assuming that.\n}\n\n/**\n * Simple FluidObject holding Presence Manager.\n */\nclass PresenceManagerDataObject extends LoadableFluidObject {\n\t// Creation of presence manager is deferred until first acquisition to avoid\n\t// instantiations and stand-up by Summarizer that has no actual use.\n\tprivate _presenceManager: IPresence | undefined;\n\n\tpublic presenceManager(): IPresence {\n\t\tif (!this._presenceManager) {\n\t\t\t// TODO: investigate if ContainerExtensionStore (path-based address routing for\n\t\t\t// Signals) is readily detectable here and use that presence manager directly.\n\t\t\tconst manager = createPresenceManager(this.runtime);\n\t\t\tthis.runtime.on(\"signal\", (message: IInboundSignalMessage, local: boolean) => {\n\t\t\t\tassertSignalMessageIsValid(message);\n\t\t\t\tmanager.processSignal(\"\", message, local);\n\t\t\t});\n\t\t\tthis._presenceManager = manager;\n\t\t}\n\t\treturn this._presenceManager;\n\t}\n}\n\n/**\n * Factory class to create {@link IPresence} in own data store.\n */\nclass PresenceManagerFactory {\n\tpublic is(value: IFluidLoadable | ExperimentalPresenceDO): value is ExperimentalPresenceDO {\n\t\treturn value instanceof PresenceManagerDataObject;\n\t}\n\n\tpublic readonly factory = new BasicDataStoreFactory(\n\t\t\"@fluidframework/presence\",\n\t\tPresenceManagerDataObject,\n\t);\n}\n\n/**\n * Brand for Experimental Presence Data Object.\n *\n * @remarks\n * See {@link acquirePresenceViaDataObject} for example usage.\n *\n * @sealed\n * @alpha\n */\nexport declare class ExperimentalPresenceDO {\n\tprivate readonly _self: ExperimentalPresenceDO;\n}\n\n/**\n * DataStore based Presence Manager that is used as fallback for preferred Container\n * Extension based version requires registration. Export SharedObjectKind for registration.\n *\n * @alpha\n */\nexport const ExperimentalPresenceManager =\n\tnew PresenceManagerFactory() as unknown as SharedObjectKind<\n\t\tIFluidLoadable & ExperimentalPresenceDO\n\t>;\n\n/**\n * Acquire IPresence from a DataStore based Presence Manager\n *\n * @example\n * ```typescript\n * const containerSchema = {\n * \tinitialObjects: {\n * \t\texperimentalPresence: ExperimentalPresenceDO,\n * \t},\n * } satisfies ContainerSchema;\n * ```\n * then\n * ```typescript\n * const presence = acquirePresenceViaDataObject(\n * \tcontainer.initialObjects.experimentalPresence,\n * \t);\n * ```\n *\n * @alpha\n */\nexport function acquirePresenceViaDataObject(\n\tfluidLoadable: ExperimentalPresenceDO,\n): IPresence {\n\tif (fluidLoadable instanceof PresenceManagerDataObject) {\n\t\treturn fluidLoadable.presenceManager();\n\t}\n\n\tthrow new Error(\"Incompatible loadable; make sure to use ExperimentalPresenceManager\");\n}\n"]}

package/dist/datastoreSupport.d.ts

@@ -0,0 +1,31 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import type { FluidObject, IFluidLoadable } from "@fluidframework/core-interfaces";
+import type { IFluidHandleInternal } from "@fluidframework/core-interfaces/internal";
+import { FluidDataStoreRuntime } from "@fluidframework/datastore/internal";
+import type { IFluidDataStoreContext, IFluidDataStoreFactory } from "@fluidframework/runtime-definitions/internal";
+/**
+ * @internal
+ */
+export declare class BasicDataStoreFactory<Type extends string> implements IFluidDataStoreFactory {
+    readonly type: Type;
+    private readonly instanceCtor;
+    get IFluidDataStoreFactory(): IFluidDataStoreFactory;
+    constructor(type: Type, instanceCtor: new (runtime: FluidDataStoreRuntime) => LoadableFluidObject);
+    instantiateDataStore(context: IFluidDataStoreContext, existing: boolean): Promise<FluidDataStoreRuntime>;
+}
+/**
+ * @internal
+ */
+export declare abstract class LoadableFluidObject implements FluidObject, IFluidLoadable {
+    protected readonly runtime: FluidDataStoreRuntime;
+    constructor(runtime: FluidDataStoreRuntime);
+    get IFluidLoadable(): this;
+    /**
+     * Handle to the this Fluid object.
+     */
+    get handle(): IFluidHandleInternal<FluidObject>;
+}
+//# sourceMappingURL=datastoreSupport.d.ts.map

package/dist/datastoreSupport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datastoreSupport.d.ts","sourceRoot":"","sources":["../src/datastoreSupport.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACX,WAAW,EACX,cAAc,EAGd,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAErF,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,KAAK,EACX,sBAAsB,EACtB,sBAAsB,EACtB,MAAM,8CAA8C,CAAC;AA+BtD;;GAEG;AACH,qBAAa,qBAAqB,CAAC,IAAI,SAAS,MAAM,CAAE,YAAW,sBAAsB;aAMvE,IAAI,EAAE,IAAI;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAN9B,IAAW,sBAAsB,IAAI,sBAAsB,CAE1D;gBAGgB,IAAI,EAAE,IAAI,EACT,YAAY,EAAE,KAAK,OAAO,EAAE,qBAAqB,KAAK,mBAAmB;IAG9E,oBAAoB,CAChC,OAAO,EAAE,sBAAsB,EAC/B,QAAQ,EAAE,OAAO,GACf,OAAO,CAAC,qBAAqB,CAAC;CAiBjC;AAED;;GAEG;AACH,8BAAsB,mBAAoB,YAAW,WAAW,EAAE,cAAc;IAC5D,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,qBAAqB;gBAA9B,OAAO,EAAE,qBAAqB;IAEpE,IAAW,cAAc,IAAI,IAAI,CAEhC;IAED;;OAEG;IACH,IAAW,MAAM,IAAI,oBAAoB,CAAC,WAAW,CAAC,CAMrD;CACD"}

package/dist/datastoreSupport.js

@@ -0,0 +1,82 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadableFluidObject = exports.BasicDataStoreFactory = void 0;
+const internal_1 = require("@fluidframework/core-utils/internal");
+const internal_2 = require("@fluidframework/datastore/internal");
+const internal_3 = require("@fluidframework/runtime-utils/internal");
+/**
+ * Extends the FluidDataStoreRuntime to provide a request method that routes requests to
+ * the entrypoint Fluid object that is expected to be a {@link LoadableFluidObject}.
+ */
+class BasicFluidDataStoreRuntime extends internal_2.FluidDataStoreRuntime {
+    async request(request) {
+        const response = await super.request(request);
+        if (response.status !== 404) {
+            return response;
+        }
+        // Return entrypoint object if someone requests it directly.
+        // Direct requests exist from two scenarios:
+        //   1. the request url is a "/"
+        //   2. the request url is empty
+        if (request.url === "" || request.url === "/" || request.url.startsWith("/?")) {
+            // The provideEntryPoint callback below always returns an instance of
+            // LoadableFluidObject. Make sure that is the case.
+            const dataObject = await this.entryPoint.get();
+            (0, internal_1.assert)(dataObject instanceof LoadableFluidObject, 0xa36 /* Data store runtime entryPoint is not expected type */);
+            return { mimeType: "fluid/object", status: 200, value: dataObject };
+        }
+        return (0, internal_3.create404Response)(request);
+    }
+}
+/**
+ * @internal
+ */
+class BasicDataStoreFactory {
+    get IFluidDataStoreFactory() {
+        return this;
+    }
+    constructor(type, instanceCtor) {
+        this.type = type;
+        this.instanceCtor = instanceCtor;
+    }
+    async instantiateDataStore(context, existing) {
+        // Create a new runtime for our data store.
+        // The runtime is what Fluid uses to route to our data store.
+        const runtime = new BasicFluidDataStoreRuntime(context, 
+        /* ISharedObjectRegistry */ new Map(), existing, 
+        /* provideEntryPoint */ async () => {
+            (0, internal_1.assert)(instance !== undefined, 0xa37 /* Intended entryPoint is undefined */);
+            return instance;
+        });
+        const instance = new this.instanceCtor(runtime);
+        return runtime;
+    }
+}
+exports.BasicDataStoreFactory = BasicDataStoreFactory;
+/**
+ * @internal
+ */
+class LoadableFluidObject {
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    get IFluidLoadable() {
+        return this;
+    }
+    /**
+     * Handle to the this Fluid object.
+     */
+    get handle() {
+        // BasicDataStoreFactory provides an entryPoint initialization function
+        // to the data store runtime; so, this object should always have access to a
+        // non-null entryPoint.
+        (0, internal_1.assert)(this.runtime.entryPoint !== undefined, 0xa38 /* EntryPoint was undefined */);
+        return this.runtime.entryPoint;
+    }
+}
+exports.LoadableFluidObject = LoadableFluidObject;
+//# sourceMappingURL=datastoreSupport.js.map