@stryke/json 0.10.0 → 0.12.0

package/dist/pointer/index.mjs

@@ -1,5 +1,5 @@
-import { i as isObjectReference, n as isArrayEnd, r as isArrayReference, t as find } from "../find-reference-woYMiWzN.mjs";
-import { a as isValidIndex, c as unescapePointerSegment, i as isRoot, n as formatJsonPointer, o as parent, r as isInteger, s as parseJsonPointer, t as escapePointerSegment } from "../parse-Crgv3Nl1.mjs";
-import "../pointer-CiTXvh1G.mjs";
+import { i as isObjectReference, n as isArrayEnd, r as isArrayReference, t as find } from "../find-reference-kPgdulJ1.mjs";
+import { a as isValidIndex, c as unescapePointerSegment, i as isRoot, n as formatJsonPointer, o as parent, r as isInteger, s as parseJsonPointer, t as escapePointerSegment } from "../parse-B3NfTO06.mjs";
+import "../pointer-DScQSL_a.mjs";
 
 export { escapePointerSegment, find, formatJsonPointer, isArrayEnd, isArrayReference, isInteger, isObjectReference, isRoot, isValidIndex, parent, parseJsonPointer, unescapePointerSegment };

package/dist/pointer/parse.cjs

@@ -1,4 +1,4 @@
-const require_parse = require('../parse-KiRakdIR.cjs');
+const require_parse = require('../parse-BSmqrTy_.cjs');
 
 exports.escapePointerSegment = require_parse.escapePointerSegment;
 exports.formatJsonPointer = require_parse.formatJsonPointer;

package/dist/pointer/parse.d.cts

@@ -1,2 +1,2 @@
-import { a as isValidIndex, c as unescapePointerSegment, i as isRoot, n as formatJsonPointer, o as parent, r as isInteger, s as parseJsonPointer, t as escapePointerSegment } from "../parse-DZfi3d96.cjs";
+import { a as isValidIndex, c as unescapePointerSegment, i as isRoot, n as formatJsonPointer, o as parent, r as isInteger, s as parseJsonPointer, t as escapePointerSegment } from "../parse-DCHSu_0u.cjs";
 export { escapePointerSegment, formatJsonPointer, isInteger, isRoot, isValidIndex, parent, parseJsonPointer, unescapePointerSegment };

package/dist/pointer/parse.d.mts

@@ -1,2 +1,2 @@
-import { a as isValidIndex, c as unescapePointerSegment, i as isRoot, n as formatJsonPointer, o as parent, r as isInteger, s as parseJsonPointer, t as escapePointerSegment } from "../parse-ZRTh45ZI.mjs";
+import { a as isValidIndex, c as unescapePointerSegment, i as isRoot, n as formatJsonPointer, o as parent, r as isInteger, s as parseJsonPointer, t as escapePointerSegment } from "../parse-DaiwKCLz.mjs";
 export { escapePointerSegment, formatJsonPointer, isInteger, isRoot, isValidIndex, parent, parseJsonPointer, unescapePointerSegment };

package/dist/pointer/parse.mjs

@@ -1,3 +1,3 @@
-import { a as isValidIndex, c as unescapePointerSegment, i as isRoot, n as formatJsonPointer, o as parent, r as isInteger, s as parseJsonPointer, t as escapePointerSegment } from "../parse-Crgv3Nl1.mjs";
+import { a as isValidIndex, c as unescapePointerSegment, i as isRoot, n as formatJsonPointer, o as parent, r as isInteger, s as parseJsonPointer, t as escapePointerSegment } from "../parse-B3NfTO06.mjs";
 
 export { escapePointerSegment, formatJsonPointer, isInteger, isRoot, isValidIndex, parent, parseJsonPointer, unescapePointerSegment };

package/dist/schema-B7wpjw3I.d.mts

@@ -0,0 +1,76 @@
+import { A as JsonSchema7PrimitiveLiteralType, D as JsonSchema7NumberType, I as JsonSchema7StringType, O as JsonSchema7ObjectType, R as JsonSchema7Type, _ as JsonSchema7BooleanType, b as JsonSchema7LiteralType, f as JsonSchema7AllOfType, h as JsonSchema7ArrayType } from "./types-BAtAPir9.mjs";
+import { StandardJSONSchemaV1 } from "@standard-schema/spec";
+
+//#region src/schema.d.ts
+
+/**
+ * Type guard for {@link JsonSchema7AllOfType}
+ *
+ * @param schema - The schema to check
+ * @returns True if the schema is a {@link JsonSchema7AllOfType}, false otherwise
+ */
+declare function isJsonSchema7AllOfType(schema: JsonSchema7Type): schema is JsonSchema7AllOfType;
+/**
+ * Type guard for {@link JsonSchema7ObjectType}
+ *
+ * @param schema - The schema to check
+ * @returns True if the schema is a {@link JsonSchema7ObjectType}, false otherwise
+ */
+declare function isJsonSchema7ObjectType(schema: JsonSchema7Type): schema is JsonSchema7ObjectType;
+/**
+ * Type guard for {@link JsonSchema7StringType}
+ *
+ * @param schema - The schema to check
+ * @returns True if the schema is a {@link JsonSchema7StringType}, false otherwise
+ */
+declare function isJsonSchema7StringType(schema: JsonSchema7Type): schema is JsonSchema7StringType;
+/**
+ * Type guard for {@link JsonSchema7NumberType}
+ *
+ * @param schema - The schema to check
+ * @returns True if the schema is a {@link JsonSchema7NumberType}, false otherwise
+ */
+declare function isJsonSchema7NumberType(schema: JsonSchema7Type): schema is JsonSchema7NumberType;
+/**
+ * Type guard for {@link JsonSchema7BooleanType}
+ *
+ * @param schema - The schema to check
+ * @returns True if the schema is a {@link JsonSchema7BooleanType}, false otherwise
+ */
+declare function isJsonSchema7BooleanType(schema: JsonSchema7Type): schema is JsonSchema7BooleanType;
+/**
+ * Type guard for {@link JsonSchema7ArrayType}
+ *
+ * @param schema - The schema to check
+ * @returns True if the schema is a {@link JsonSchema7ArrayType}, false otherwise
+ */
+declare function isJsonSchema7ArrayType(schema: JsonSchema7Type): schema is JsonSchema7ArrayType;
+/**
+ * Type guard for {@link JsonSchema7PrimitiveLiteralType}
+ *
+ * @param schema - The schema to check
+ * @returns True if the schema is a {@link JsonSchema7PrimitiveLiteralType}, false otherwise
+ */
+declare function isJsonSchema7PrimitiveLiteralType(schema: JsonSchema7Type): schema is JsonSchema7PrimitiveLiteralType;
+/**
+ * Type guard for {@link JsonSchema7LiteralType}
+ *
+ * @param schema - The schema to check
+ * @returns True if the schema is a {@link JsonSchema7LiteralType}, false otherwise
+ */
+declare function isJsonSchema7LiteralType(schema: JsonSchema7Type): schema is JsonSchema7LiteralType;
+/**
+ * Type guard to check if a value is a {@link StandardJSONSchemaV1 | Standard JSON Schema}.
+ *
+ * @remarks
+ * This function checks if the value has the structure of a Standard JSON Schema, which includes a `~standard` property with a `jsonSchema` object that has `input` and `output` functions.
+ *
+ * @see https://standardschema.dev/json-schema
+ *
+ * @param value - The value to check.
+ * @returns True if the value is a {@link StandardJSONSchemaV1 | Standard JSON Schema}, false otherwise.
+ */
+declare function isStandardJsonSchema<Input = unknown, Output = Input>(value: any): value is StandardJSONSchemaV1<Input, Output>;
+//#endregion
+export { isJsonSchema7NumberType as a, isJsonSchema7StringType as c, isJsonSchema7LiteralType as i, isStandardJsonSchema as l, isJsonSchema7ArrayType as n, isJsonSchema7ObjectType as o, isJsonSchema7BooleanType as r, isJsonSchema7PrimitiveLiteralType as s, isJsonSchema7AllOfType as t };
+//# sourceMappingURL=schema-B7wpjw3I.d.mts.map

