@ai-matrx/kit 0.5.0

package/dist/json-format.d.cts

@@ -0,0 +1,148 @@
+/**
+ * Canonical JSON value types + narrowing guards.
+ *
+ * Ported (the subset this subpath needs) from matrx-frontend `types/json.ts` —
+ * the honest names for "this is just JSON" that are NOT `any` and NOT a bare
+ * `unknown`. The package must stand alone, so the types live here; a Matrx
+ * host keeps using its own `@/types/json` for app code and the two are
+ * structurally identical.
+ */
+type JsonPrimitive = string | number | boolean | null;
+/**
+ * A JSON object. Values are `JsonValue | undefined` so optional keys read
+ * cleanly (mirrors Supabase's original generated `Json` object member).
+ */
+interface JsonObject {
+    [key: string]: JsonValue | undefined;
+}
+type JsonArray = JsonValue[];
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+/**
+ * Narrow an `unknown` (e.g. a bare JSONB column) to a `JsonObject`.
+ * Plain object only — arrays and `null` return false.
+ */
+declare function isJsonObject(value: unknown): value is JsonObject;
+/** Narrow an `unknown` to a `JsonArray`. */
+declare function isJsonArray(value: unknown): value is JsonArray;
+/** Narrow an `unknown` to a JSON primitive (string | number | boolean | null). */
+declare function isJsonPrimitive(value: unknown): value is JsonPrimitive;
+
+/**
+ * How the JSON is laid out.
+ *
+ * - `minify`  — one line, zero optional whitespace. The smallest legal form.
+ * - `compact` — width-aware: any subtree that fits within `width` is inlined,
+ *               and sibling entries that fit are packed onto shared lines.
+ *               Readable AND small; this is the "scrunch it down" default.
+ * - `pretty`  — classic one-entry-per-line indentation.
+ */
+type JsonFormatStyle = "minify" | "compact" | "pretty";
+/** What to do with the markdown code fence around the JSON. */
+type JsonFenceMode = 
+/** Keep the fence exactly as it arrived (and add none if there was none). */
+"preserve"
+/** Remove the fence, leaving bare JSON. */
+ | "strip"
+/** Ensure a ```json fence, adding one if the source was bare. */
+ | "add";
+/** A markdown code fence wrapping the JSON payload. */
+interface JsonFence {
+    /** The opening marker as written, e.g. "```" or "~~~~". */
+    marker: string;
+    /** Info string after the marker, e.g. "json" (empty when the fence was bare). */
+    lang: string;
+    /** Whitespace the opening fence line was indented by. */
+    indent: string;
+    /** False when the source ran out before a closing fence (unterminated). */
+    closed: boolean;
+}
+/** Which JSON container sits at the root of the payload. */
+type JsonRootKind = "object" | "array" | "scalar";
+/** How permissively the payload had to be parsed. */
+type JsonParser = 
+/** Valid JSON — `JSON.parse` accepted it verbatim. */
+"strict"
+/** Only JSON5 accepted it: trailing commas, comments, unquoted keys, … */
+ | "tolerant";
+interface JsonDetection {
+    /** The payload parsed (strictly or tolerantly) into a value. */
+    ok: boolean;
+    /**
+     * The text is JSON-SHAPED even if it did not parse — it opens with `{`/`[`
+     * and closes with the matching bracket, or it arrived in a ```json fence.
+     * This is the gate for OFFERING json actions; `ok` is the gate for running
+     * them.
+     */
+    looksLikeJson: boolean;
+    /** The parsed value. Present only when `ok`. */
+    value?: JsonValue | undefined;
+    parser?: JsonParser | undefined;
+    /** Human-readable parse failure. Present only when `!ok`. */
+    error?: string | undefined;
+    /** The fence that was stripped before parsing, when the source had one. */
+    fence: JsonFence | null;
+    /** Text before the payload (fence excluded) — preserved verbatim on format. */
+    leading: string;
+    /** Text after the payload (fence excluded) — preserved verbatim on format. */
+    trailing: string;
+    /** The JSON text itself: fence and surrounding whitespace removed. */
+    payload: string;
+    root?: JsonRootKind | undefined;
+    /** Lines the payload currently occupies. */
+    lineCount: number;
+    /** Characters the payload currently occupies. */
+    charCount: number;
+}
+interface JsonFormatOptions {
+    style: JsonFormatStyle;
+    /** Spaces per indent level for `compact` / `pretty`. Default 2. */
+    indent?: number | undefined;
+    /** Target line width for `compact`. Default 100. Ignored otherwise. */
+    width?: number | undefined;
+    /** Sort object keys alphabetically at every depth. Default false. */
+    sortKeys?: boolean | undefined;
+    /** Fence handling. Default "preserve". */
+    fence?: JsonFenceMode | undefined;
+}
+/** Size of a chunk of text, for before/after reporting. */
+interface JsonTextSize {
+    lines: number;
+    chars: number;
+}
+interface JsonFormatResult {
+    /** False when the text could not be parsed; `text` is then the input, unchanged. */
+    ok: boolean;
+    /** The re-formatted text (full input: leading + fence + payload + trailing). */
+    text: string;
+    error?: string | undefined;
+    /** True when `text` differs from the input. */
+    changed: boolean;
+    detection: JsonDetection;
+    before: JsonTextSize;
+    after: JsonTextSize;
+}
+
+/**
+ * Detect JSON in `text`. Never throws; a non-JSON string comes back with
+ * `ok: false` and `looksLikeJson: false`, which is the signal to offer nothing.
+ */
+declare function detectJson(text: string): JsonDetection;
+
+declare const DEFAULT_JSON_INDENT = 2;
+declare const DEFAULT_JSON_WIDTH = 100;
+/**
+ * Serialize a JSON value in one of the three styles. This is the entry point
+ * for callers that already HAVE a value (a DB JSONB blob, an API frame) and
+ * just want it laid out; text callers want {@link formatJsonText}.
+ */
+declare function stringifyJson(value: JsonValue, options: JsonFormatOptions): string;
+/**
+ * Format the JSON found in `text`, preserving everything around it.
+ *
+ * Never throws. When the text does not parse, the result is `ok: false`,
+ * `changed: false`, and `text` is the input verbatim — a formatter that
+ * mangles text it did not understand is a data-loss bug.
+ */
+declare function formatJsonText(text: string, options: JsonFormatOptions): JsonFormatResult;
+
+export { DEFAULT_JSON_INDENT, DEFAULT_JSON_WIDTH, type JsonArray, type JsonDetection, type JsonFence, type JsonFenceMode, type JsonFormatOptions, type JsonFormatResult, type JsonFormatStyle, type JsonObject, type JsonParser, type JsonPrimitive, type JsonRootKind, type JsonTextSize, type JsonValue, detectJson, formatJsonText, isJsonArray, isJsonObject, isJsonPrimitive, stringifyJson };

