@stackframe/stack-shared 2.8.7 → 2.8.10

package/dist/utils/http.d.cts

@@ -0,0 +1,43 @@
+declare const HTTP_METHODS: {
+    readonly GET: {
+        readonly safe: true;
+        readonly idempotent: true;
+    };
+    readonly POST: {
+        readonly safe: false;
+        readonly idempotent: false;
+    };
+    readonly PUT: {
+        readonly safe: false;
+        readonly idempotent: true;
+    };
+    readonly DELETE: {
+        readonly safe: false;
+        readonly idempotent: true;
+    };
+    readonly PATCH: {
+        readonly safe: false;
+        readonly idempotent: false;
+    };
+    readonly OPTIONS: {
+        readonly safe: true;
+        readonly idempotent: true;
+    };
+    readonly HEAD: {
+        readonly safe: true;
+        readonly idempotent: true;
+    };
+    readonly TRACE: {
+        readonly safe: true;
+        readonly idempotent: true;
+    };
+    readonly CONNECT: {
+        readonly safe: false;
+        readonly idempotent: false;
+    };
+};
+type HttpMethod = keyof typeof HTTP_METHODS;
+declare function decodeBasicAuthorizationHeader(value: string): [string, string] | null;
+declare function encodeBasicAuthorizationHeader(id: string, password: string): string;
+
+export { HTTP_METHODS, type HttpMethod, decodeBasicAuthorizationHeader, encodeBasicAuthorizationHeader };

package/dist/utils/http.d.ts