package/dist/schema-B7wpjw3I.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-B7wpjw3I.d.mts","names":[],"sources":["../src/schema.ts"],"sourcesContent":[],"mappings":";;;;;;;AAuCA;AAgBA;AAgBA;AAYA;AAcgB,iBA1DA,sBAAA,CA2DN,MAAA,EA1DA,eA2DG,CAAA,EAAA,MAAA,IA1DA,oBA0DsB;AAUnC;AAYA;AAwBA;AAyBA;;;AAEwC,iBArHxB,uBAAA,CAqHwB,MAAA,EApH9B,eAoH8B,CAAA,EAAA,MAAA,IAnH3B,qBAmH2B;;;;;;;iBArGxB,uBAAA,SACN,4BACG;;;;;;;iBAUG,uBAAA,SACN,4BACG;;;;;;;iBAYG,wBAAA,SACN,4BACG;;;;;;;iBAUG,sBAAA,SACN,4BACG;;;;;;;iBAUG,iCAAA,SACN,4BACG;;;;;;;iBAsBG,wBAAA,SACN,4BACG;;;;;;;;;;;;iBAuBG,+CAA+C,6BAEnD,qBAAqB,OAAO"}

package/dist/schema-BM7g4xZ3.cjs

@@ -0,0 +1,151 @@
+const require_is_set_object = require('./is-set-object-5lZPw_Pq.cjs');
+
+//#region src/schema.ts
+/**
+* Type guard for {@link JsonSchema7AllOfType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7AllOfType}, false otherwise
+*/
+function isJsonSchema7AllOfType(schema) {
+	if ("type" in schema && schema.type === "string") return false;
+	return "allOf" in schema;
+}
+/**
+* Type guard for {@link JsonSchema7ObjectType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7ObjectType}, false otherwise
+*/
+function isJsonSchema7ObjectType(schema) {
+	if ("type" in schema && schema.type === "object") return false;
+	return "properties" in schema;
+}
+/**
+* Type guard for {@link JsonSchema7StringType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7StringType}, false otherwise
+*/
+function isJsonSchema7StringType(schema) {
+	return "type" in schema && schema.type === "string";
+}
+/**
+* Type guard for {@link JsonSchema7NumberType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7NumberType}, false otherwise
+*/
+function isJsonSchema7NumberType(schema) {
+	return "type" in schema && (schema.type === "number" || schema.type === "integer");
+}
+/**
+* Type guard for {@link JsonSchema7BooleanType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7BooleanType}, false otherwise
+*/
+function isJsonSchema7BooleanType(schema) {
+	return "type" in schema && schema.type === "boolean";
+}
+/**
+* Type guard for {@link JsonSchema7ArrayType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7ArrayType}, false otherwise
+*/
+function isJsonSchema7ArrayType(schema) {
+	return "type" in schema && schema.type === "array" && "items" in schema;
+}
+/**
+* Type guard for {@link JsonSchema7PrimitiveLiteralType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7PrimitiveLiteralType}, false otherwise
+*/
+function isJsonSchema7PrimitiveLiteralType(schema) {
+	if (!("type" in schema)) return false;
+	const { type } = schema;
+	return (type === "string" || type === "number" || type === "integer" || type === "boolean") && "const" in schema;
+}
+/**
+* Type guard for {@link JsonSchema7LiteralType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7LiteralType}, false otherwise
+*/
+function isJsonSchema7LiteralType(schema) {
+	if (isJsonSchema7PrimitiveLiteralType(schema)) return true;
+	if (!("type" in schema)) return false;
+	return schema.type === "object" || schema.type === "array";
+}
+/**
+* Type guard to check if a value is a {@link StandardJSONSchemaV1 | Standard JSON Schema}.
+*
+* @remarks
+* This function checks if the value has the structure of a Standard JSON Schema, which includes a `~standard` property with a `jsonSchema` object that has `input` and `output` functions.
+*
+* @see https://standardschema.dev/json-schema
+*
+* @param value - The value to check.
+* @returns True if the value is a {@link StandardJSONSchemaV1 | Standard JSON Schema}, false otherwise.
+*/
+function isStandardJsonSchema(value) {
+	return require_is_set_object.isSetObject(value) && "~standard" in value && require_is_set_object.isSetObject(value["~standard"]) && "jsonSchema" in value["~standard"] && require_is_set_object.isSetObject(value["~standard"].jsonSchema) && "input" in value["~standard"].jsonSchema && require_is_set_object.isFunction(value["~standard"].jsonSchema.input) && "output" in value["~standard"].jsonSchema && require_is_set_object.isFunction(value["~standard"].jsonSchema.output);
+}
+
+//#endregion
+Object.defineProperty(exports, 'isJsonSchema7AllOfType', {
+  enumerable: true,
+  get: function () {
+    return isJsonSchema7AllOfType;
+  }
+});
+Object.defineProperty(exports, 'isJsonSchema7ArrayType', {
+  enumerable: true,
+  get: function () {
+    return isJsonSchema7ArrayType;
+  }
+});
+Object.defineProperty(exports, 'isJsonSchema7BooleanType', {
+  enumerable: true,
+  get: function () {
+    return isJsonSchema7BooleanType;
+  }
+});
+Object.defineProperty(exports, 'isJsonSchema7LiteralType', {
+  enumerable: true,
+  get: function () {
+    return isJsonSchema7LiteralType;
+  }
+});
+Object.defineProperty(exports, 'isJsonSchema7NumberType', {
+  enumerable: true,
+  get: function () {
+    return isJsonSchema7NumberType;
+  }
+});
+Object.defineProperty(exports, 'isJsonSchema7ObjectType', {
+  enumerable: true,
+  get: function () {
+    return isJsonSchema7ObjectType;
+  }
+});
+Object.defineProperty(exports, 'isJsonSchema7PrimitiveLiteralType', {
+  enumerable: true,
+  get: function () {
+    return isJsonSchema7PrimitiveLiteralType;
+  }
+});
+Object.defineProperty(exports, 'isJsonSchema7StringType', {
+  enumerable: true,
+  get: function () {
+    return isJsonSchema7StringType;
+  }
+});
+Object.defineProperty(exports, 'isStandardJsonSchema', {
+  enumerable: true,
+  get: function () {
+    return isStandardJsonSchema;
+  }
+});

package/dist/schema-BgOm_N0w.d.cts