package/dist/json-format.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Canonical JSON value types + narrowing guards.
+ *
+ * Ported (the subset this subpath needs) from matrx-frontend `types/json.ts` —
+ * the honest names for "this is just JSON" that are NOT `any` and NOT a bare
+ * `unknown`. The package must stand alone, so the types live here; a Matrx
+ * host keeps using its own `@/types/json` for app code and the two are
+ * structurally identical.
+ */
+type JsonPrimitive = string | number | boolean | null;
+/**
+ * A JSON object. Values are `JsonValue | undefined` so optional keys read
+ * cleanly (mirrors Supabase's original generated `Json` object member).
+ */
+interface JsonObject {
+    [key: string]: JsonValue | undefined;
+}
+type JsonArray = JsonValue[];
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+/**
+ * Narrow an `unknown` (e.g. a bare JSONB column) to a `JsonObject`.
+ * Plain object only — arrays and `null` return false.
+ */
+declare function isJsonObject(value: unknown): value is JsonObject;
+/** Narrow an `unknown` to a `JsonArray`. */
+declare function isJsonArray(value: unknown): value is JsonArray;
+/** Narrow an `unknown` to a JSON primitive (string | number | boolean | null). */
+declare function isJsonPrimitive(value: unknown): value is JsonPrimitive;
+
+/**
+ * How the JSON is laid out.
+ *
+ * - `minify`  — one line, zero optional whitespace. The smallest legal form.
+ * - `compact` — width-aware: any subtree that fits within `width` is inlined,
+ *               and sibling entries that fit are packed onto shared lines.
+ *               Readable AND small; this is the "scrunch it down" default.
+ * - `pretty`  — classic one-entry-per-line indentation.
+ */
+type JsonFormatStyle = "minify" | "compact" | "pretty";
+/** What to do with the markdown code fence around the JSON. */
+type JsonFenceMode = 
+/** Keep the fence exactly as it arrived (and add none if there was none). */
+"preserve"
+/** Remove the fence, leaving bare JSON. */
+ | "strip"
+/** Ensure a ```json fence, adding one if the source was bare. */
+ | "add";
+/** A markdown code fence wrapping the JSON payload. */
+interface JsonFence {
+    /** The opening marker as written, e.g. "```" or "~~~~". */
+    marker: string;
+    /** Info string after the marker, e.g. "json" (empty when the fence was bare). */
+    lang: string;
+    /** Whitespace the opening fence line was indented by. */
+    indent: string;
+    /** False when the source ran out before a closing fence (unterminated). */
+    closed: boolean;
+}
+/** Which JSON container sits at the root of the payload. */
+type JsonRootKind = "object" | "array" | "scalar";
+/** How permissively the payload had to be parsed. */
+type JsonParser = 
+/** Valid JSON — `JSON.parse` accepted it verbatim. */
+"strict"
+/** Only JSON5 accepted it: trailing commas, comments, unquoted keys, … */
+ | "tolerant";
+interface JsonDetection {
+    /** The payload parsed (strictly or tolerantly) into a value. */
+    ok: boolean;
+    /**
+     * The text is JSON-SHAPED even if it did not parse — it opens with `{`/`[`
+     * and closes with the matching bracket, or it arrived in a ```json fence.
+     * This is the gate for OFFERING json actions; `ok` is the gate for running
+     * them.
+     */
+    looksLikeJson: boolean;
+    /** The parsed value. Present only when `ok`. */
+    value?: JsonValue | undefined;
+    parser?: JsonParser | undefined;
+    /** Human-readable parse failure. Present only when `!ok`. */
+    error?: string | undefined;
+    /** The fence that was stripped before parsing, when the source had one. */
+    fence: JsonFence | null;
+    /** Text before the payload (fence excluded) — preserved verbatim on format. */
+    leading: string;
+    /** Text after the payload (fence excluded) — preserved verbatim on format. */
+    trailing: string;
+    /** The JSON text itself: fence and surrounding whitespace removed. */
+    payload: string;
+    root?: JsonRootKind | undefined;
+    /** Lines the payload currently occupies. */
+    lineCount: number;
+    /** Characters the payload currently occupies. */
+    charCount: number;
+}
+interface JsonFormatOptions {
+    style: JsonFormatStyle;
+    /** Spaces per indent level for `compact` / `pretty`. Default 2. */
+    indent?: number | undefined;
+    /** Target line width for `compact`. Default 100. Ignored otherwise. */
+    width?: number | undefined;
+    /** Sort object keys alphabetically at every depth. Default false. */
+    sortKeys?: boolean | undefined;
+    /** Fence handling. Default "preserve". */
+    fence?: JsonFenceMode | undefined;
+}
+/** Size of a chunk of text, for before/after reporting. */
+interface JsonTextSize {
+    lines: number;
+    chars: number;
+}
+interface JsonFormatResult {
+    /** False when the text could not be parsed; `text` is then the input, unchanged. */
+    ok: boolean;
+    /** The re-formatted text (full input: leading + fence + payload + trailing). */
+    text: string;
+    error?: string | undefined;
+    /** True when `text` differs from the input. */
+    changed: boolean;
+    detection: JsonDetection;
+    before: JsonTextSize;
+    after: JsonTextSize;
+}
+
+/**
+ * Detect JSON in `text`. Never throws; a non-JSON string comes back with
+ * `ok: false` and `looksLikeJson: false`, which is the signal to offer nothing.
+ */
+declare function detectJson(text: string): JsonDetection;
+
+declare const DEFAULT_JSON_INDENT = 2;
+declare const DEFAULT_JSON_WIDTH = 100;
+/**
+ * Serialize a JSON value in one of the three styles. This is the entry point
+ * for callers that already HAVE a value (a DB JSONB blob, an API frame) and
+ * just want it laid out; text callers want {@link formatJsonText}.
+ */
+declare function stringifyJson(value: JsonValue, options: JsonFormatOptions): string;
+/**
+ * Format the JSON found in `text`, preserving everything around it.
+ *
+ * Never throws. When the text does not parse, the result is `ok: false`,
+ * `changed: false`, and `text` is the input verbatim — a formatter that
+ * mangles text it did not understand is a data-loss bug.
+ */
+declare function formatJsonText(text: string, options: JsonFormatOptions): JsonFormatResult;
+
+export { DEFAULT_JSON_INDENT, DEFAULT_JSON_WIDTH, type JsonArray, type JsonDetection, type JsonFence, type JsonFenceMode, type JsonFormatOptions, type JsonFormatResult, type JsonFormatStyle, type JsonObject, type JsonParser, type JsonPrimitive, type JsonRootKind, type JsonTextSize, type JsonValue, detectJson, formatJsonText, isJsonArray, isJsonObject, isJsonPrimitive, stringifyJson };