@@ -1,4 +1,4 @@
-export declare const HTTP_METHODS: {
+declare const HTTP_METHODS: {
     readonly GET: {
         readonly safe: true;
         readonly idempotent: true;
@@ -36,6 +36,8 @@ export declare const HTTP_METHODS: {
         readonly idempotent: false;
     };
 };
-export type HttpMethod = keyof typeof HTTP_METHODS;
-export declare function decodeBasicAuthorizationHeader(value: string): [string, string] | null;
-export declare function encodeBasicAuthorizationHeader(id: string, password: string): string;
+type HttpMethod = keyof typeof HTTP_METHODS;
+declare function decodeBasicAuthorizationHeader(value: string): [string, string] | null;
+declare function encodeBasicAuthorizationHeader(id: string, password: string): string;
+
+export { HTTP_METHODS, type HttpMethod, decodeBasicAuthorizationHeader, encodeBasicAuthorizationHeader };

package/dist/utils/http.js

@@ -1,87 +1,87 @@
-import { decodeBase64, encodeBase64, isBase64 } from "./bytes";
-export const HTTP_METHODS = {
-    "GET": {
-        safe: true,
-        idempotent: true,
-    },
-    "POST": {
-        safe: false,
-        idempotent: false,
-    },
-    "PUT": {
-        safe: false,
-        idempotent: true,
-    },
-    "DELETE": {
-        safe: false,
-        idempotent: true,
-    },
-    "PATCH": {
-        safe: false,
-        idempotent: false,
-    },
-    "OPTIONS": {
-        safe: true,
-        idempotent: true,
-    },
-    "HEAD": {
-        safe: true,
-        idempotent: true,
-    },
-    "TRACE": {
-        safe: true,
-        idempotent: true,
-    },
-    "CONNECT": {
-        safe: false,
-        idempotent: false,
-    },
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-export function decodeBasicAuthorizationHeader(value) {
-    const [type, encoded, ...rest] = value.split(' ');
-    if (rest.length > 0)
-        return null;
-    if (!encoded)
-        return null;
-    if (type !== 'Basic')
-        return null;
-    if (!isBase64(encoded))
-        return null;
-    const decoded = new TextDecoder().decode(decodeBase64(encoded));
-    const split = decoded.split(':');
-    return [split[0], split.slice(1).join(':')];
-}
-import.meta.vitest?.test("decodeBasicAuthorizationHeader", ({ expect }) => {
-    // Test with valid Basic Authorization header
-    const username = "user";
-    const password = "pass";
-    const encoded = encodeBasicAuthorizationHeader(username, password);
-    expect(decodeBasicAuthorizationHeader(encoded)).toEqual([username, password]);
-    // Test with password containing colons
-    const complexPassword = "pass:with:colons";
-    const encodedComplex = encodeBasicAuthorizationHeader(username, complexPassword);
-    expect(decodeBasicAuthorizationHeader(encodedComplex)).toEqual([username, complexPassword]);
-    // Test with invalid headers
-    expect(decodeBasicAuthorizationHeader("NotBasic dXNlcjpwYXNz")).toBe(null); // Wrong type
-    expect(decodeBasicAuthorizationHeader("Basic")).toBe(null); // Missing encoded part
-    expect(decodeBasicAuthorizationHeader("Basic not-base64")).toBe(null); // Not base64
-    expect(decodeBasicAuthorizationHeader("Basic dXNlcjpwYXNz extra")).toBe(null); // Extra parts
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/http.tsx
+var http_exports = {};
+__export(http_exports, {
+  HTTP_METHODS: () => HTTP_METHODS,
+  decodeBasicAuthorizationHeader: () => decodeBasicAuthorizationHeader,
+  encodeBasicAuthorizationHeader: () => encodeBasicAuthorizationHeader
 });
-export function encodeBasicAuthorizationHeader(id, password) {
-    if (id.includes(':'))
-        throw new Error("Basic authorization header id cannot contain ':'");
-    return `Basic ${encodeBase64(new TextEncoder().encode(`${id}:${password}`))}`;
+module.exports = __toCommonJS(http_exports);
+var import_bytes = require("./bytes");
+var HTTP_METHODS = {
+  "GET": {
+    safe: true,
+    idempotent: true
+  },
+  "POST": {
+    safe: false,
+    idempotent: false
+  },
+  "PUT": {
+    safe: false,
+    idempotent: true
+  },
+  "DELETE": {
+    safe: false,
+    idempotent: true
+  },
+  "PATCH": {
+    safe: false,
+    idempotent: false
+  },
+  "OPTIONS": {
+    safe: true,
+    idempotent: true
+  },
+  "HEAD": {
+    safe: true,
+    idempotent: true
+  },
+  "TRACE": {
+    safe: true,
+    idempotent: true
+  },
+  "CONNECT": {
+    safe: false,
+    idempotent: false
+  }
+};
+function decodeBasicAuthorizationHeader(value) {
+  const [type, encoded, ...rest] = value.split(" ");
+  if (rest.length > 0) return null;
+  if (!encoded) return null;
+  if (type !== "Basic") return null;
+  if (!(0, import_bytes.isBase64)(encoded)) return null;
+  const decoded = new TextDecoder().decode((0, import_bytes.decodeBase64)(encoded));
+  const split = decoded.split(":");
+  return [split[0], split.slice(1).join(":")];
+}
+function encodeBasicAuthorizationHeader(id, password) {
+  if (id.includes(":")) throw new Error("Basic authorization header id cannot contain ':'");
+  return `Basic ${(0, import_bytes.encodeBase64)(new TextEncoder().encode(`${id}:${password}`))}`;
 }
-import.meta.vitest?.test("encodeBasicAuthorizationHeader", ({ expect }) => {
-    // Test with simple username and password
-    const encoded = encodeBasicAuthorizationHeader("user", "pass");
-    expect(encoded).toMatch(/^Basic [A-Za-z0-9+/=]+$/); // Should start with "Basic " followed by base64
-    // Test with empty password
-    const encodedEmptyPass = encodeBasicAuthorizationHeader("user", "");
-    expect(encodedEmptyPass).toMatch(/^Basic [A-Za-z0-9+/=]+$/);
-    // Test with password containing special characters
-    const encodedSpecialChars = encodeBasicAuthorizationHeader("user", "p@ss!w0rd");
-    expect(encodedSpecialChars).toMatch(/^Basic [A-Za-z0-9+/=]+$/);
-    // Test with username containing colon should throw
-    expect(() => encodeBasicAuthorizationHeader("user:name", "pass")).toThrow();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HTTP_METHODS,
+  decodeBasicAuthorizationHeader,
+  encodeBasicAuthorizationHeader
 });
+//# sourceMappingURL=http.js.map

package/dist/utils/http.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/http.tsx"],"sourcesContent":["import { decodeBase64, encodeBase64, isBase64 } from \"./bytes\";\n\nexport const HTTP_METHODS = {\n  \"GET\": {\n    safe: true,\n    idempotent: true,\n  },\n  \"POST\": {\n    safe: false,\n    idempotent: false,\n  },\n  \"PUT\": {\n    safe: false,\n    idempotent: true,\n  },\n  \"DELETE\": {\n    safe: false,\n    idempotent: true,\n  },\n  \"PATCH\": {\n    safe: false,\n    idempotent: false,\n  },\n  \"OPTIONS\": {\n    safe: true,\n    idempotent: true,\n  },\n  \"HEAD\": {\n    safe: true,\n    idempotent: true,\n  },\n  \"TRACE\": {\n    safe: true,\n    idempotent: true,\n  },\n  \"CONNECT\": {\n    safe: false,\n    idempotent: false,\n  },\n} as const;\nexport type HttpMethod = keyof typeof HTTP_METHODS;\n\nexport function decodeBasicAuthorizationHeader(value: string): [string, string] | null {\n  const [type, encoded, ...rest] = value.split(' ');\n  if (rest.length > 0) return null;\n  if (!encoded) return null;\n  if (type !== 'Basic') return null;\n  if (!isBase64(encoded)) return null;\n  const decoded = new TextDecoder().decode(decodeBase64(encoded));\n  const split = decoded.split(':');\n  return [split[0], split.slice(1).join(':')];\n}\nundefined?.test(\"decodeBasicAuthorizationHeader\", ({ expect }) => {\n  // Test with valid Basic Authorization header\n  const username = \"user\";\n  const password = \"pass\";\n  const encoded = encodeBasicAuthorizationHeader(username, password);\n  expect(decodeBasicAuthorizationHeader(encoded)).toEqual([username, password]);\n\n  // Test with password containing colons\n  const complexPassword = \"pass:with:colons\";\n  const encodedComplex = encodeBasicAuthorizationHeader(username, complexPassword);\n  expect(decodeBasicAuthorizationHeader(encodedComplex)).toEqual([username, complexPassword]);\n\n  // Test with invalid headers\n  expect(decodeBasicAuthorizationHeader(\"NotBasic dXNlcjpwYXNz\")).toBe(null); // Wrong type\n  expect(decodeBasicAuthorizationHeader(\"Basic\")).toBe(null); // Missing encoded part\n  expect(decodeBasicAuthorizationHeader(\"Basic not-base64\")).toBe(null); // Not base64\n  expect(decodeBasicAuthorizationHeader(\"Basic dXNlcjpwYXNz extra\")).toBe(null); // Extra parts\n});\n\nexport function encodeBasicAuthorizationHeader(id: string, password: string): string {\n  if (id.includes(':')) throw new Error(\"Basic authorization header id cannot contain ':'\");\n  return `Basic ${encodeBase64(new TextEncoder().encode(`${id}:${password}`))}`;\n}\nundefined?.test(\"encodeBasicAuthorizationHeader\", ({ expect }) => {\n  // Test with simple username and password\n  const encoded = encodeBasicAuthorizationHeader(\"user\", \"pass\");\n  expect(encoded).toMatch(/^Basic [A-Za-z0-9+/=]+$/); // Should start with \"Basic \" followed by base64\n\n  // Test with empty password\n  const encodedEmptyPass = encodeBasicAuthorizationHeader(\"user\", \"\");\n  expect(encodedEmptyPass).toMatch(/^Basic [A-Za-z0-9+/=]+$/);\n\n  // Test with password containing special characters\n  const encodedSpecialChars = encodeBasicAuthorizationHeader(\"user\", \"p@ss!w0rd\");\n  expect(encodedSpecialChars).toMatch(/^Basic [A-Za-z0-9+/=]+$/);\n\n  // Test with username containing colon should throw\n  expect(() => encodeBasicAuthorizationHeader(\"user:name\", \"pass\")).toThrow();\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAqD;AAE9C,IAAM,eAAe;AAAA,EAC1B,OAAO;AAAA,IACL,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AAAA,EACA,QAAQ;AAAA,IACN,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AAAA,EACA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AAAA,EACA,UAAU;AAAA,IACR,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AAAA,EACA,SAAS;AAAA,IACP,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AAAA,EACA,WAAW;AAAA,IACT,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AAAA,EACA,QAAQ;AAAA,IACN,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AAAA,EACA,SAAS;AAAA,IACP,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AAAA,EACA,WAAW;AAAA,IACT,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AACF;AAGO,SAAS,+BAA+B,OAAwC;AACrF,QAAM,CAAC,MAAM,SAAS,GAAG,IAAI,IAAI,MAAM,MAAM,GAAG;AAChD,MAAI,KAAK,SAAS,EAAG,QAAO;AAC5B,MAAI,CAAC,QAAS,QAAO;AACrB,MAAI,SAAS,QAAS,QAAO;AAC7B,MAAI,KAAC,uBAAS,OAAO,EAAG,QAAO;AAC/B,QAAM,UAAU,IAAI,YAAY,EAAE,WAAO,2BAAa,OAAO,CAAC;AAC9D,QAAM,QAAQ,QAAQ,MAAM,GAAG;AAC/B,SAAO,CAAC,MAAM,CAAC,GAAG,MAAM,MAAM,CAAC,EAAE,KAAK,GAAG,CAAC;AAC5C;AAoBO,SAAS,+BAA+B,IAAY,UAA0B;AACnF,MAAI,GAAG,SAAS,GAAG,EAAG,OAAM,IAAI,MAAM,kDAAkD;AACxF,SAAO,aAAS,2BAAa,IAAI,YAAY,EAAE,OAAO,GAAG,EAAE,IAAI,QAAQ,EAAE,CAAC,CAAC;AAC7E;","names":[]}

package/dist/utils/ips.d.cts

@@ -0,0 +1,6 @@
+type Ipv4Address = `${number}.${number}.${number}.${number}`;
+type Ipv6Address = string;
+declare function isIpAddress(ip: string): ip is Ipv4Address | Ipv6Address;
+declare function assertIpAddress(ip: string): asserts ip is Ipv4Address | Ipv6Address;
+
+export { type Ipv4Address, type Ipv6Address, assertIpAddress, isIpAddress };

package/dist/utils/ips.d.ts

@@ -1,4 +1,6 @@
-export type Ipv4Address = `${number}.${number}.${number}.${number}`;
-export type Ipv6Address = string;
-export declare function isIpAddress(ip: string): ip is Ipv4Address | Ipv6Address;
-export declare function assertIpAddress(ip: string): asserts ip is Ipv4Address | Ipv6Address;
+type Ipv4Address = `${number}.${number}.${number}.${number}`;
+type Ipv6Address = string;
+declare function isIpAddress(ip: string): ip is Ipv4Address | Ipv6Address;
+declare function assertIpAddress(ip: string): asserts ip is Ipv4Address | Ipv6Address;
+
+export { type Ipv4Address, type Ipv6Address, assertIpAddress, isIpAddress };

package/dist/utils/ips.js

@@ -1,38 +1,51 @@
-import ipRegex from "ip-regex";
-export function isIpAddress(ip) {
-    return ipRegex({ exact: true }).test(ip);
-}
-import.meta.vitest?.test("isIpAddress", ({ expect }) => {
-    // Test valid IPv4 addresses
-    expect(isIpAddress("192.168.1.1")).toBe(true);
-    expect(isIpAddress("127.0.0.1")).toBe(true);
-    expect(isIpAddress("0.0.0.0")).toBe(true);
-    expect(isIpAddress("255.255.255.255")).toBe(true);
-    // Test valid IPv6 addresses
-    expect(isIpAddress("::1")).toBe(true);
-    expect(isIpAddress("2001:db8::")).toBe(true);
-    expect(isIpAddress("2001:db8:85a3:8d3:1319:8a2e:370:7348")).toBe(true);
-    // Test invalid IP addresses
-    expect(isIpAddress("")).toBe(false);
-    expect(isIpAddress("not an ip")).toBe(false);
-    expect(isIpAddress("256.256.256.256")).toBe(false);
-    expect(isIpAddress("192.168.1")).toBe(false);
-    expect(isIpAddress("192.168.1.1.1")).toBe(false);
-    expect(isIpAddress("2001:db8::xyz")).toBe(false);
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/ips.tsx
+var ips_exports = {};
+__export(ips_exports, {
+  assertIpAddress: () => assertIpAddress,
+  isIpAddress: () => isIpAddress
 });
-export function assertIpAddress(ip) {
-    if (!isIpAddress(ip)) {
-        throw new Error(`Invalid IP address: ${ip}`);
-    }
+module.exports = __toCommonJS(ips_exports);
+var import_ip_regex = __toESM(require("ip-regex"), 1);
+function isIpAddress(ip) {
+  return (0, import_ip_regex.default)({ exact: true }).test(ip);
+}
+function assertIpAddress(ip) {
+  if (!isIpAddress(ip)) {
+    throw new Error(`Invalid IP address: ${ip}`);
+  }
 }
-import.meta.vitest?.test("assertIpAddress", ({ expect }) => {
-    // Test with valid IPv4 address
-    expect(() => assertIpAddress("192.168.1.1")).not.toThrow();
-    // Test with valid IPv6 address
-    expect(() => assertIpAddress("::1")).not.toThrow();
-    // Test with invalid IP addresses
-    expect(() => assertIpAddress("")).toThrow("Invalid IP address: ");
-    expect(() => assertIpAddress("not an ip")).toThrow("Invalid IP address: not an ip");
-    expect(() => assertIpAddress("256.256.256.256")).toThrow("Invalid IP address: 256.256.256.256");
-    expect(() => assertIpAddress("192.168.1")).toThrow("Invalid IP address: 192.168.1");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertIpAddress,
+  isIpAddress
 });
+//# sourceMappingURL=ips.js.map

package/dist/utils/ips.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/ips.tsx"],"sourcesContent":["import ipRegex from \"ip-regex\";\n\nexport type Ipv4Address = `${number}.${number}.${number}.${number}`;\nexport type Ipv6Address = string;\n\nexport function isIpAddress(ip: string): ip is Ipv4Address | Ipv6Address {\n  return ipRegex({ exact: true }).test(ip);\n}\nundefined?.test(\"isIpAddress\", ({ expect }) => {\n  // Test valid IPv4 addresses\n  expect(isIpAddress(\"192.168.1.1\")).toBe(true);\n  expect(isIpAddress(\"127.0.0.1\")).toBe(true);\n  expect(isIpAddress(\"0.0.0.0\")).toBe(true);\n  expect(isIpAddress(\"255.255.255.255\")).toBe(true);\n\n  // Test valid IPv6 addresses\n  expect(isIpAddress(\"::1\")).toBe(true);\n  expect(isIpAddress(\"2001:db8::\")).toBe(true);\n  expect(isIpAddress(\"2001:db8:85a3:8d3:1319:8a2e:370:7348\")).toBe(true);\n\n  // Test invalid IP addresses\n  expect(isIpAddress(\"\")).toBe(false);\n  expect(isIpAddress(\"not an ip\")).toBe(false);\n  expect(isIpAddress(\"256.256.256.256\")).toBe(false);\n  expect(isIpAddress(\"192.168.1\")).toBe(false);\n  expect(isIpAddress(\"192.168.1.1.1\")).toBe(false);\n  expect(isIpAddress(\"2001:db8::xyz\")).toBe(false);\n});\n\nexport function assertIpAddress(ip: string): asserts ip is Ipv4Address | Ipv6Address {\n  if (!isIpAddress(ip)) {\n    throw new Error(`Invalid IP address: ${ip}`);\n  }\n}\nundefined?.test(\"assertIpAddress\", ({ expect }) => {\n  // Test with valid IPv4 address\n  expect(() => assertIpAddress(\"192.168.1.1\")).not.toThrow();\n\n  // Test with valid IPv6 address\n  expect(() => assertIpAddress(\"::1\")).not.toThrow();\n\n  // Test with invalid IP addresses\n  expect(() => assertIpAddress(\"\")).toThrow(\"Invalid IP address: \");\n  expect(() => assertIpAddress(\"not an ip\")).toThrow(\"Invalid IP address: not an ip\");\n  expect(() => assertIpAddress(\"256.256.256.256\")).toThrow(\"Invalid IP address: 256.256.256.256\");\n  expect(() => assertIpAddress(\"192.168.1\")).toThrow(\"Invalid IP address: 192.168.1\");\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sBAAoB;AAKb,SAAS,YAAY,IAA6C;AACvE,aAAO,gBAAAA,SAAQ,EAAE,OAAO,KAAK,CAAC,EAAE,KAAK,EAAE;AACzC;AAsBO,SAAS,gBAAgB,IAAqD;AACnF,MAAI,CAAC,YAAY,EAAE,GAAG;AACpB,UAAM,IAAI,MAAM,uBAAuB,EAAE,EAAE;AAAA,EAC7C;AACF;","names":["ipRegex"]}

package/dist/utils/json.d.cts

@@ -0,0 +1,13 @@
+import { Result } from './results.cjs';
+
+type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json;
+};
+type ReadonlyJson = null | boolean | number | string | readonly ReadonlyJson[] | {
+    readonly [key: string]: ReadonlyJson;
+};
+declare function isJson(value: unknown): value is Json;
+declare function parseJson(json: string): Result<Json>;
+declare function stringifyJson(json: Json): Result<string>;
+
+export { type Json, type ReadonlyJson, isJson, parseJson, stringifyJson };

package/dist/utils/json.d.ts

@@ -1,10 +1,13 @@
-import { Result } from "./results";
-export type Json = null | boolean | number | string | Json[] | {
+import { Result } from './results.js';
+
+type Json = null | boolean | number | string | Json[] | {
     [key: string]: Json;
 };
-export type ReadonlyJson = null | boolean | number | string | readonly ReadonlyJson[] | {
+type ReadonlyJson = null | boolean | number | string | readonly ReadonlyJson[] | {
     readonly [key: string]: ReadonlyJson;
 };
-export declare function isJson(value: unknown): value is Json;
-export declare function parseJson(json: string): Result<Json>;
-export declare function stringifyJson(json: Json): Result<string>;
+declare function isJson(value: unknown): value is Json;
+declare function parseJson(json: string): Result<Json>;
+declare function stringifyJson(json: Json): Result<string>;
+
+export { type Json, type ReadonlyJson, isJson, parseJson, stringifyJson };

package/dist/utils/json.js

@@ -1,161 +1,58 @@
-import { Result } from "./results";
-export function isJson(value) {
-    switch (typeof value) {
-        case "object": {
-            if (value === null)
-                return true;
-            if (Array.isArray(value))
-                return value.every(isJson);
-            return Object.keys(value).every(k => typeof k === "string") && Object.values(value).every(isJson);
-        }
-        case "string":
-        case "number":
-        case "boolean": {
-            return true;
-        }
-        default: {
-            return false;
-        }
-    }
-}
-import.meta.vitest?.test("isJson", ({ expect }) => {
-    // Test primitive values
-    expect(isJson(null)).toBe(true);
-    expect(isJson(true)).toBe(true);
-    expect(isJson(false)).toBe(true);
-    expect(isJson(123)).toBe(true);
-    expect(isJson("string")).toBe(true);
-    // Test arrays
-    expect(isJson([])).toBe(true);
-    expect(isJson([1, 2, 3])).toBe(true);
-    expect(isJson(["a", "b", "c"])).toBe(true);
-    expect(isJson([1, "a", true, null])).toBe(true);
-    expect(isJson([1, [2, 3], { a: "b" }])).toBe(true);
-    // Test objects
-    expect(isJson({})).toBe(true);
-    expect(isJson({ a: 1, b: 2 })).toBe(true);
-    expect(isJson({ a: "string", b: true, c: null })).toBe(true);
-    expect(isJson({ a: [1, 2, 3], b: { c: "d" } })).toBe(true);
-    // Test invalid JSON values
-    expect(isJson(undefined)).toBe(false);
-    expect(isJson(() => { })).toBe(false);
-    expect(isJson(Symbol())).toBe(false);
-    expect(isJson(BigInt(123))).toBe(false);
-    // Test arrays with invalid JSON values
-    expect(isJson([1, undefined, 3])).toBe(false);
-    expect(isJson([1, () => { }, 3])).toBe(false);
-    // Test objects with invalid JSON values
-    expect(isJson({ a: 1, b: undefined })).toBe(false);
-    expect(isJson({ a: 1, b: () => { } })).toBe(false);
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/json.tsx
+var json_exports = {};
+__export(json_exports, {
+  isJson: () => isJson,
+  parseJson: () => parseJson,
+  stringifyJson: () => stringifyJson
 });
-export function parseJson(json) {
-    return Result.fromThrowing(() => JSON.parse(json));
+module.exports = __toCommonJS(json_exports);
+var import_results = require("./results");
+function isJson(value) {
+  switch (typeof value) {
+    case "object": {
+      if (value === null) return true;
+      if (Array.isArray(value)) return value.every(isJson);
+      return Object.keys(value).every((k) => typeof k === "string") && Object.values(value).every(isJson);
+    }
+    case "string":
+    case "number":
+    case "boolean": {
+      return true;
+    }
+    default: {
+      return false;
+    }
+  }
 }
-import.meta.vitest?.test("parseJson", ({ expect }) => {
-    // Test valid JSON strings
-    const nullResult = parseJson("null");
-    expect(nullResult.status).toBe("ok");
-    if (nullResult.status === "ok") {
-        expect(nullResult.data).toBe(null);
-    }
-    const trueResult = parseJson("true");
-    expect(trueResult.status).toBe("ok");
-    if (trueResult.status === "ok") {
-        expect(trueResult.data).toBe(true);
-    }
-    const numberResult = parseJson("123");
-    expect(numberResult.status).toBe("ok");
-    if (numberResult.status === "ok") {
-        expect(numberResult.data).toBe(123);
-    }
-    const stringResult = parseJson('"string"');
-    expect(stringResult.status).toBe("ok");
-    if (stringResult.status === "ok") {
-        expect(stringResult.data).toBe("string");
-    }
-    const emptyArrayResult = parseJson("[]");
-    expect(emptyArrayResult.status).toBe("ok");
-    if (emptyArrayResult.status === "ok") {
-        expect(emptyArrayResult.data).toEqual([]);
-    }
-    const arrayResult = parseJson("[1,2,3]");
-    expect(arrayResult.status).toBe("ok");
-    if (arrayResult.status === "ok") {
-        expect(arrayResult.data).toEqual([1, 2, 3]);
-    }
-    const emptyObjectResult = parseJson("{}");
-    expect(emptyObjectResult.status).toBe("ok");
-    if (emptyObjectResult.status === "ok") {
-        expect(emptyObjectResult.data).toEqual({});
-    }
-    const objectResult = parseJson('{"a":1,"b":"string"}');
-    expect(objectResult.status).toBe("ok");
-    if (objectResult.status === "ok") {
-        expect(objectResult.data).toEqual({ a: 1, b: "string" });
-    }
-    // Test invalid JSON strings
-    expect(parseJson("").status).toBe("error");
-    expect(parseJson("undefined").status).toBe("error");
-    expect(parseJson("{").status).toBe("error");
-    expect(parseJson('{"a":1,}').status).toBe("error");
-    expect(parseJson("function(){}").status).toBe("error");
-});
-export function stringifyJson(json) {
-    return Result.fromThrowing(() => JSON.stringify(json));
+function parseJson(json) {
+  return import_results.Result.fromThrowing(() => JSON.parse(json));
 }
-import.meta.vitest?.test("stringifyJson", ({ expect }) => {
-    // Test primitive values
-    const nullResult = stringifyJson(null);
-    expect(nullResult.status).toBe("ok");
-    if (nullResult.status === "ok") {
-        expect(nullResult.data).toBe("null");
-    }
-    const trueResult = stringifyJson(true);
-    expect(trueResult.status).toBe("ok");
-    if (trueResult.status === "ok") {
-        expect(trueResult.data).toBe("true");
-    }
-    const numberResult = stringifyJson(123);
-    expect(numberResult.status).toBe("ok");
-    if (numberResult.status === "ok") {
-        expect(numberResult.data).toBe("123");
-    }
-    const stringResult = stringifyJson("string");
-    expect(stringResult.status).toBe("ok");
-    if (stringResult.status === "ok") {
-        expect(stringResult.data).toBe('"string"');
-    }
-    // Test arrays
-    const emptyArrayResult = stringifyJson([]);
-    expect(emptyArrayResult.status).toBe("ok");
-    if (emptyArrayResult.status === "ok") {
-        expect(emptyArrayResult.data).toBe("[]");
-    }
-    const arrayResult = stringifyJson([1, 2, 3]);
-    expect(arrayResult.status).toBe("ok");
-    if (arrayResult.status === "ok") {
-        expect(arrayResult.data).toBe("[1,2,3]");
-    }
-    // Test objects
-    const emptyObjectResult = stringifyJson({});
-    expect(emptyObjectResult.status).toBe("ok");
-    if (emptyObjectResult.status === "ok") {
-        expect(emptyObjectResult.data).toBe("{}");
-    }
-    const objectResult = stringifyJson({ a: 1, b: "string" });
-    expect(objectResult.status).toBe("ok");
-    if (objectResult.status === "ok") {
-        expect(objectResult.data).toBe('{"a":1,"b":"string"}');
-    }
-    // Test nested structures
-    const nested = { a: [1, 2, 3], b: { c: "d" } };
-    const nestedResult = stringifyJson(nested);
-    expect(nestedResult.status).toBe("ok");
-    if (nestedResult.status === "ok") {
-        expect(nestedResult.data).toBe('{"a":[1,2,3],"b":{"c":"d"}}');
-    }
-    // Test circular references (should error)
-    const circular = { a: 1 };
-    circular.self = circular;
-    expect(stringifyJson(circular).status).toBe("error");
+function stringifyJson(json) {
+  return import_results.Result.fromThrowing(() => JSON.stringify(json));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isJson,
+  parseJson,
+  stringifyJson
 });
+//# sourceMappingURL=json.js.map

package/dist/utils/json.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/json.tsx"],"sourcesContent":["import { Result } from \"./results\";\n\nexport type Json =\n  | null\n  | boolean\n  | number\n  | string\n  | Json[]\n  | { [key: string]: Json };\n\nexport type ReadonlyJson =\n  | null\n  | boolean\n  | number\n  | string\n  | readonly ReadonlyJson[]\n  | { readonly [key: string]: ReadonlyJson };\n\nexport function isJson(value: unknown): value is Json {\n  switch (typeof value) {\n    case \"object\": {\n      if (value === null) return true;\n      if (Array.isArray(value)) return value.every(isJson);\n      return Object.keys(value).every(k => typeof k === \"string\") && Object.values(value).every(isJson);\n    }\n    case \"string\":\n    case \"number\":\n    case \"boolean\": {\n      return true;\n    }\n    default: {\n      return false;\n    }\n  }\n}\nundefined?.test(\"isJson\", ({ expect }) => {\n  // Test primitive values\n  expect(isJson(null)).toBe(true);\n  expect(isJson(true)).toBe(true);\n  expect(isJson(false)).toBe(true);\n  expect(isJson(123)).toBe(true);\n  expect(isJson(\"string\")).toBe(true);\n\n  // Test arrays\n  expect(isJson([])).toBe(true);\n  expect(isJson([1, 2, 3])).toBe(true);\n  expect(isJson([\"a\", \"b\", \"c\"])).toBe(true);\n  expect(isJson([1, \"a\", true, null])).toBe(true);\n  expect(isJson([1, [2, 3], { a: \"b\" }])).toBe(true);\n\n  // Test objects\n  expect(isJson({})).toBe(true);\n  expect(isJson({ a: 1, b: 2 })).toBe(true);\n  expect(isJson({ a: \"string\", b: true, c: null })).toBe(true);\n  expect(isJson({ a: [1, 2, 3], b: { c: \"d\" } })).toBe(true);\n\n  // Test invalid JSON values\n  expect(isJson(undefined)).toBe(false);\n  expect(isJson(() => {})).toBe(false);\n  expect(isJson(Symbol())).toBe(false);\n  expect(isJson(BigInt(123))).toBe(false);\n\n  // Test arrays with invalid JSON values\n  expect(isJson([1, undefined, 3])).toBe(false);\n  expect(isJson([1, () => {}, 3])).toBe(false);\n\n  // Test objects with invalid JSON values\n  expect(isJson({ a: 1, b: undefined })).toBe(false);\n  expect(isJson({ a: 1, b: () => {} })).toBe(false);\n});\n\nexport function parseJson(json: string): Result<Json> {\n  return Result.fromThrowing(() => JSON.parse(json));\n}\nundefined?.test(\"parseJson\", ({ expect }) => {\n  // Test valid JSON strings\n  const nullResult = parseJson(\"null\");\n  expect(nullResult.status).toBe(\"ok\");\n  if (nullResult.status === \"ok\") {\n    expect(nullResult.data).toBe(null);\n  }\n\n  const trueResult = parseJson(\"true\");\n  expect(trueResult.status).toBe(\"ok\");\n  if (trueResult.status === \"ok\") {\n    expect(trueResult.data).toBe(true);\n  }\n\n  const numberResult = parseJson(\"123\");\n  expect(numberResult.status).toBe(\"ok\");\n  if (numberResult.status === \"ok\") {\n    expect(numberResult.data).toBe(123);\n  }\n\n  const stringResult = parseJson('\"string\"');\n  expect(stringResult.status).toBe(\"ok\");\n  if (stringResult.status === \"ok\") {\n    expect(stringResult.data).toBe(\"string\");\n  }\n\n  const emptyArrayResult = parseJson(\"[]\");\n  expect(emptyArrayResult.status).toBe(\"ok\");\n  if (emptyArrayResult.status === \"ok\") {\n    expect(emptyArrayResult.data).toEqual([]);\n  }\n\n  const arrayResult = parseJson(\"[1,2,3]\");\n  expect(arrayResult.status).toBe(\"ok\");\n  if (arrayResult.status === \"ok\") {\n    expect(arrayResult.data).toEqual([1, 2, 3]);\n  }\n\n  const emptyObjectResult = parseJson(\"{}\");\n  expect(emptyObjectResult.status).toBe(\"ok\");\n  if (emptyObjectResult.status === \"ok\") {\n    expect(emptyObjectResult.data).toEqual({});\n  }\n\n  const objectResult = parseJson('{\"a\":1,\"b\":\"string\"}');\n  expect(objectResult.status).toBe(\"ok\");\n  if (objectResult.status === \"ok\") {\n    expect(objectResult.data).toEqual({ a: 1, b: \"string\" });\n  }\n\n  // Test invalid JSON strings\n  expect(parseJson(\"\").status).toBe(\"error\");\n  expect(parseJson(\"undefined\").status).toBe(\"error\");\n  expect(parseJson(\"{\").status).toBe(\"error\");\n  expect(parseJson('{\"a\":1,}').status).toBe(\"error\");\n  expect(parseJson(\"function(){}\").status).toBe(\"error\");\n});\n\nexport function stringifyJson(json: Json): Result<string> {\n  return Result.fromThrowing(() => JSON.stringify(json));\n}\nundefined?.test(\"stringifyJson\", ({ expect }) => {\n  // Test primitive values\n  const nullResult = stringifyJson(null);\n  expect(nullResult.status).toBe(\"ok\");\n  if (nullResult.status === \"ok\") {\n    expect(nullResult.data).toBe(\"null\");\n  }\n\n  const trueResult = stringifyJson(true);\n  expect(trueResult.status).toBe(\"ok\");\n  if (trueResult.status === \"ok\") {\n    expect(trueResult.data).toBe(\"true\");\n  }\n\n  const numberResult = stringifyJson(123);\n  expect(numberResult.status).toBe(\"ok\");\n  if (numberResult.status === \"ok\") {\n    expect(numberResult.data).toBe(\"123\");\n  }\n\n  const stringResult = stringifyJson(\"string\");\n  expect(stringResult.status).toBe(\"ok\");\n  if (stringResult.status === \"ok\") {\n    expect(stringResult.data).toBe('\"string\"');\n  }\n\n  // Test arrays\n  const emptyArrayResult = stringifyJson([]);\n  expect(emptyArrayResult.status).toBe(\"ok\");\n  if (emptyArrayResult.status === \"ok\") {\n    expect(emptyArrayResult.data).toBe(\"[]\");\n  }\n\n  const arrayResult = stringifyJson([1, 2, 3]);\n  expect(arrayResult.status).toBe(\"ok\");\n  if (arrayResult.status === \"ok\") {\n    expect(arrayResult.data).toBe(\"[1,2,3]\");\n  }\n\n  // Test objects\n  const emptyObjectResult = stringifyJson({});\n  expect(emptyObjectResult.status).toBe(\"ok\");\n  if (emptyObjectResult.status === \"ok\") {\n    expect(emptyObjectResult.data).toBe(\"{}\");\n  }\n\n  const objectResult = stringifyJson({ a: 1, b: \"string\" });\n  expect(objectResult.status).toBe(\"ok\");\n  if (objectResult.status === \"ok\") {\n    expect(objectResult.data).toBe('{\"a\":1,\"b\":\"string\"}');\n  }\n\n  // Test nested structures\n  const nested = { a: [1, 2, 3], b: { c: \"d\" } };\n  const nestedResult = stringifyJson(nested);\n  expect(nestedResult.status).toBe(\"ok\");\n  if (nestedResult.status === \"ok\") {\n    expect(nestedResult.data).toBe('{\"a\":[1,2,3],\"b\":{\"c\":\"d\"}}');\n  }\n\n  // Test circular references (should error)\n  const circular: any = { a: 1 };\n  circular.self = circular;\n  expect(stringifyJson(circular).status).toBe(\"error\");\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAuB;AAkBhB,SAAS,OAAO,OAA+B;AACpD,UAAQ,OAAO,OAAO;AAAA,IACpB,KAAK,UAAU;AACb,UAAI,UAAU,KAAM,QAAO;AAC3B,UAAI,MAAM,QAAQ,KAAK,EAAG,QAAO,MAAM,MAAM,MAAM;AACnD,aAAO,OAAO,KAAK,KAAK,EAAE,MAAM,OAAK,OAAO,MAAM,QAAQ,KAAK,OAAO,OAAO,KAAK,EAAE,MAAM,MAAM;AAAA,IAClG;AAAA,IACA,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK,WAAW;AACd,aAAO;AAAA,IACT;AAAA,IACA,SAAS;AACP,aAAO;AAAA,IACT;AAAA,EACF;AACF;AAqCO,SAAS,UAAU,MAA4B;AACpD,SAAO,sBAAO,aAAa,MAAM,KAAK,MAAM,IAAI,CAAC;AACnD;AA2DO,SAAS,cAAc,MAA4B;AACxD,SAAO,sBAAO,aAAa,MAAM,KAAK,UAAU,IAAI,CAAC;AACvD;","names":[]}