@@ -0,0 +1,76 @@
+import { A as JsonSchema7PrimitiveLiteralType, D as JsonSchema7NumberType, I as JsonSchema7StringType, O as JsonSchema7ObjectType, R as JsonSchema7Type, _ as JsonSchema7BooleanType, b as JsonSchema7LiteralType, f as JsonSchema7AllOfType, h as JsonSchema7ArrayType } from "./types-BzNIRhpI.cjs";
+import { StandardJSONSchemaV1 } from "@standard-schema/spec";
+
+//#region src/schema.d.ts
+
+/**
+ * Type guard for {@link JsonSchema7AllOfType}
+ *
+ * @param schema - The schema to check
+ * @returns True if the schema is a {@link JsonSchema7AllOfType}, false otherwise
+ */
+declare function isJsonSchema7AllOfType(schema: JsonSchema7Type): schema is JsonSchema7AllOfType;
+/**
+ * Type guard for {@link JsonSchema7ObjectType}
+ *
+ * @param schema - The schema to check
+ * @returns True if the schema is a {@link JsonSchema7ObjectType}, false otherwise
+ */
+declare function isJsonSchema7ObjectType(schema: JsonSchema7Type): schema is JsonSchema7ObjectType;
+/**
+ * Type guard for {@link JsonSchema7StringType}
+ *
+ * @param schema - The schema to check
+ * @returns True if the schema is a {@link JsonSchema7StringType}, false otherwise
+ */
+declare function isJsonSchema7StringType(schema: JsonSchema7Type): schema is JsonSchema7StringType;
+/**
+ * Type guard for {@link JsonSchema7NumberType}
+ *
+ * @param schema - The schema to check
+ * @returns True if the schema is a {@link JsonSchema7NumberType}, false otherwise
+ */
+declare function isJsonSchema7NumberType(schema: JsonSchema7Type): schema is JsonSchema7NumberType;
+/**
+ * Type guard for {@link JsonSchema7BooleanType}
+ *
+ * @param schema - The schema to check
+ * @returns True if the schema is a {@link JsonSchema7BooleanType}, false otherwise
+ */
+declare function isJsonSchema7BooleanType(schema: JsonSchema7Type): schema is JsonSchema7BooleanType;
+/**
+ * Type guard for {@link JsonSchema7ArrayType}
+ *
+ * @param schema - The schema to check
+ * @returns True if the schema is a {@link JsonSchema7ArrayType}, false otherwise
+ */
+declare function isJsonSchema7ArrayType(schema: JsonSchema7Type): schema is JsonSchema7ArrayType;
+/**
+ * Type guard for {@link JsonSchema7PrimitiveLiteralType}
+ *
+ * @param schema - The schema to check
+ * @returns True if the schema is a {@link JsonSchema7PrimitiveLiteralType}, false otherwise
+ */
+declare function isJsonSchema7PrimitiveLiteralType(schema: JsonSchema7Type): schema is JsonSchema7PrimitiveLiteralType;
+/**
+ * Type guard for {@link JsonSchema7LiteralType}
+ *
+ * @param schema - The schema to check
+ * @returns True if the schema is a {@link JsonSchema7LiteralType}, false otherwise
+ */
+declare function isJsonSchema7LiteralType(schema: JsonSchema7Type): schema is JsonSchema7LiteralType;
+/**
+ * Type guard to check if a value is a {@link StandardJSONSchemaV1 | Standard JSON Schema}.
+ *
+ * @remarks
+ * This function checks if the value has the structure of a Standard JSON Schema, which includes a `~standard` property with a `jsonSchema` object that has `input` and `output` functions.
+ *
+ * @see https://standardschema.dev/json-schema
+ *
+ * @param value - The value to check.
+ * @returns True if the value is a {@link StandardJSONSchemaV1 | Standard JSON Schema}, false otherwise.
+ */
+declare function isStandardJsonSchema<Input = unknown, Output = Input>(value: any): value is StandardJSONSchemaV1<Input, Output>;
+//#endregion
+export { isJsonSchema7NumberType as a, isJsonSchema7StringType as c, isJsonSchema7LiteralType as i, isStandardJsonSchema as l, isJsonSchema7ArrayType as n, isJsonSchema7ObjectType as o, isJsonSchema7BooleanType as r, isJsonSchema7PrimitiveLiteralType as s, isJsonSchema7AllOfType as t };
+//# sourceMappingURL=schema-BgOm_N0w.d.cts.map

package/dist/schema-BgOm_N0w.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-BgOm_N0w.d.cts","names":[],"sources":["../src/schema.ts"],"sourcesContent":[],"mappings":";;;;;;;AAuCA;AAgBA;AAgBA;AAYA;AAcgB,iBA1DA,sBAAA,CA2DN,MAAA,EA1DA,eA2DG,CAAA,EAAA,MAAA,IA1DA,oBA0DsB;AAUnC;AAYA;AAwBA;AAyBA;;;AAEwC,iBArHxB,uBAAA,CAqHwB,MAAA,EApH9B,eAoH8B,CAAA,EAAA,MAAA,IAnH3B,qBAmH2B;;;;;;;iBArGxB,uBAAA,SACN,4BACG;;;;;;;iBAUG,uBAAA,SACN,4BACG;;;;;;;iBAYG,wBAAA,SACN,4BACG;;;;;;;iBAUG,sBAAA,SACN,4BACG;;;;;;;iBAUG,iCAAA,SACN,4BACG;;;;;;;iBAsBG,wBAAA,SACN,4BACG;;;;;;;;;;;;iBAuBG,+CAA+C,6BAEnD,qBAAqB,OAAO"}

package/dist/schema-SrJmxZsC.mjs

@@ -0,0 +1,99 @@
+import { n as isFunction, t as isSetObject } from "./is-set-object-yxjp5vg-.mjs";
+
+//#region src/schema.ts
+/**
+* Type guard for {@link JsonSchema7AllOfType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7AllOfType}, false otherwise
+*/
+function isJsonSchema7AllOfType(schema) {
+	if ("type" in schema && schema.type === "string") return false;
+	return "allOf" in schema;
+}
+/**
+* Type guard for {@link JsonSchema7ObjectType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7ObjectType}, false otherwise
+*/
+function isJsonSchema7ObjectType(schema) {
+	if ("type" in schema && schema.type === "object") return false;
+	return "properties" in schema;
+}
+/**
+* Type guard for {@link JsonSchema7StringType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7StringType}, false otherwise
+*/
+function isJsonSchema7StringType(schema) {
+	return "type" in schema && schema.type === "string";
+}
+/**
+* Type guard for {@link JsonSchema7NumberType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7NumberType}, false otherwise
+*/
+function isJsonSchema7NumberType(schema) {
+	return "type" in schema && (schema.type === "number" || schema.type === "integer");
+}
+/**
+* Type guard for {@link JsonSchema7BooleanType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7BooleanType}, false otherwise
+*/
+function isJsonSchema7BooleanType(schema) {
+	return "type" in schema && schema.type === "boolean";
+}
+/**
+* Type guard for {@link JsonSchema7ArrayType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7ArrayType}, false otherwise
+*/
+function isJsonSchema7ArrayType(schema) {
+	return "type" in schema && schema.type === "array" && "items" in schema;
+}
+/**
+* Type guard for {@link JsonSchema7PrimitiveLiteralType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7PrimitiveLiteralType}, false otherwise
+*/
+function isJsonSchema7PrimitiveLiteralType(schema) {
+	if (!("type" in schema)) return false;
+	const { type } = schema;
+	return (type === "string" || type === "number" || type === "integer" || type === "boolean") && "const" in schema;
+}
+/**
+* Type guard for {@link JsonSchema7LiteralType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7LiteralType}, false otherwise
+*/
+function isJsonSchema7LiteralType(schema) {
+	if (isJsonSchema7PrimitiveLiteralType(schema)) return true;
+	if (!("type" in schema)) return false;
+	return schema.type === "object" || schema.type === "array";
+}
+/**
+* Type guard to check if a value is a {@link StandardJSONSchemaV1 | Standard JSON Schema}.
+*
+* @remarks
+* This function checks if the value has the structure of a Standard JSON Schema, which includes a `~standard` property with a `jsonSchema` object that has `input` and `output` functions.
+*
+* @see https://standardschema.dev/json-schema
+*
+* @param value - The value to check.
+* @returns True if the value is a {@link StandardJSONSchemaV1 | Standard JSON Schema}, false otherwise.
+*/
+function isStandardJsonSchema(value) {
+	return isSetObject(value) && "~standard" in value && isSetObject(value["~standard"]) && "jsonSchema" in value["~standard"] && isSetObject(value["~standard"].jsonSchema) && "input" in value["~standard"].jsonSchema && isFunction(value["~standard"].jsonSchema.input) && "output" in value["~standard"].jsonSchema && isFunction(value["~standard"].jsonSchema.output);
+}
+
+//#endregion
+export { isJsonSchema7NumberType as a, isJsonSchema7StringType as c, isJsonSchema7LiteralType as i, isStandardJsonSchema as l, isJsonSchema7ArrayType as n, isJsonSchema7ObjectType as o, isJsonSchema7BooleanType as r, isJsonSchema7PrimitiveLiteralType as s, isJsonSchema7AllOfType as t };
+//# sourceMappingURL=schema-SrJmxZsC.mjs.map