package/dist/json-format.js

@@ -0,0 +1,286 @@
+// src/json-format/detect.ts
+import JSON5 from "json5";
+var FENCE_OPEN = /^([ \t]*)(`{3,}|~{3,})[ \t]*([^\s`~]*)[ \t]*$/;
+var JSON_FENCE_LANGS = /* @__PURE__ */ new Set(["json", "jsonc", "json5", "geojson", "jsonl"]);
+function splitFence(text) {
+  const lines = text.split("\n");
+  const openIdx = lines.findIndex((l) => FENCE_OPEN.test(l));
+  if (openIdx === -1) return null;
+  const open = FENCE_OPEN.exec(lines[openIdx] ?? "");
+  if (!open) return null;
+  const [, indent = "", marker = "```", lang = ""] = open;
+  const fenceChar = marker[0] ?? "`";
+  const closeRe = new RegExp(`^[ \\t]*\\${fenceChar}{${marker.length},}[ \\t]*$`);
+  let closeIdx = -1;
+  for (let i = openIdx + 1; i < lines.length; i++) {
+    if (closeRe.test(lines[i] ?? "")) {
+      closeIdx = i;
+      break;
+    }
+  }
+  const afterClose = closeIdx === -1 ? [] : lines.slice(closeIdx + 1);
+  if (afterClose.some((l) => FENCE_OPEN.test(l))) return null;
+  const bodyEnd = closeIdx === -1 ? lines.length : closeIdx;
+  return {
+    leading: openIdx > 0 ? `${lines.slice(0, openIdx).join("\n")}
+` : "",
+    payload: lines.slice(openIdx + 1, bodyEnd).join("\n"),
+    trailing: afterClose.length > 0 ? `
+${afterClose.join("\n")}` : "",
+    fence: {
+      marker,
+      lang: lang.toLowerCase(),
+      indent,
+      closed: closeIdx !== -1
+    }
+  };
+}
+function splitBare(text) {
+  const payload = text.trim();
+  if (payload === "") {
+    return { leading: text, payload: "", trailing: "", fence: null };
+  }
+  const start = text.indexOf(payload);
+  return {
+    leading: text.slice(0, start),
+    payload,
+    trailing: text.slice(start + payload.length),
+    fence: null
+  };
+}
+function rootKindOf(value) {
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "object" && value !== null) return "object";
+  return "scalar";
+}
+function isBracketShaped(payload) {
+  const first = payload[0];
+  const last = payload[payload.length - 1];
+  if (payload.length < 2) return false;
+  return first === "{" && last === "}" || first === "[" && last === "]";
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : "Invalid JSON";
+}
+function countLines(s) {
+  if (s === "") return 0;
+  let n = 1;
+  for (let i = 0; i < s.length; i++) if (s[i] === "\n") n++;
+  return n;
+}
+function detectJson(text) {
+  const split = splitFence(text) ?? splitBare(text);
+  const payload = split.fence ? split.payload.trim() : split.payload;
+  const fenceSaysJson = split.fence !== null && (split.fence.lang === "" || JSON_FENCE_LANGS.has(split.fence.lang));
+  const base = {
+    fence: split.fence,
+    leading: split.leading,
+    trailing: split.trailing,
+    payload,
+    lineCount: countLines(payload),
+    charCount: payload.length
+  };
+  if (payload === "") {
+    return { ...base, ok: false, looksLikeJson: false };
+  }
+  if (split.fence !== null && !fenceSaysJson) {
+    return { ...base, ok: false, looksLikeJson: false };
+  }
+  const shaped = isBracketShaped(payload);
+  let value;
+  let parser;
+  let error;
+  try {
+    value = JSON.parse(payload);
+    parser = "strict";
+  } catch (strictErr) {
+    try {
+      value = JSON5.parse(payload);
+      parser = "tolerant";
+    } catch {
+      error = errorMessage(strictErr);
+    }
+  }
+  if (value === void 0 || parser === void 0) {
+    return { ...base, ok: false, looksLikeJson: shaped, error };
+  }
+  const root = rootKindOf(value);
+  const worthOffering = root !== "scalar" || fenceSaysJson;
+  return { ...base, ok: true, looksLikeJson: worthOffering, value, parser, root };
+}
+
+// src/json-format/json-value.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJsonArray(value) {
+  return Array.isArray(value);
+}
+function isJsonPrimitive(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+
+// src/json-format/format.ts
+var DEFAULT_JSON_INDENT = 2;
+var DEFAULT_JSON_WIDTH = 100;
+function orderedKeys(obj, sortKeys) {
+  const keys = Object.keys(obj).filter((k) => obj[k] !== void 0);
+  return sortKeys ? [...keys].sort((a, b) => a.localeCompare(b)) : keys;
+}
+function writeScalar(value) {
+  return JSON.stringify(value) ?? "null";
+}
+function flatten(value, cfg) {
+  if (isJsonArray(value)) {
+    if (value.length === 0) return "[]";
+    const parts = value.map((v) => flatten(v ?? null, cfg));
+    return cfg.spaced ? `[${parts.join(", ")}]` : `[${parts.join(",")}]`;
+  }
+  if (isJsonObject(value)) {
+    const keys = orderedKeys(value, cfg.sortKeys);
+    if (keys.length === 0) return "{}";
+    const colon = cfg.spaced ? ": " : ":";
+    const parts = keys.map(
+      (k) => `${JSON.stringify(k)}${colon}${flatten(value[k] ?? null, cfg)}`
+    );
+    return cfg.spaced ? `{ ${parts.join(", ")} }` : `{${parts.join(",")}}`;
+  }
+  return writeScalar(value);
+}
+function layoutEntries(entries, pad, cfg) {
+  if (!cfg.pack) return entries.map((e) => pad + e);
+  const lines = [];
+  let current = "";
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i] ?? "";
+    const isLast = i === entries.length - 1;
+    const piece = isLast ? entry : `${entry},`;
+    if (entry.includes("\n")) {
+      if (current !== "") {
+        lines.push(pad + current);
+        current = "";
+      }
+      lines.push(pad + piece);
+      continue;
+    }
+    if (current === "") {
+      current = piece;
+      continue;
+    }
+    const merged = `${current} ${piece}`;
+    if (pad.length + merged.length <= cfg.width) {
+      current = merged;
+    } else {
+      lines.push(pad + current);
+      current = piece;
+    }
+  }
+  if (current !== "") lines.push(pad + current);
+  return lines;
+}
+function renderNode(value, level, used, cfg) {
+  const isContainer = isJsonArray(value) || isJsonObject(value);
+  if (!isContainer) return writeScalar(value);
+  const flat = flatten(value, cfg);
+  if (flat === "[]" || flat === "{}") return flat;
+  if (cfg.width >= 0 && used + flat.length <= cfg.width) return flat;
+  const pad = " ".repeat((level + 1) * cfg.indent);
+  const closePad = " ".repeat(level * cfg.indent);
+  if (isJsonArray(value)) {
+    const entries2 = value.map(
+      (v) => renderNode(v ?? null, level + 1, pad.length, cfg)
+    );
+    const body2 = layoutEntries(entries2, pad, cfg);
+    const joined2 = cfg.pack ? body2.join("\n") : body2.join(",\n");
+    return `[
+${joined2}
+${closePad}]`;
+  }
+  const keys = orderedKeys(value, cfg.sortKeys);
+  const entries = keys.map((k) => {
+    const prefix = `${JSON.stringify(k)}: `;
+    const rendered = renderNode(
+      value[k] ?? null,
+      level + 1,
+      pad.length + prefix.length,
+      cfg
+    );
+    return prefix + rendered;
+  });
+  const body = layoutEntries(entries, pad, cfg);
+  const joined = cfg.pack ? body.join("\n") : body.join(",\n");
+  return `{
+${joined}
+${closePad}}`;
+}
+function stringifyJson(value, options) {
+  const indent = options.indent ?? DEFAULT_JSON_INDENT;
+  const sortKeys = options.sortKeys ?? false;
+  if (options.style === "minify") {
+    return flatten(value, { indent, width: -1, pack: false, spaced: false, sortKeys });
+  }
+  const cfg = {
+    indent,
+    width: options.style === "pretty" ? -1 : options.width ?? DEFAULT_JSON_WIDTH,
+    pack: options.style === "compact",
+    spaced: true,
+    sortKeys
+  };
+  return renderNode(value, 0, 0, cfg);
+}
+function sizeOf(text) {
+  let lines = text === "" ? 0 : 1;
+  for (let i = 0; i < text.length; i++) if (text[i] === "\n") lines++;
+  return { lines, chars: text.length };
+}
+function reassemble(detection, payload, mode) {
+  const { fence, leading, trailing } = detection;
+  const keepFence = mode === "add" || mode === "preserve" && fence !== null;
+  if (!keepFence) {
+    return leading + payload + trailing;
+  }
+  const marker = fence?.marker ?? "```";
+  const lang = fence?.lang && fence.lang !== "" ? fence.lang : "json";
+  const indent = fence?.indent ?? "";
+  const body = indent ? payload.split("\n").map((l) => l === "" ? l : indent + l).join("\n") : payload;
+  const close = fence !== null && !fence.closed ? "" : `
+${indent}${marker}`;
+  return `${leading}${indent}${marker}${lang}
+${body}${close}${trailing}`;
+}
+function formatJsonText(text, options) {
+  const detection = detectJson(text);
+  const before = sizeOf(text);
+  if (!detection.ok || detection.value === void 0) {
+    return {
+      ok: false,
+      text,
+      error: detection.error ?? "Selection is not JSON.",
+      changed: false,
+      detection,
+      before,
+      after: before
+    };
+  }
+  const payload = stringifyJson(detection.value, options);
+  const next = reassemble(detection, payload, options.fence ?? "preserve");
+  return {
+    ok: true,
+    text: next,
+    changed: next !== text,
+    detection,
+    before,
+    after: sizeOf(next)
+  };
+}
+export {
+  DEFAULT_JSON_INDENT,
+  DEFAULT_JSON_WIDTH,
+  detectJson,
+  formatJsonText,
+  isJsonArray,
+  isJsonObject,
+  isJsonPrimitive,
+  stringifyJson
+};
+//# sourceMappingURL=json-format.js.map

