@fluidframework/datastore-definitions 1.2.0-77818 → 1.2.1

package/dist/jsonable.d.ts

@@ -3,28 +3,39 @@
  * Licensed under the MIT License.
  */
 /**
- * Used to constrain a type `T` to types that are serializable as JSON.  Produces a
- * compile-time error if `T` contains non-Jsonable members.
+ * Used to constrain a type `T` to types that are serializable as JSON.
+ * Produces a compile-time error if `T` contains non-Jsonable members.
  *
- * Typical usage:
- * ```ts
- *      function foo<T>(value: Jsonable<T>) { ... }
- * ```
+ * @remarks
+ * Note that this does NOT prevent using 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 an a value typed with json compatible
+ * interface into this function,
+ * that could actually be a class with lots on non-json compatible fields and methods.
  *
- * Important: `T extends Jsonable<T>` is generally incorrect. (Any value of `T`
- *            extends the JSON serializable subset of itself.)
+ * Important: `T extends Jsonable<T>` is incorrect (does not even compile).
+ * `T extends Jsonable` is also incorrect since `Jsonable` is just `any` and thus applies no constraint at all.
  *
  * The optional 'TReplaced' parameter may be used to permit additional leaf types to support
  * situations where a `replacer` is used to handle special values (e.g., `Jsonable<{ x: IFluidHandle }, IFluidHandle>`).
  *
- * Note that `Jsonable<T>` does not protect against the following pitfalls when serializing
- * `undefined` and non-finite numbers:
+ * Note that `Jsonable<T>` does not protect against the following pitfalls when serializing with JSON.stringify():
  *
  *  - `undefined` properties on objects are omitted (i.e., properties become undefined instead of equal to undefined).
  *  - When `undefined` appears as the root object or as an array element it is coerced to `null`.
  *  - Non-finite numbers (`NaN`, `+/-Infinity`) are also coerced to `null`.
+ *  - prototypes and non-enumerable properties are lost.
  *
  * Also, `Jsonable<T>` does not prevent the construction of circular references.
+ *
+ * Using `Jsonable` (with no type parameters) or `Jsonable<any>` is just a type alias for `any`
+ * and should not be used if type safety is desired.
+ *
+ * @example
+ * Typical usage:
+ * ```ts
+ *      function foo<T>(value: Jsonable<T>) { ... }
+ * ```
  */
 export declare type Jsonable<T = any, TReplaced = void> = T extends undefined | null | boolean | number | string | TReplaced ? T : Extract<T, Function> extends never ? {
     [K in keyof T]: Extract<K, symbol> extends never ? Jsonable<T[K], TReplaced> : never;

package/dist/jsonable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsonable.d.ts","sourceRoot":"","sources":["../src/jsonable.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,oBAAY,QAAQ,CAAC,CAAC,GAAG,GAAG,EAAE,SAAS,GAAG,IAAI,IAC1C,CAAC,SAAS,SAAS,GAAG,IAAI,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,GAC5D,CAAC,GAED,OAAO,CAAC,CAAC,EAAE,QAAQ,CAAC,SAAS,KAAK,GAC9B;KACG,CAAC,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,SAAS,KAAK,GAC1C,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,GACzB,KAAK;CACd,GACC,KAAK,CAAC"}
+{"version":3,"file":"jsonable.d.ts","sourceRoot":"","sources":["../src/jsonable.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,oBAAY,QAAQ,CAAC,CAAC,GAAG,GAAG,EAAE,SAAS,GAAG,IAAI,IAC1C,CAAC,SAAS,SAAS,GAAG,IAAI,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,GAC5D,CAAC,GAED,OAAO,CAAC,CAAC,EAAE,QAAQ,CAAC,SAAS,KAAK,GAC9B;KACG,CAAC,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,SAAS,KAAK,GAC1C,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,GACzB,KAAK;CACd,GACC,KAAK,CAAC"}

package/dist/jsonable.js.map

@@ -1 +1 @@
-{"version":3,"file":"jsonable.js","sourceRoot":"","sources":["../src/jsonable.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 * Used to constrain a type `T` to types that are serializable as JSON.  Produces a\n * compile-time error if `T` contains non-Jsonable members.\n *\n * Typical usage:\n * ```ts\n *      function foo<T>(value: Jsonable<T>) { ... }\n * ```\n *\n * Important: `T extends Jsonable<T>` is generally incorrect. (Any value of `T`\n *            extends the JSON serializable subset of itself.)\n *\n * The optional 'TReplaced' parameter may be used to permit additional leaf types to support\n * situations where a `replacer` is used to handle special values (e.g., `Jsonable<{ x: IFluidHandle }, IFluidHandle>`).\n *\n * Note that `Jsonable<T>` does not protect against the following pitfalls when serializing\n * `undefined` and non-finite numbers:\n *\n *  - `undefined` properties on objects are omitted (i.e., properties become undefined instead of equal to undefined).\n *  - When `undefined` appears as the root object or as an array element it is coerced to `null`.\n *  - Non-finite numbers (`NaN`, `+/-Infinity`) are also coerced to `null`.\n *\n * Also, `Jsonable<T>` does not prevent the construction of circular references.\n */\nexport type Jsonable<T = any, TReplaced = void> =\n    T extends undefined | null | boolean | number | string | TReplaced\n        ? T\n        // eslint-disable-next-line @typescript-eslint/ban-types\n        : Extract<T, Function> extends never\n            ? {\n                [K in keyof T]: Extract<K, symbol> extends never\n                    ? Jsonable<T[K], TReplaced>\n                    : never\n            }\n            : never;\n"]}
+{"version":3,"file":"jsonable.js","sourceRoot":"","sources":["../src/jsonable.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 * Used to constrain a type `T` to types that are serializable as JSON.\n * Produces a compile-time error if `T` contains non-Jsonable members.\n *\n * @remarks\n * Note that this does NOT prevent using 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 an a value typed with json compatible\n * interface into this function,\n * that could actually be a class with lots on non-json compatible fields and methods.\n *\n * Important: `T extends Jsonable<T>` is incorrect (does not even compile).\n * `T extends Jsonable` is also incorrect since `Jsonable` is just `any` and thus applies no constraint at all.\n *\n * The optional 'TReplaced' parameter may be used to permit additional leaf types to support\n * situations where a `replacer` is used to handle special values (e.g., `Jsonable<{ x: IFluidHandle }, IFluidHandle>`).\n *\n * Note that `Jsonable<T>` does not protect against the following pitfalls when serializing with JSON.stringify():\n *\n *  - `undefined` properties on objects are omitted (i.e., properties become undefined instead of equal to undefined).\n *  - When `undefined` appears as the root object or as an array element it is coerced to `null`.\n *  - Non-finite numbers (`NaN`, `+/-Infinity`) are also coerced to `null`.\n *  - prototypes and non-enumerable properties are lost.\n *\n * Also, `Jsonable<T>` does not prevent the construction of circular references.\n *\n * Using `Jsonable` (with no type parameters) or `Jsonable<any>` is just a type alias for `any`\n * and should not be used if type safety is desired.\n *\n * @example\n * Typical usage:\n * ```ts\n *      function foo<T>(value: Jsonable<T>) { ... }\n * ```\n */\nexport type Jsonable<T = any, TReplaced = void> =\n    T extends undefined | null | boolean | number | string | TReplaced\n        ? T\n        // eslint-disable-next-line @typescript-eslint/ban-types\n        : Extract<T, Function> extends never\n            ? {\n                [K in keyof T]: Extract<K, symbol> extends never\n                    ? Jsonable<T[K], TReplaced>\n                    : never\n            }\n            : never;\n"]}

package/dist/serializable.d.ts

@@ -8,16 +8,18 @@ import { Jsonable } from "./jsonable";
  * Used to constrain a type 'T' to types that Fluid can intrinsically serialize.  Produces a
  * compile-time error if `T` contains non-serializable members.
  *
+ * @remarks
+ * See Jsonable for caveats regarding serialization of `undefined`, non-finite numbers,
+ * and circular references.
+ *
+ * Important: `T extends Serializable<T>` is generally incorrect.
+ * (Any value of `T` extends the serializable subset of itself.)
+ *
+ * @example
  * Typical usage:
- * ```ts
+ * ```typescript
  *      function serialize<T>(value: Serializable<T>) { ... }
  * ```
- *
- * Important: `T extends Serializable<T>` is generally incorrect. (Any value of `T`
- *            extends the serializable subset of itself.)
- *
- * See Jsonable for caveats regarding serialization of `undefined`, non-finite numbers,
- * and circular references.
  */
 export declare type Serializable<T = any> = Jsonable<T, IFluidHandle>;
 //# sourceMappingURL=serializable.d.ts.map

package/dist/serializable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serializable.d.ts","sourceRoot":"","sources":["../src/serializable.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;;;;;;;;;;;GAcG;AACH,oBAAY,YAAY,CAAC,CAAC,GAAG,GAAG,IAAI,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC"}
+{"version":3,"file":"serializable.d.ts","sourceRoot":"","sources":["../src/serializable.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;;;;;;;;;;;;;GAgBG;AACH,oBAAY,YAAY,CAAC,CAAC,GAAG,GAAG,IAAI,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC"}

package/dist/serializable.js.map

@@ -1 +1 @@
-{"version":3,"file":"serializable.js","sourceRoot":"","sources":["../src/serializable.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 { IFluidHandle } from \"@fluidframework/core-interfaces\";\nimport { Jsonable } from \"./jsonable\";\n\n/**\n * Used to constrain a type 'T' to types that Fluid can intrinsically serialize.  Produces a\n * compile-time error if `T` contains non-serializable members.\n *\n * Typical usage:\n * ```ts\n *      function serialize<T>(value: Serializable<T>) { ... }\n * ```\n *\n * Important: `T extends Serializable<T>` is generally incorrect. (Any value of `T`\n *            extends the serializable subset of itself.)\n *\n * See Jsonable for caveats regarding serialization of `undefined`, non-finite numbers,\n * and circular references.\n */\nexport type Serializable<T = any> = Jsonable<T, IFluidHandle>;\n"]}
+{"version":3,"file":"serializable.js","sourceRoot":"","sources":["../src/serializable.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 { IFluidHandle } from \"@fluidframework/core-interfaces\";\nimport { Jsonable } from \"./jsonable\";\n\n/**\n * Used to constrain a type 'T' to types that Fluid can intrinsically serialize.  Produces a\n * compile-time error if `T` contains non-serializable members.\n *\n * @remarks\n * See Jsonable for caveats regarding serialization of `undefined`, non-finite numbers,\n * and circular references.\n *\n * Important: `T extends Serializable<T>` is generally incorrect.\n * (Any value of `T` extends the serializable subset of itself.)\n *\n * @example\n * Typical usage:\n * ```typescript\n *      function serialize<T>(value: Serializable<T>) { ... }\n * ```\n */\nexport type Serializable<T = any> = Jsonable<T, IFluidHandle>;\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluidframework/datastore-definitions",
-  "version": "1.2.0-77818",
+  "version": "1.2.1",
   "description": "Fluid data store definitions",
   "homepage": "https://fluidframework.com",
   "repository": {
@@ -34,15 +34,15 @@
   "dependencies": {
     "@fluidframework/common-definitions": "^0.20.1",
     "@fluidframework/common-utils": "^0.32.1",
-    "@fluidframework/container-definitions": "1.2.0-77818",
-    "@fluidframework/core-interfaces": "1.2.0-77818",
+    "@fluidframework/container-definitions": "^1.2.1",
+    "@fluidframework/core-interfaces": "^1.2.1",
     "@fluidframework/protocol-definitions": "^0.1028.2000",
-    "@fluidframework/runtime-definitions": "1.2.0-77818",
+    "@fluidframework/runtime-definitions": "^1.2.1",
     "@types/node": "^14.18.0"
   },
   "devDependencies": {
     "@fluidframework/build-common": "^0.24.0",
-    "@fluidframework/datastore-definitions-previous": "npm:@fluidframework/datastore-definitions@1.1.0",
+    "@fluidframework/datastore-definitions-previous": "npm:@fluidframework/datastore-definitions@1.2.0",
     "@fluidframework/eslint-config-fluid": "^0.28.2000",
     "@microsoft/api-extractor": "^7.22.2",
     "@rushstack/eslint-config": "^2.5.1",
@@ -54,7 +54,7 @@
     "typescript-formatter": "7.1.0"
   },
   "typeValidation": {
-    "version": "1.2.0",
+    "version": "1.2.1",
     "broken": {}
   }
 }

package/src/jsonable.ts

@@ -4,28 +4,39 @@
  */
 
 /**
- * Used to constrain a type `T` to types that are serializable as JSON.  Produces a
- * compile-time error if `T` contains non-Jsonable members.
+ * Used to constrain a type `T` to types that are serializable as JSON.
+ * Produces a compile-time error if `T` contains non-Jsonable members.
  *
- * Typical usage:
- * ```ts
- *      function foo<T>(value: Jsonable<T>) { ... }
- * ```
+ * @remarks
+ * Note that this does NOT prevent using 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 an a value typed with json compatible
+ * interface into this function,
+ * that could actually be a class with lots on non-json compatible fields and methods.
  *
- * Important: `T extends Jsonable<T>` is generally incorrect. (Any value of `T`
- *            extends the JSON serializable subset of itself.)
+ * Important: `T extends Jsonable<T>` is incorrect (does not even compile).
+ * `T extends Jsonable` is also incorrect since `Jsonable` is just `any` and thus applies no constraint at all.
  *
  * The optional 'TReplaced' parameter may be used to permit additional leaf types to support
  * situations where a `replacer` is used to handle special values (e.g., `Jsonable<{ x: IFluidHandle }, IFluidHandle>`).
  *
- * Note that `Jsonable<T>` does not protect against the following pitfalls when serializing
- * `undefined` and non-finite numbers:
+ * Note that `Jsonable<T>` does not protect against the following pitfalls when serializing with JSON.stringify():
  *
  *  - `undefined` properties on objects are omitted (i.e., properties become undefined instead of equal to undefined).
  *  - When `undefined` appears as the root object or as an array element it is coerced to `null`.
  *  - Non-finite numbers (`NaN`, `+/-Infinity`) are also coerced to `null`.
+ *  - prototypes and non-enumerable properties are lost.
  *
  * Also, `Jsonable<T>` does not prevent the construction of circular references.
+ *
+ * Using `Jsonable` (with no type parameters) or `Jsonable<any>` is just a type alias for `any`
+ * and should not be used if type safety is desired.
+ *
+ * @example
+ * Typical usage:
+ * ```ts
+ *      function foo<T>(value: Jsonable<T>) { ... }
+ * ```
  */
 export type Jsonable<T = any, TReplaced = void> =
     T extends undefined | null | boolean | number | string | TReplaced

package/src/serializable.ts

@@ -10,15 +10,17 @@ import { Jsonable } from "./jsonable";
  * Used to constrain a type 'T' to types that Fluid can intrinsically serialize.  Produces a
  * compile-time error if `T` contains non-serializable members.
  *
+ * @remarks
+ * See Jsonable for caveats regarding serialization of `undefined`, non-finite numbers,
+ * and circular references.
+ *
+ * Important: `T extends Serializable<T>` is generally incorrect.
+ * (Any value of `T` extends the serializable subset of itself.)
+ *
+ * @example
  * Typical usage:
- * ```ts
+ * ```typescript
  *      function serialize<T>(value: Serializable<T>) { ... }
  * ```
- *
- * Important: `T extends Serializable<T>` is generally incorrect. (Any value of `T`
- *            extends the serializable subset of itself.)
- *
- * See Jsonable for caveats regarding serialization of `undefined`, non-finite numbers,
- * and circular references.
  */
 export type Serializable<T = any> = Jsonable<T, IFluidHandle>;