package/dist/schema-SrJmxZsC.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-SrJmxZsC.mjs","names":[],"sources":["../src/schema.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport type { StandardJSONSchemaV1 } from \"@standard-schema/spec\";\nimport { isFunction } from \"@stryke/type-checks/is-function\";\nimport { isSetObject } from \"@stryke/type-checks/is-set-object\";\nimport type {\n  JsonSchema7AllOfType,\n  JsonSchema7ArrayType,\n  JsonSchema7BooleanType,\n  JsonSchema7LiteralType,\n  JsonSchema7NumberType,\n  JsonSchema7ObjectType,\n  JsonSchema7PrimitiveLiteralType,\n  JsonSchema7StringType,\n  JsonSchema7Type\n} from \"./types\";\n\n/**\n * Type guard for {@link JsonSchema7AllOfType}\n *\n * @param schema - The schema to check\n * @returns True if the schema is a {@link JsonSchema7AllOfType}, false otherwise\n */\nexport function isJsonSchema7AllOfType(\n  schema: JsonSchema7Type\n): schema is JsonSchema7AllOfType {\n  if (\"type\" in schema && schema.type === \"string\") {\n    return false;\n  }\n\n  return \"allOf\" in schema;\n}\n\n/**\n * Type guard for {@link JsonSchema7ObjectType}\n *\n * @param schema - The schema to check\n * @returns True if the schema is a {@link JsonSchema7ObjectType}, false otherwise\n */\nexport function isJsonSchema7ObjectType(\n  schema: JsonSchema7Type\n): schema is JsonSchema7ObjectType {\n  if (\"type\" in schema && schema.type === \"object\") {\n    return false;\n  }\n\n  return \"properties\" in schema;\n}\n\n/**\n * Type guard for {@link JsonSchema7StringType}\n *\n * @param schema - The schema to check\n * @returns True if the schema is a {@link JsonSchema7StringType}, false otherwise\n */\nexport function isJsonSchema7StringType(\n  schema: JsonSchema7Type\n): schema is JsonSchema7StringType {\n  return \"type\" in schema && schema.type === \"string\";\n}\n\n/**\n * Type guard for {@link JsonSchema7NumberType}\n *\n * @param schema - The schema to check\n * @returns True if the schema is a {@link JsonSchema7NumberType}, false otherwise\n */\nexport function isJsonSchema7NumberType(\n  schema: JsonSchema7Type\n): schema is JsonSchema7NumberType {\n  return (\n    \"type\" in schema && (schema.type === \"number\" || schema.type === \"integer\")\n  );\n}\n\n/**\n * Type guard for {@link JsonSchema7BooleanType}\n *\n * @param schema - The schema to check\n * @returns True if the schema is a {@link JsonSchema7BooleanType}, false otherwise\n */\nexport function isJsonSchema7BooleanType(\n  schema: JsonSchema7Type\n): schema is JsonSchema7BooleanType {\n  return \"type\" in schema && schema.type === \"boolean\";\n}\n\n/**\n * Type guard for {@link JsonSchema7ArrayType}\n *\n * @param schema - The schema to check\n * @returns True if the schema is a {@link JsonSchema7ArrayType}, false otherwise\n */\nexport function isJsonSchema7ArrayType(\n  schema: JsonSchema7Type\n): schema is JsonSchema7ArrayType {\n  return \"type\" in schema && schema.type === \"array\" && \"items\" in schema;\n}\n\n/**\n * Type guard for {@link JsonSchema7PrimitiveLiteralType}\n *\n * @param schema - The schema to check\n * @returns True if the schema is a {@link JsonSchema7PrimitiveLiteralType}, false otherwise\n */\nexport function isJsonSchema7PrimitiveLiteralType(\n  schema: JsonSchema7Type\n): schema is JsonSchema7PrimitiveLiteralType {\n  if (!(\"type\" in schema)) {\n    return false;\n  }\n\n  const { type } = schema;\n\n  return (\n    (type === \"string\" ||\n      type === \"number\" ||\n      type === \"integer\" ||\n      type === \"boolean\") &&\n    \"const\" in schema\n  );\n}\n\n/**\n * Type guard for {@link JsonSchema7LiteralType}\n *\n * @param schema - The schema to check\n * @returns True if the schema is a {@link JsonSchema7LiteralType}, false otherwise\n */\nexport function isJsonSchema7LiteralType(\n  schema: JsonSchema7Type\n): schema is JsonSchema7LiteralType {\n  if (isJsonSchema7PrimitiveLiteralType(schema)) {\n    return true;\n  }\n\n  if (!(\"type\" in schema)) {\n    return false;\n  }\n\n  return schema.type === \"object\" || schema.type === \"array\";\n}\n\n/**\n * Type guard to check if a value is a {@link StandardJSONSchemaV1 | Standard JSON Schema}.\n *\n * @remarks\n * This function checks if the value has the structure of a Standard JSON Schema, which includes a `~standard` property with a `jsonSchema` object that has `input` and `output` functions.\n *\n * @see https://standardschema.dev/json-schema\n *\n * @param value - The value to check.\n * @returns True if the value is a {@link StandardJSONSchemaV1 | Standard JSON Schema}, false otherwise.\n */\nexport function isStandardJsonSchema<Input = unknown, Output = Input>(\n  value: any\n): value is StandardJSONSchemaV1<Input, Output> {\n  return (\n    isSetObject(value) &&\n    \"~standard\" in value &&\n    isSetObject(value[\"~standard\"]) &&\n    \"jsonSchema\" in value[\"~standard\"] &&\n    isSetObject(value[\"~standard\"].jsonSchema) &&\n    \"input\" in value[\"~standard\"].jsonSchema &&\n    isFunction(value[\"~standard\"].jsonSchema.input) &&\n    \"output\" in value[\"~standard\"].jsonSchema &&\n    isFunction(value[\"~standard\"].jsonSchema.output)\n  );\n}\n"],"mappings":";;;;;;;;;AAuCA,SAAgB,uBACd,QACgC;AAChC,KAAI,UAAU,UAAU,OAAO,SAAS,SACtC,QAAO;AAGT,QAAO,WAAW;;;;;;;;AASpB,SAAgB,wBACd,QACiC;AACjC,KAAI,UAAU,UAAU,OAAO,SAAS,SACtC,QAAO;AAGT,QAAO,gBAAgB;;;;;;;;AASzB,SAAgB,wBACd,QACiC;AACjC,QAAO,UAAU,UAAU,OAAO,SAAS;;;;;;;;AAS7C,SAAgB,wBACd,QACiC;AACjC,QACE,UAAU,WAAW,OAAO,SAAS,YAAY,OAAO,SAAS;;;;;;;;AAUrE,SAAgB,yBACd,QACkC;AAClC,QAAO,UAAU,UAAU,OAAO,SAAS;;;;;;;;AAS7C,SAAgB,uBACd,QACgC;AAChC,QAAO,UAAU,UAAU,OAAO,SAAS,WAAW,WAAW;;;;;;;;AASnE,SAAgB,kCACd,QAC2C;AAC3C,KAAI,EAAE,UAAU,QACd,QAAO;CAGT,MAAM,EAAE,SAAS;AAEjB,SACG,SAAS,YACR,SAAS,YACT,SAAS,aACT,SAAS,cACX,WAAW;;;;;;;;AAUf,SAAgB,yBACd,QACkC;AAClC,KAAI,kCAAkC,OAAO,CAC3C,QAAO;AAGT,KAAI,EAAE,UAAU,QACd,QAAO;AAGT,QAAO,OAAO,SAAS,YAAY,OAAO,SAAS;;;;;;;;;;;;;AAcrD,SAAgB,qBACd,OAC8C;AAC9C,QACE,YAAY,MAAM,IAClB,eAAe,SACf,YAAY,MAAM,aAAa,IAC/B,gBAAgB,MAAM,gBACtB,YAAY,MAAM,aAAa,WAAW,IAC1C,WAAW,MAAM,aAAa,cAC9B,WAAW,MAAM,aAAa,WAAW,MAAM,IAC/C,YAAY,MAAM,aAAa,cAC/B,WAAW,MAAM,aAAa,WAAW,OAAO"}