package/dist/json-format.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/json-format/detect.ts","../src/json-format/json-value.ts","../src/json-format/format.ts"],"sourcesContent":["// json-format/detect.ts\n//\n// \"Is this text JSON, and where exactly does the JSON start and stop?\"\n//\n// The answer has to survive real-world selections: a fenced ```json block, a\n// bare pasted object, an object with a stray blank line above it, a fence the\n// user only half-selected. So detection splits the text into three parts —\n// leading / payload / trailing — and only the payload is ever re-formatted.\n// Everything outside it is restored verbatim, because a formatter that eats\n// the prose around the JSON is worse than no formatter at all.\n//\n// Two parse tiers: `JSON.parse` first (strict — what the value really is), then\n// JSON5 (tolerant — trailing commas, comments, unquoted keys, single quotes),\n// because the JSON people paste out of logs and code is frequently not legal\n// JSON. Tolerant parsing is reported, never hidden: a consumer that re-emits a\n// tolerantly-parsed value is normalizing it, and the caller can say so.\n//\n// Pure: no React / DOM. Never throws.\n//\n// Ported verbatim from matrx-frontend `lib/json-format/detect.ts`.\n\nimport JSON5 from \"json5\";\nimport type { JsonValue } from \"./json-value\";\nimport type {\n  JsonDetection,\n  JsonFence,\n  JsonParser,\n  JsonRootKind,\n} from \"./types\";\n\n/** Opening fence line: optional indent, 3+ backticks or tildes, optional info. */\nconst FENCE_OPEN = /^([ \\t]*)(`{3,}|~{3,})[ \\t]*([^\\s`~]*)[ \\t]*$/;\n\n/** Languages we treat as \"this fence contains JSON\". */\nconst JSON_FENCE_LANGS = new Set([\"json\", \"jsonc\", \"json5\", \"geojson\", \"jsonl\"]);\n\ninterface Split {\n  leading: string;\n  payload: string;\n  trailing: string;\n  fence: JsonFence | null;\n}\n\n/** Peel a markdown code fence off the text, if the text IS a fenced block. */\nfunction splitFence(text: string): Split | null {\n  const lines = text.split(\"\\n\");\n\n  // The fence may sit anywhere in the selection (a user highlighting a block\n  // plus the sentence above it is the common case) — but there must be exactly\n  // ONE block. Two fenced blocks in one selection is not a single JSON payload,\n  // and spanning them would splice unrelated content together.\n  const openIdx = lines.findIndex((l) => FENCE_OPEN.test(l));\n  if (openIdx === -1) return null;\n\n  const open = FENCE_OPEN.exec(lines[openIdx] ?? \"\");\n  if (!open) return null;\n  const [, indent = \"\", marker = \"```\", lang = \"\"] = open;\n  const fenceChar = marker[0] ?? \"`\";\n  const closeRe = new RegExp(`^[ \\\\t]*\\\\${fenceChar}{${marker.length},}[ \\\\t]*$`);\n\n  let closeIdx = -1;\n  for (let i = openIdx + 1; i < lines.length; i++) {\n    if (closeRe.test(lines[i] ?? \"\")) {\n      closeIdx = i;\n      break;\n    }\n  }\n\n  const afterClose = closeIdx === -1 ? [] : lines.slice(closeIdx + 1);\n  if (afterClose.some((l) => FENCE_OPEN.test(l))) return null;\n\n  const bodyEnd = closeIdx === -1 ? lines.length : closeIdx;\n  // The line separators bordering the fence belong to leading/trailing, so\n  // reassembly is a plain concatenation and blank lines survive it.\n  return {\n    leading: openIdx > 0 ? `${lines.slice(0, openIdx).join(\"\\n\")}\\n` : \"\",\n    payload: lines.slice(openIdx + 1, bodyEnd).join(\"\\n\"),\n    trailing: afterClose.length > 0 ? `\\n${afterClose.join(\"\\n\")}` : \"\",\n    fence: {\n      marker,\n      lang: lang.toLowerCase(),\n      indent,\n      closed: closeIdx !== -1,\n    },\n  };\n}\n\n/** Split bare (unfenced) text into surrounding whitespace + payload. */\nfunction splitBare(text: string): Split {\n  const payload = text.trim();\n  if (payload === \"\") {\n    return { leading: text, payload: \"\", trailing: \"\", fence: null };\n  }\n  const start = text.indexOf(payload);\n  return {\n    leading: text.slice(0, start),\n    payload,\n    trailing: text.slice(start + payload.length),\n    fence: null,\n  };\n}\n\nfunction rootKindOf(value: JsonValue): JsonRootKind {\n  if (Array.isArray(value)) return \"array\";\n  if (typeof value === \"object\" && value !== null) return \"object\";\n  return \"scalar\";\n}\n\n/** Bracket-shaped: opens and closes with a matching container delimiter. */\nfunction isBracketShaped(payload: string): boolean {\n  const first = payload[0];\n  const last = payload[payload.length - 1];\n  if (payload.length < 2) return false;\n  return (first === \"{\" && last === \"}\") || (first === \"[\" && last === \"]\");\n}\n\nfunction errorMessage(err: unknown): string {\n  return err instanceof Error ? err.message : \"Invalid JSON\";\n}\n\nfunction countLines(s: string): number {\n  if (s === \"\") return 0;\n  let n = 1;\n  for (let i = 0; i < s.length; i++) if (s[i] === \"\\n\") n++;\n  return n;\n}\n\n/**\n * Detect JSON in `text`. Never throws; a non-JSON string comes back with\n * `ok: false` and `looksLikeJson: false`, which is the signal to offer nothing.\n */\nexport function detectJson(text: string): JsonDetection {\n  const split = splitFence(text) ?? splitBare(text);\n  // A fenced block's body still carries its own indentation/blank lines.\n  const payload = split.fence ? split.payload.trim() : split.payload;\n\n  const fenceSaysJson =\n    split.fence !== null &&\n    (split.fence.lang === \"\" || JSON_FENCE_LANGS.has(split.fence.lang));\n\n  const base = {\n    fence: split.fence,\n    leading: split.leading,\n    trailing: split.trailing,\n    payload,\n    lineCount: countLines(payload),\n    charCount: payload.length,\n  };\n\n  if (payload === \"\") {\n    return { ...base, ok: false, looksLikeJson: false };\n  }\n\n  // A fence declaring a NON-JSON language is a hard no, even if the body would\n  // parse — reformatting the inside of a ```python block is not our business.\n  if (split.fence !== null && !fenceSaysJson) {\n    return { ...base, ok: false, looksLikeJson: false };\n  }\n\n  const shaped = isBracketShaped(payload);\n\n  let value: JsonValue | undefined;\n  let parser: JsonParser | undefined;\n  let error: string | undefined;\n  try {\n    value = JSON.parse(payload) as JsonValue;\n    parser = \"strict\";\n  } catch (strictErr) {\n    try {\n      value = JSON5.parse(payload) as JsonValue;\n      parser = \"tolerant\";\n    } catch {\n      error = errorMessage(strictErr);\n    }\n  }\n\n  if (value === undefined || parser === undefined) {\n    // Unparseable. Still \"looks like JSON\" when it is bracket-shaped, so a\n    // surface can show the actions and report the parse error on click rather\n    // than pretending the selection is ordinary prose.\n    return { ...base, ok: false, looksLikeJson: shaped, error };\n  }\n\n  const root = rootKindOf(value);\n  // A bare scalar (\"hello\", 42, true) parses but is not worth offering JSON\n  // actions on — every prose word that happens to be a number would qualify.\n  const worthOffering = root !== \"scalar\" || fenceSaysJson;\n\n  return { ...base, ok: true, looksLikeJson: worthOffering, value, parser, root };\n}\n","/**\n * Canonical JSON value types + narrowing guards.\n *\n * Ported (the subset this subpath needs) from matrx-frontend `types/json.ts` —\n * the honest names for \"this is just JSON\" that are NOT `any` and NOT a bare\n * `unknown`. The package must stand alone, so the types live here; a Matrx\n * host keeps using its own `@/types/json` for app code and the two are\n * structurally identical.\n */\n\nexport type JsonPrimitive = string | number | boolean | null;\n\n/**\n * A JSON object. Values are `JsonValue | undefined` so optional keys read\n * cleanly (mirrors Supabase's original generated `Json` object member).\n */\nexport interface JsonObject {\n  [key: string]: JsonValue | undefined;\n}\n\nexport type JsonArray = JsonValue[];\n\nexport type JsonValue = JsonPrimitive | JsonObject | JsonArray;\n\n/**\n * Narrow an `unknown` (e.g. a bare JSONB column) to a `JsonObject`.\n * Plain object only — arrays and `null` return false.\n */\nexport function isJsonObject(value: unknown): value is JsonObject {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\n/** Narrow an `unknown` to a `JsonArray`. */\nexport function isJsonArray(value: unknown): value is JsonArray {\n  return Array.isArray(value);\n}\n\n/** Narrow an `unknown` to a JSON primitive (string | number | boolean | null). */\nexport function isJsonPrimitive(value: unknown): value is JsonPrimitive {\n  return (\n    value === null ||\n    typeof value === \"string\" ||\n    typeof value === \"number\" ||\n    typeof value === \"boolean\"\n  );\n}\n","// json-format/format.ts\n//\n// The JSON writer. Three styles over one recursive printer:\n//\n//   minify  — one line, no optional whitespace.\n//   compact — width-aware FILL. Any subtree whose flat form fits the remaining\n//             columns is inlined; a subtree that does not fit expands, but its\n//             children are then PACKED onto shared lines while they fit. This\n//             is what turns an 11-line reference blob into 3 lines without\n//             turning it into an unreadable one-liner.\n//   pretty  — one entry per line (classic 2-space JSON).\n//\n// Why not `JSON.stringify(v, null, 2)`: it cannot inline, cannot pack, and\n// cannot sort keys. All three are the point.\n//\n// Pure: no React / DOM. Never throws — a parse failure comes back as a result\n// with `ok: false` and the input text unchanged.\n//\n// Ported verbatim from matrx-frontend `lib/json-format/format.ts`.\n\nimport type { JsonObject, JsonValue } from \"./json-value\";\nimport { isJsonArray, isJsonObject } from \"./json-value\";\nimport { detectJson } from \"./detect\";\nimport type {\n  JsonDetection,\n  JsonFormatOptions,\n  JsonFormatResult,\n  JsonTextSize,\n} from \"./types\";\n\nexport const DEFAULT_JSON_INDENT = 2;\nexport const DEFAULT_JSON_WIDTH = 100;\n\ninterface WriterConfig {\n  indent: number;\n  /** Target line width; `-1` disables inlining entirely (pretty). */\n  width: number;\n  /** Pack sibling entries onto shared lines (compact only). */\n  pack: boolean;\n  /** Spaces inside braces/brackets and after colons/commas. */\n  spaced: boolean;\n  sortKeys: boolean;\n}\n\nfunction orderedKeys(obj: JsonObject, sortKeys: boolean): string[] {\n  // `undefined` values are not JSON — JSON.stringify drops them, so do we.\n  const keys = Object.keys(obj).filter((k) => obj[k] !== undefined);\n  return sortKeys ? [...keys].sort((a, b) => a.localeCompare(b)) : keys;\n}\n\n/** Serialize a scalar exactly as JSON does. */\nfunction writeScalar(value: JsonValue): string {\n  // NaN / Infinity stringify to \"null\", matching JSON.stringify.\n  return JSON.stringify(value) ?? \"null\";\n}\n\n/** The whole subtree on one line. */\nfunction flatten(value: JsonValue, cfg: WriterConfig): string {\n  if (isJsonArray(value)) {\n    if (value.length === 0) return \"[]\";\n    const parts = value.map((v) => flatten(v ?? null, cfg));\n    return cfg.spaced ? `[${parts.join(\", \")}]` : `[${parts.join(\",\")}]`;\n  }\n  if (isJsonObject(value)) {\n    const keys = orderedKeys(value, cfg.sortKeys);\n    if (keys.length === 0) return \"{}\";\n    const colon = cfg.spaced ? \": \" : \":\";\n    const parts = keys.map(\n      (k) => `${JSON.stringify(k)}${colon}${flatten(value[k] ?? null, cfg)}`,\n    );\n    return cfg.spaced ? `{ ${parts.join(\", \")} }` : `{${parts.join(\",\")}}`;\n  }\n  return writeScalar(value);\n}\n\n/**\n * Lay out `entries` (already-rendered child texts) inside a container.\n * Single-line entries are packed together while they fit; a multi-line entry\n * always occupies its own line(s). Returns the body lines, unindented-prefixed\n * with `pad` already applied.\n */\nfunction layoutEntries(\n  entries: string[],\n  pad: string,\n  cfg: WriterConfig,\n): string[] {\n  if (!cfg.pack) return entries.map((e) => pad + e);\n\n  const lines: string[] = [];\n  let current = \"\";\n  for (let i = 0; i < entries.length; i++) {\n    const entry = entries[i] ?? \"\";\n    const isLast = i === entries.length - 1;\n    const piece = isLast ? entry : `${entry},`;\n\n    if (entry.includes(\"\\n\")) {\n      // Multi-line child: flush whatever is buffered, then stand alone.\n      if (current !== \"\") {\n        lines.push(pad + current);\n        current = \"\";\n      }\n      lines.push(pad + piece);\n      continue;\n    }\n\n    if (current === \"\") {\n      current = piece;\n      continue;\n    }\n    const merged = `${current} ${piece}`;\n    if (pad.length + merged.length <= cfg.width) {\n      current = merged;\n    } else {\n      lines.push(pad + current);\n      current = piece;\n    }\n  }\n  if (current !== \"\") lines.push(pad + current);\n  return lines;\n}\n\n/**\n * Render `value` starting at column `used` on its current line, at nesting\n * `level`. `used` includes the indentation AND any key prefix already written,\n * so the width budget is honest about `\"items\": [` style prefixes.\n */\nfunction renderNode(\n  value: JsonValue,\n  level: number,\n  used: number,\n  cfg: WriterConfig,\n): string {\n  const isContainer = isJsonArray(value) || isJsonObject(value);\n  if (!isContainer) return writeScalar(value);\n\n  const flat = flatten(value, cfg);\n  if (flat === \"[]\" || flat === \"{}\") return flat;\n  if (cfg.width >= 0 && used + flat.length <= cfg.width) return flat;\n\n  const pad = \" \".repeat((level + 1) * cfg.indent);\n  const closePad = \" \".repeat(level * cfg.indent);\n\n  if (isJsonArray(value)) {\n    const entries = value.map((v) =>\n      renderNode(v ?? null, level + 1, pad.length, cfg),\n    );\n    const body = layoutEntries(entries, pad, cfg);\n    const joined = cfg.pack ? body.join(\"\\n\") : body.join(\",\\n\");\n    return `[\\n${joined}\\n${closePad}]`;\n  }\n\n  const keys = orderedKeys(value, cfg.sortKeys);\n  const entries = keys.map((k) => {\n    const prefix = `${JSON.stringify(k)}: `;\n    const rendered = renderNode(\n      value[k] ?? null,\n      level + 1,\n      pad.length + prefix.length,\n      cfg,\n    );\n    return prefix + rendered;\n  });\n  const body = layoutEntries(entries, pad, cfg);\n  const joined = cfg.pack ? body.join(\"\\n\") : body.join(\",\\n\");\n  return `{\\n${joined}\\n${closePad}}`;\n}\n\n/**\n * Serialize a JSON value in one of the three styles. This is the entry point\n * for callers that already HAVE a value (a DB JSONB blob, an API frame) and\n * just want it laid out; text callers want {@link formatJsonText}.\n */\nexport function stringifyJson(\n  value: JsonValue,\n  options: JsonFormatOptions,\n): string {\n  const indent = options.indent ?? DEFAULT_JSON_INDENT;\n  const sortKeys = options.sortKeys ?? false;\n\n  if (options.style === \"minify\") {\n    return flatten(value, { indent, width: -1, pack: false, spaced: false, sortKeys });\n  }\n\n  const cfg: WriterConfig = {\n    indent,\n    width: options.style === \"pretty\" ? -1 : (options.width ?? DEFAULT_JSON_WIDTH),\n    pack: options.style === \"compact\",\n    spaced: true,\n    sortKeys,\n  };\n  return renderNode(value, 0, 0, cfg);\n}\n\nfunction sizeOf(text: string): JsonTextSize {\n  let lines = text === \"\" ? 0 : 1;\n  for (let i = 0; i < text.length; i++) if (text[i] === \"\\n\") lines++;\n  return { lines, chars: text.length };\n}\n\n/** Re-assemble the full text: leading + fence + formatted payload + trailing. */\nfunction reassemble(\n  detection: JsonDetection,\n  payload: string,\n  mode: NonNullable<JsonFormatOptions[\"fence\"]>,\n): string {\n  const { fence, leading, trailing } = detection;\n\n  const keepFence =\n    mode === \"add\" || (mode === \"preserve\" && fence !== null);\n  if (!keepFence) {\n    return leading + payload + trailing;\n  }\n\n  const marker = fence?.marker ?? \"```\";\n  const lang = fence?.lang && fence.lang !== \"\" ? fence.lang : \"json\";\n  const indent = fence?.indent ?? \"\";\n  const body = indent\n    ? payload\n        .split(\"\\n\")\n        .map((l) => (l === \"\" ? l : indent + l))\n        .join(\"\\n\")\n    : payload;\n\n  // An unterminated source fence stays unterminated — inventing a closing fence\n  // would change the surrounding document's structure, not just this block's.\n  const close = fence !== null && !fence.closed ? \"\" : `\\n${indent}${marker}`;\n  return `${leading}${indent}${marker}${lang}\\n${body}${close}${trailing}`;\n}\n\n/**\n * Format the JSON found in `text`, preserving everything around it.\n *\n * Never throws. When the text does not parse, the result is `ok: false`,\n * `changed: false`, and `text` is the input verbatim — a formatter that\n * mangles text it did not understand is a data-loss bug.\n */\nexport function formatJsonText(\n  text: string,\n  options: JsonFormatOptions,\n): JsonFormatResult {\n  const detection = detectJson(text);\n  const before = sizeOf(text);\n\n  if (!detection.ok || detection.value === undefined) {\n    return {\n      ok: false,\n      text,\n      error: detection.error ?? \"Selection is not JSON.\",\n      changed: false,\n      detection,\n      before,\n      after: before,\n    };\n  }\n\n  const payload = stringifyJson(detection.value, options);\n  const next = reassemble(detection, payload, options.fence ?? \"preserve\");\n\n  return {\n    ok: true,\n    text: next,\n    changed: next !== text,\n    detection,\n    before,\n    after: sizeOf(next),\n  };\n}\n"],"mappings":"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","names":["entries","body","joined"]}

package/dist/latest-request.cjs

@@ -0,0 +1,36 @@
+"use client";
+"use strict";
+"use client";
+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/latest-request.ts
+var latest_request_exports = {};
+__export(latest_request_exports, {
+  useLatestRequest: () => useLatestRequest
+});
+module.exports = __toCommonJS(latest_request_exports);
+var import_react = require("react");
+function useLatestRequest() {
+  const seqRef = (0, import_react.useRef)(0);
+  return (0, import_react.useCallback)(() => {
+    const mySeq = ++seqRef.current;
+    return () => mySeq === seqRef.current;
+  }, []);
+}
+//# sourceMappingURL=latest-request.cjs.map