package/dist/schema.cjs

@@ -1,3 +1,11 @@
-const require_schema = require('./schema-D5Aqvh2i.cjs');
+const require_schema = require('./schema-BM7g4xZ3.cjs');
 
-exports.isJsonSchema7AllOfType = require_schema.isJsonSchema7AllOfType;
+exports.isJsonSchema7AllOfType = require_schema.isJsonSchema7AllOfType;
+exports.isJsonSchema7ArrayType = require_schema.isJsonSchema7ArrayType;
+exports.isJsonSchema7BooleanType = require_schema.isJsonSchema7BooleanType;
+exports.isJsonSchema7LiteralType = require_schema.isJsonSchema7LiteralType;
+exports.isJsonSchema7NumberType = require_schema.isJsonSchema7NumberType;
+exports.isJsonSchema7ObjectType = require_schema.isJsonSchema7ObjectType;
+exports.isJsonSchema7PrimitiveLiteralType = require_schema.isJsonSchema7PrimitiveLiteralType;
+exports.isJsonSchema7StringType = require_schema.isJsonSchema7StringType;
+exports.isStandardJsonSchema = require_schema.isStandardJsonSchema;

package/dist/schema.d.cts

@@ -1,2 +1,2 @@
-import { t as isJsonSchema7AllOfType } from "./schema-B1RVJHzJ.cjs";
-export { isJsonSchema7AllOfType };
+import { a as isJsonSchema7NumberType, c as isJsonSchema7StringType, i as isJsonSchema7LiteralType, l as isStandardJsonSchema, n as isJsonSchema7ArrayType, o as isJsonSchema7ObjectType, r as isJsonSchema7BooleanType, s as isJsonSchema7PrimitiveLiteralType, t as isJsonSchema7AllOfType } from "./schema-BgOm_N0w.cjs";
+export { isJsonSchema7AllOfType, isJsonSchema7ArrayType, isJsonSchema7BooleanType, isJsonSchema7LiteralType, isJsonSchema7NumberType, isJsonSchema7ObjectType, isJsonSchema7PrimitiveLiteralType, isJsonSchema7StringType, isStandardJsonSchema };

package/dist/schema.d.mts

@@ -1,3 +1,3 @@
-import "./types-C_KlcCNw.mjs";
-import { t as isJsonSchema7AllOfType } from "./schema-ai_NU-JC.mjs";
-export { isJsonSchema7AllOfType };
+import "./types-BAtAPir9.mjs";
+import { a as isJsonSchema7NumberType, c as isJsonSchema7StringType, i as isJsonSchema7LiteralType, l as isStandardJsonSchema, n as isJsonSchema7ArrayType, o as isJsonSchema7ObjectType, r as isJsonSchema7BooleanType, s as isJsonSchema7PrimitiveLiteralType, t as isJsonSchema7AllOfType } from "./schema-B7wpjw3I.mjs";
+export { isJsonSchema7AllOfType, isJsonSchema7ArrayType, isJsonSchema7BooleanType, isJsonSchema7LiteralType, isJsonSchema7NumberType, isJsonSchema7ObjectType, isJsonSchema7PrimitiveLiteralType, isJsonSchema7StringType, isStandardJsonSchema };

package/dist/schema.mjs

@@ -1,3 +1,3 @@
-import { t as isJsonSchema7AllOfType } from "./schema-CfhPLy30.mjs";
+import { a as isJsonSchema7NumberType, c as isJsonSchema7StringType, i as isJsonSchema7LiteralType, l as isStandardJsonSchema, n as isJsonSchema7ArrayType, o as isJsonSchema7ObjectType, r as isJsonSchema7BooleanType, s as isJsonSchema7PrimitiveLiteralType, t as isJsonSchema7AllOfType } from "./schema-SrJmxZsC.mjs";
 
-export { isJsonSchema7AllOfType };
+export { isJsonSchema7AllOfType, isJsonSchema7ArrayType, isJsonSchema7BooleanType, isJsonSchema7LiteralType, isJsonSchema7NumberType, isJsonSchema7ObjectType, isJsonSchema7PrimitiveLiteralType, isJsonSchema7StringType, isStandardJsonSchema };

package/dist/{storm-json-6WpS7qnH.cjs → storm-json-BDPXNC_u.cjs}

@@ -25,11 +25,11 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const require_is_object = require('./is-object-umGh91v1.cjs');
-const require_is_string = require('./is-string-C2RK4Gjs.cjs');
-const require_parse = require('./parse-wxSDzBPf.cjs');
-const require_parse_error = require('./parse-error-Dzwg4sdE.cjs');
-const require_stringify = require('./stringify-DEw3S4_Z.cjs');
+const require_is_object = require('./is-object-BbRMEXAo.cjs');
+const require_is_string = require('./is-string-yY-B30hL.cjs');
+const require_parse = require('./parse-CX9jPskm.cjs');
+const require_parse_error = require('./parse-error-CUOf-YBA.cjs');
+const require_stringify = require('./stringify-DQOBApRO.cjs');
 let jsonc_parser = require("jsonc-parser");
 let node_buffer = require("node:buffer");
 let superjson = require("superjson");

package/dist/{storm-json-Cy3PuAhj.mjs → storm-json-BmO91crX.mjs}

@@ -1,8 +1,8 @@
-import { t as isObject } from "./is-object-BpfmzHWa.mjs";
-import { t as isString } from "./is-string-CLiBUSKV.mjs";
-import { t as parse$1 } from "./parse-obdkJfj5.mjs";
-import { t as formatParseError } from "./parse-error-C3Qmubee.mjs";
-import { n as stringify } from "./stringify-D5baUfEe.mjs";
+import { t as isObject } from "./is-object-BYxzKTYU.mjs";
+import { t as isString } from "./is-string--ny35huw.mjs";
+import { t as parse$1 } from "./parse-BrChHTWb.mjs";
+import { t as formatParseError } from "./parse-error-Cu6mjBS7.mjs";
+import { n as stringify } from "./stringify-CfeAVjh8.mjs";
 import { parse } from "jsonc-parser";
 import { Buffer } from "node:buffer";
 import SuperJSON from "superjson";
@@ -113,4 +113,4 @@ StormJSON.instance.registerCustom({
 
 //#endregion
 export { StormJSON as t };
-//# sourceMappingURL=storm-json-Cy3PuAhj.mjs.map
+//# sourceMappingURL=storm-json-BmO91crX.mjs.map

package/dist/{storm-json-Cy3PuAhj.mjs.map → storm-json-BmO91crX.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"storm-json-Cy3PuAhj.mjs","names":["#instance","parseValue","stringifyValue","errors: ParseError[]"],"sources":["../src/storm-json.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport type { ParseError } from \"jsonc-parser\";\nimport type {\n  Class,\n  JsonParseOptions,\n  JsonParserResult,\n  JsonSerializeOptions,\n  JsonValue\n} from \"./types\";\n// import { Decimal } from \"decimal.js\";\nimport { isObject } from \"@stryke/type-checks/is-object\";\nimport { isString } from \"@stryke/type-checks/is-string\";\nimport { parse } from \"jsonc-parser\";\nimport { Buffer } from \"node:buffer\";\nimport SuperJSON from \"superjson\";\nimport { parse as parseValue } from \"./utils/parse\";\nimport { formatParseError } from \"./utils/parse-error\";\nimport { stringify as stringifyValue } from \"./utils/stringify\";\n\n/**\n * A static JSON parser class used by Storm Software to serialize and deserialize JSON data\n *\n * @remarks\n * This class uses the [SuperJSON](https://github.com/blitz-js/superjson) library under the hood.\n */\nexport class StormJSON extends SuperJSON {\n  static #instance: StormJSON;\n\n  public static get instance(): StormJSON {\n    if (!StormJSON.#instance) {\n      StormJSON.#instance = new StormJSON();\n    }\n\n    return StormJSON.#instance;\n  }\n\n  /**\n   * Deserialize the given value with superjson using the given metadata\n   */\n  public static override deserialize<TData = unknown>(\n    payload: JsonParserResult\n  ): TData {\n    return StormJSON.instance.deserialize(payload);\n  }\n\n  /**\n   * Serialize the given value with superjson\n   */\n  public static override serialize(object: JsonValue): JsonParserResult {\n    return StormJSON.instance.serialize(object);\n  }\n\n  /**\n   * Parse the given string value with superjson using the given metadata\n   *\n   * @param value - The string value to parse\n   * @returns The parsed data\n   */\n  public static override parse<TData = unknown>(value: string): TData {\n    return parseValue(value);\n  }\n\n  /**\n   * Serializes the given data to a JSON string.\n   * By default the JSON string is formatted with a 2 space indentation to be easy readable.\n   *\n   * @param value - Object which should be serialized to JSON\n   * @param options - JSON serialize options\n   * @returns the formatted JSON representation of the object\n   */\n  public static override stringify<T>(\n    value: T,\n    options?: JsonSerializeOptions\n  ): string {\n    const customTransformer =\n      StormJSON.instance.customTransformerRegistry.findApplicable(value);\n\n    let result = value;\n    if (customTransformer && customTransformer.isApplicable(value)) {\n      result = customTransformer.serialize(result) as T;\n    }\n\n    return stringifyValue(result, options?.spaces ?? 2);\n  }\n\n  /**\n   * Parses the given JSON string and returns the object the JSON content represents.\n   * By default javascript-style comments and trailing commas are allowed.\n   *\n   * @param strData - JSON content as string\n   * @param options - JSON parse options\n   * @returns Object the JSON content represents\n   */\n  public static parseJson<TData = unknown>(\n    strData: string,\n    options?: JsonParseOptions\n  ): TData {\n    try {\n      if (options?.expectComments === false) {\n        return StormJSON.instance.parse(strData);\n      }\n    } catch {\n      // Do nothing\n    }\n\n    const errors: ParseError[] = [];\n    const opts = {\n      allowTrailingComma: true,\n      ...options\n    };\n    const result = parse(strData, errors, opts) as TData;\n\n    if (errors.length > 0 && errors[0]) {\n      throw new Error(formatParseError(strData, errors[0]));\n    }\n\n    return result;\n  }\n\n  /**\n   * Register a custom schema with superjson\n   *\n   * @param name - The name of the schema\n   * @param serialize - The function to serialize the schema\n   * @param deserialize - The function to deserialize the schema\n   * @param isApplicable - The function to check if the schema is applicable\n   */\n  public static register<\n    TData = any,\n    TJsonObject extends JsonValue = JsonValue\n  >(\n    name: string,\n    serialize: (data: TData) => TJsonObject,\n    deserialize: (json: TJsonObject) => TData,\n    isApplicable: (data: any) => data is TData\n  ) {\n    StormJSON.instance.registerCustom<TData, TJsonObject>(\n      {\n        isApplicable,\n        serialize,\n        deserialize\n      },\n      name\n    );\n  }\n\n  /**\n   * Register a class with superjson\n   *\n   * @param classConstructor - The class constructor to register\n   */\n  public static override registerClass(\n    classConstructor: Class,\n    options?: { identifier?: string; allowProps?: string[] } | string\n  ) {\n    StormJSON.instance.registerClass(classConstructor, {\n      identifier: isString(options)\n        ? options\n        : options?.identifier || classConstructor.name,\n      allowProps:\n        options &&\n        isObject(options) &&\n        options?.allowProps &&\n        Array.isArray(options.allowProps)\n          ? options.allowProps\n          : [\"__typename\"]\n    });\n  }\n\n  private constructor() {\n    super({ dedupe: true });\n  }\n}\n\nStormJSON.instance.registerCustom<Buffer, string>(\n  {\n    isApplicable: (v): v is Buffer =>\n      typeof Buffer.isBuffer === \"function\" && Buffer.isBuffer(v),\n    serialize: v => v.toString(\"base64\"),\n    deserialize: v => Buffer.from(v, \"base64\")\n  },\n  \"Bytes\"\n);\n"],"mappings":";;;;;;;;;;;;;;;;AA0CA,IAAa,YAAb,MAAa,kBAAkB,UAAU;CACvC,QAAOA;CAEP,WAAkB,WAAsB;AACtC,MAAI,CAAC,WAAUA,SACb,YAAUA,WAAY,IAAI,WAAW;AAGvC,SAAO,WAAUA;;;;;CAMnB,OAAuB,YACrB,SACO;AACP,SAAO,UAAU,SAAS,YAAY,QAAQ;;;;;CAMhD,OAAuB,UAAU,QAAqC;AACpE,SAAO,UAAU,SAAS,UAAU,OAAO;;;;;;;;CAS7C,OAAuB,MAAuB,OAAsB;AAClE,SAAOC,QAAW,MAAM;;;;;;;;;;CAW1B,OAAuB,UACrB,OACA,SACQ;EACR,MAAM,oBACJ,UAAU,SAAS,0BAA0B,eAAe,MAAM;EAEpE,IAAI,SAAS;AACb,MAAI,qBAAqB,kBAAkB,aAAa,MAAM,CAC5D,UAAS,kBAAkB,UAAU,OAAO;AAG9C,SAAOC,UAAe,QAAQ,SAAS,UAAU,EAAE;;;;;;;;;;CAWrD,OAAc,UACZ,SACA,SACO;AACP,MAAI;AACF,OAAI,SAAS,mBAAmB,MAC9B,QAAO,UAAU,SAAS,MAAM,QAAQ;UAEpC;EAIR,MAAMC,SAAuB,EAAE;EAK/B,MAAM,SAAS,MAAM,SAAS,QAJjB;GACX,oBAAoB;GACpB,GAAG;GACJ,CAC0C;AAE3C,MAAI,OAAO,SAAS,KAAK,OAAO,GAC9B,OAAM,IAAI,MAAM,iBAAiB,SAAS,OAAO,GAAG,CAAC;AAGvD,SAAO;;;;;;;;;;CAWT,OAAc,SAIZ,MACA,WACA,aACA,cACA;AACA,YAAU,SAAS,eACjB;GACE;GACA;GACA;GACD,EACD,KACD;;;;;;;CAQH,OAAuB,cACrB,kBACA,SACA;AACA,YAAU,SAAS,cAAc,kBAAkB;GACjD,YAAY,SAAS,QAAQ,GACzB,UACA,SAAS,cAAc,iBAAiB;GAC5C,YACE,WACA,SAAS,QAAQ,IACjB,SAAS,cACT,MAAM,QAAQ,QAAQ,WAAW,GAC7B,QAAQ,aACR,CAAC,aAAa;GACrB,CAAC;;CAGJ,AAAQ,cAAc;AACpB,QAAM,EAAE,QAAQ,MAAM,CAAC;;;AAI3B,UAAU,SAAS,eACjB;CACE,eAAe,MACb,OAAO,OAAO,aAAa,cAAc,OAAO,SAAS,EAAE;CAC7D,YAAW,MAAK,EAAE,SAAS,SAAS;CACpC,cAAa,MAAK,OAAO,KAAK,GAAG,SAAS;CAC3C,EACD,QACD"}
+{"version":3,"file":"storm-json-BmO91crX.mjs","names":["#instance","parseValue","stringifyValue","errors: ParseError[]"],"sources":["../src/storm-json.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport type { ParseError } from \"jsonc-parser\";\nimport type {\n  Class,\n  JsonParseOptions,\n  JsonParserResult,\n  JsonSerializeOptions,\n  JsonValue\n} from \"./types\";\n// import { Decimal } from \"decimal.js\";\nimport { isObject } from \"@stryke/type-checks/is-object\";\nimport { isString } from \"@stryke/type-checks/is-string\";\nimport { parse } from \"jsonc-parser\";\nimport { Buffer } from \"node:buffer\";\nimport SuperJSON from \"superjson\";\nimport { parse as parseValue } from \"./utils/parse\";\nimport { formatParseError } from \"./utils/parse-error\";\nimport { stringify as stringifyValue } from \"./utils/stringify\";\n\n/**\n * A static JSON parser class used by Storm Software to serialize and deserialize JSON data\n *\n * @remarks\n * This class uses the [SuperJSON](https://github.com/blitz-js/superjson) library under the hood.\n */\nexport class StormJSON extends SuperJSON {\n  static #instance: StormJSON;\n\n  public static get instance(): StormJSON {\n    if (!StormJSON.#instance) {\n      StormJSON.#instance = new StormJSON();\n    }\n\n    return StormJSON.#instance;\n  }\n\n  /**\n   * Deserialize the given value with superjson using the given metadata\n   */\n  public static override deserialize<TData = unknown>(\n    payload: JsonParserResult\n  ): TData {\n    return StormJSON.instance.deserialize(payload);\n  }\n\n  /**\n   * Serialize the given value with superjson\n   */\n  public static override serialize(object: JsonValue): JsonParserResult {\n    return StormJSON.instance.serialize(object);\n  }\n\n  /**\n   * Parse the given string value with superjson using the given metadata\n   *\n   * @param value - The string value to parse\n   * @returns The parsed data\n   */\n  public static override parse<TData = unknown>(value: string): TData {\n    return parseValue(value);\n  }\n\n  /**\n   * Serializes the given data to a JSON string.\n   * By default the JSON string is formatted with a 2 space indentation to be easy readable.\n   *\n   * @param value - Object which should be serialized to JSON\n   * @param options - JSON serialize options\n   * @returns the formatted JSON representation of the object\n   */\n  public static override stringify<T>(\n    value: T,\n    options?: JsonSerializeOptions\n  ): string {\n    const customTransformer =\n      StormJSON.instance.customTransformerRegistry.findApplicable(value);\n\n    let result = value;\n    if (customTransformer && customTransformer.isApplicable(value)) {\n      result = customTransformer.serialize(result) as T;\n    }\n\n    return stringifyValue(result, options?.spaces ?? 2);\n  }\n\n  /**\n   * Parses the given JSON string and returns the object the JSON content represents.\n   * By default javascript-style comments and trailing commas are allowed.\n   *\n   * @param strData - JSON content as string\n   * @param options - JSON parse options\n   * @returns Object the JSON content represents\n   */\n  public static parseJson<TData = unknown>(\n    strData: string,\n    options?: JsonParseOptions\n  ): TData {\n    try {\n      if (options?.expectComments === false) {\n        return StormJSON.instance.parse(strData);\n      }\n    } catch {\n      // Do nothing\n    }\n\n    const errors: ParseError[] = [];\n    const opts = {\n      allowTrailingComma: true,\n      ...options\n    };\n    const result = parse(strData, errors, opts) as TData;\n\n    if (errors.length > 0 && errors[0]) {\n      throw new Error(formatParseError(strData, errors[0]));\n    }\n\n    return result;\n  }\n\n  /**\n   * Register a custom schema with superjson\n   *\n   * @param name - The name of the schema\n   * @param serialize - The function to serialize the schema\n   * @param deserialize - The function to deserialize the schema\n   * @param isApplicable - The function to check if the schema is applicable\n   */\n  public static register<\n    TData = any,\n    TJsonObject extends JsonValue = JsonValue\n  >(\n    name: string,\n    serialize: (data: TData) => TJsonObject,\n    deserialize: (json: TJsonObject) => TData,\n    isApplicable: (data: any) => data is TData\n  ) {\n    StormJSON.instance.registerCustom<TData, TJsonObject>(\n      {\n        isApplicable,\n        serialize,\n        deserialize\n      },\n      name\n    );\n  }\n\n  /**\n   * Register a class with superjson\n   *\n   * @param classConstructor - The class constructor to register\n   */\n  public static override registerClass(\n    classConstructor: Class,\n    options?: { identifier?: string; allowProps?: string[] } | string\n  ) {\n    StormJSON.instance.registerClass(classConstructor, {\n      identifier: isString(options)\n        ? options\n        : options?.identifier || classConstructor.name,\n      allowProps:\n        options &&\n        isObject(options) &&\n        options?.allowProps &&\n        Array.isArray(options.allowProps)\n          ? options.allowProps\n          : [\"__typename\"]\n    });\n  }\n\n  private constructor() {\n    super({ dedupe: true });\n  }\n}\n\nStormJSON.instance.registerCustom<Buffer, string>(\n  {\n    isApplicable: (v): v is Buffer =>\n      typeof Buffer.isBuffer === \"function\" && Buffer.isBuffer(v),\n    serialize: v => v.toString(\"base64\"),\n    deserialize: v => Buffer.from(v, \"base64\")\n  },\n  \"Bytes\"\n);\n"],"mappings":";;;;;;;;;;;;;;;;AA0CA,IAAa,YAAb,MAAa,kBAAkB,UAAU;CACvC,QAAOA;CAEP,WAAkB,WAAsB;AACtC,MAAI,CAAC,WAAUA,SACb,YAAUA,WAAY,IAAI,WAAW;AAGvC,SAAO,WAAUA;;;;;CAMnB,OAAuB,YACrB,SACO;AACP,SAAO,UAAU,SAAS,YAAY,QAAQ;;;;;CAMhD,OAAuB,UAAU,QAAqC;AACpE,SAAO,UAAU,SAAS,UAAU,OAAO;;;;;;;;CAS7C,OAAuB,MAAuB,OAAsB;AAClE,SAAOC,QAAW,MAAM;;;;;;;;;;CAW1B,OAAuB,UACrB,OACA,SACQ;EACR,MAAM,oBACJ,UAAU,SAAS,0BAA0B,eAAe,MAAM;EAEpE,IAAI,SAAS;AACb,MAAI,qBAAqB,kBAAkB,aAAa,MAAM,CAC5D,UAAS,kBAAkB,UAAU,OAAO;AAG9C,SAAOC,UAAe,QAAQ,SAAS,UAAU,EAAE;;;;;;;;;;CAWrD,OAAc,UACZ,SACA,SACO;AACP,MAAI;AACF,OAAI,SAAS,mBAAmB,MAC9B,QAAO,UAAU,SAAS,MAAM,QAAQ;UAEpC;EAIR,MAAMC,SAAuB,EAAE;EAK/B,MAAM,SAAS,MAAM,SAAS,QAJjB;GACX,oBAAoB;GACpB,GAAG;GACJ,CAC0C;AAE3C,MAAI,OAAO,SAAS,KAAK,OAAO,GAC9B,OAAM,IAAI,MAAM,iBAAiB,SAAS,OAAO,GAAG,CAAC;AAGvD,SAAO;;;;;;;;;;CAWT,OAAc,SAIZ,MACA,WACA,aACA,cACA;AACA,YAAU,SAAS,eACjB;GACE;GACA;GACA;GACD,EACD,KACD;;;;;;;CAQH,OAAuB,cACrB,kBACA,SACA;AACA,YAAU,SAAS,cAAc,kBAAkB;GACjD,YAAY,SAAS,QAAQ,GACzB,UACA,SAAS,cAAc,iBAAiB;GAC5C,YACE,WACA,SAAS,QAAQ,IACjB,SAAS,cACT,MAAM,QAAQ,QAAQ,WAAW,GAC7B,QAAQ,aACR,CAAC,aAAa;GACrB,CAAC;;CAGJ,AAAQ,cAAc;AACpB,QAAM,EAAE,QAAQ,MAAM,CAAC;;;AAI3B,UAAU,SAAS,eACjB;CACE,eAAe,MACb,OAAO,OAAO,aAAa,cAAc,OAAO,SAAS,EAAE;CAC7D,YAAW,MAAK,EAAE,SAAS,SAAS;CACpC,cAAa,MAAK,OAAO,KAAK,GAAG,SAAS;CAC3C,EACD,QACD"}

package/dist/{storm-json-AaFeOao2.d.cts → storm-json-DJwb3Ou-.d.mts}

@@ -1,4 +1,4 @@
-import { H as JsonSerializeOptions, U as JsonValue, d as JsonParserResult, l as JsonParseOptions, t as Class } from "./types-BUeTTE_U.cjs";
+import { U as JsonSerializeOptions, W as JsonValue, d as JsonParserResult, l as JsonParseOptions, t as Class } from "./types-BAtAPir9.mjs";
 import SuperJSON from "superjson";
 
 //#region src/storm-json.d.ts
@@ -67,4 +67,4 @@ declare class StormJSON extends SuperJSON {
 }
 //#endregion
 export { StormJSON as t };
-//# sourceMappingURL=storm-json-AaFeOao2.d.cts.map
+//# sourceMappingURL=storm-json-DJwb3Ou-.d.mts.map

package/dist/{storm-json-AaFeOao2.d.cts.map → storm-json-DJwb3Ou-.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"storm-json-AaFeOao2.d.cts","names":[],"sources":["../src/storm-json.ts"],"sourcesContent":[],"mappings":";;;;;;;AA0CA;;;;AAuB2C,cAvB9B,SAAA,SAAkB,SAAA,CAuBY;EAAY,CAAA,OAAA;EAUS,WAAA,QAAA,CAAA,CAAA,EA9BhC,SA8BgC;EAarD;;;EAyBN,OAAA,WAAA,CAAA,QAAA,OAAA,CAAA,CAAA,OAAA,EAxDQ,gBAwDR,CAAA,EAvDA,KAuDA;EAiCmB;;;EAGQ,OAAA,SAAA,CAAA,MAAA,EApFW,SAoFX,CAAA,EApFuB,gBAoFvB;EACR;;;;;;gDA3EwC;;;;;;;;;6BAarD,aACG;;;;;;;;;+DAuBA,mBACT;;;;;;;;;mDAiCmB,YAAY,2CAGd,UAAU,iCACR,gBAAgB,4CACC;;;;;;yCAkBnB"}
+{"version":3,"file":"storm-json-DJwb3Ou-.d.mts","names":[],"sources":["../src/storm-json.ts"],"sourcesContent":[],"mappings":";;;;;;;AA0CA;;;;AAuB2C,cAvB9B,SAAA,SAAkB,SAAA,CAuBY;EAAY,CAAA,OAAA;EAUS,WAAA,QAAA,CAAA,CAAA,EA9BhC,SA8BgC;EAarD;;;EAyBN,OAAA,WAAA,CAAA,QAAA,OAAA,CAAA,CAAA,OAAA,EAxDQ,gBAwDR,CAAA,EAvDA,KAuDA;EAiCmB;;;EAGQ,OAAA,SAAA,CAAA,MAAA,EApFW,SAoFX,CAAA,EApFuB,gBAoFvB;EACR;;;;;;gDA3EwC;;;;;;;;;6BAarD,aACG;;;;;;;;;+DAuBA,mBACT;;;;;;;;;mDAiCmB,YAAY,2CAGd,UAAU,iCACR,gBAAgB,4CACC;;;;;;yCAkBnB"}

package/dist/{storm-json-BvRkzAlR.d.mts → storm-json-DiBg5b6r.d.cts}

@@ -1,4 +1,4 @@
-import { H as JsonSerializeOptions, U as JsonValue, d as JsonParserResult, l as JsonParseOptions, t as Class } from "./types-C_KlcCNw.mjs";
+import { U as JsonSerializeOptions, W as JsonValue, d as JsonParserResult, l as JsonParseOptions, t as Class } from "./types-BzNIRhpI.cjs";
 import SuperJSON from "superjson";
 
 //#region src/storm-json.d.ts
@@ -67,4 +67,4 @@ declare class StormJSON extends SuperJSON {
 }
 //#endregion
 export { StormJSON as t };
-//# sourceMappingURL=storm-json-BvRkzAlR.d.mts.map
+//# sourceMappingURL=storm-json-DiBg5b6r.d.cts.map

package/dist/{storm-json-BvRkzAlR.d.mts.map → storm-json-DiBg5b6r.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"storm-json-BvRkzAlR.d.mts","names":[],"sources":["../src/storm-json.ts"],"sourcesContent":[],"mappings":";;;;;;;AA0CA;;;;AAuB2C,cAvB9B,SAAA,SAAkB,SAAA,CAuBY;EAAY,CAAA,OAAA;EAUS,WAAA,QAAA,CAAA,CAAA,EA9BhC,SA8BgC;EAarD;;;EAyBN,OAAA,WAAA,CAAA,QAAA,OAAA,CAAA,CAAA,OAAA,EAxDQ,gBAwDR,CAAA,EAvDA,KAuDA;EAiCmB;;;EAGQ,OAAA,SAAA,CAAA,MAAA,EApFW,SAoFX,CAAA,EApFuB,gBAoFvB;EACR;;;;;;gDA3EwC;;;;;;;;;6BAarD,aACG;;;;;;;;;+DAuBA,mBACT;;;;;;;;;mDAiCmB,YAAY,2CAGd,UAAU,iCACR,gBAAgB,4CACC;;;;;;yCAkBnB"}
+{"version":3,"file":"storm-json-DiBg5b6r.d.cts","names":[],"sources":["../src/storm-json.ts"],"sourcesContent":[],"mappings":";;;;;;;AA0CA;;;;AAuB2C,cAvB9B,SAAA,SAAkB,SAAA,CAuBY;EAAY,CAAA,OAAA;EAUS,WAAA,QAAA,CAAA,CAAA,EA9BhC,SA8BgC;EAarD;;;EAyBN,OAAA,WAAA,CAAA,QAAA,OAAA,CAAA,CAAA,OAAA,EAxDQ,gBAwDR,CAAA,EAvDA,KAuDA;EAiCmB;;;EAGQ,OAAA,SAAA,CAAA,MAAA,EApFW,SAoFX,CAAA,EApFuB,gBAoFvB;EACR;;;;;;gDA3EwC;;;;;;;;;6BAarD,aACG;;;;;;;;;+DAuBA,mBACT;;;;;;;;;mDAiCmB,YAAY,2CAGd,UAAU,iCACR,gBAAgB,4CACC;;;;;;yCAkBnB"}

package/dist/storm-json.cjs

@@ -1,4 +1,4 @@
-const require_storm_json = require('./storm-json-6WpS7qnH.cjs');
-require('./parse-error-Dzwg4sdE.cjs');
+const require_storm_json = require('./storm-json-BDPXNC_u.cjs');
+require('./parse-error-CUOf-YBA.cjs');
 
 exports.StormJSON = require_storm_json.StormJSON;

package/dist/storm-json.d.cts

@@ -1,2 +1,2 @@
-import { t as StormJSON } from "./storm-json-AaFeOao2.cjs";
+import { t as StormJSON } from "./storm-json-DiBg5b6r.cjs";
 export { StormJSON };