@caseparts-org/caseblocks 0.0.193 → 0.0.195

package/dist/atoms/Markdown/Markdown.stories.d.ts

@@ -12,3 +12,5 @@ export default meta;
 type Story = StoryObj<typeof meta>;
 export declare const Basic: Story;
 export declare const ItemDescription: Story;
+export declare const Admonitions: Story;
+export declare const Playground: Story;

package/dist/atoms/Markdown/Markdown.stories.js

@@ -1,12 +1,43 @@
-import { jsx as t } from "react/jsx-runtime";
-import { Markdown as a } from "./Markdown.js";
-import { usePreprocessedMarkdown as m } from "./usePreprocessedMarkdown.js";
-const g = {
+import { jsx as t, jsxs as p } from "react/jsx-runtime";
+import { useState as u, useEffect as h } from "react";
+import { Markdown as s } from "./Markdown.js";
+import { usePreprocessedMarkdown as g } from "./usePreprocessedMarkdown.js";
+const x = {
   title: "Case Parts/Atoms/Markdown",
-  component: a,
+  component: s,
   parameters: { layout: "padded" },
   tags: ["autodocs"]
-}, x = {
+}, a = `# Admonitions
+
+:::warning[Electrical Hazard]{icon="bolt"}
+Disconnect power before servicing this unit.
+:::
+
+:::warning[Electrical Hazard]{icon="bolt"}
+
+Disconnect power before servicing this unit.
+
+:::
+`;
+function w(e) {
+  const [n, o] = u(e.children ?? a);
+  return h(() => {
+    o(e.children ?? a);
+  }, [e.children]), /* @__PURE__ */ p("div", { style: { display: "grid", gap: 12 }, children: [
+    /* @__PURE__ */ t("label", { style: { fontWeight: 600 }, children: "Edit Markdown (live):" }),
+    /* @__PURE__ */ t(
+      "textarea",
+      {
+        value: n,
+        onChange: (i) => o(i.target.value),
+        rows: 14,
+        style: { width: "100%", fontFamily: "monospace" }
+      }
+    ),
+    /* @__PURE__ */ t(s, { ...e, children: n })
+  ] });
+}
+const k = {
   args: {
     children: `# Heading 1
 
@@ -43,27 +74,66 @@ export default greet;
 |------:|:------|
 |  123  | text  |`
   }
-}, f = {
+}, C = {
   name: "Item Description Variant",
-  render: (o) => /* @__PURE__ */ t(({ text: n }) => {
-    const r = async (e) => {
-      if (await new Promise((l) => setTimeout(l, 50)), /^\d+$/.test(e)) return !0;
+  render: (e) => /* @__PURE__ */ t(({ text: i }) => {
+    const l = async (r) => {
+      if (await new Promise((m) => setTimeout(m, 50)), /^\d+$/.test(r)) return !0;
       throw new Error("invalid");
-    }, { output: s, loading: i } = m(
-      n,
-      (e) => `https://example.com/parts/${encodeURIComponent(e)}`,
-      r,
+    }, { output: d, loading: c } = g(
+      i,
+      (r) => `https://example.com/parts/${encodeURIComponent(r)}`,
+      l,
       !0
     );
-    return /* @__PURE__ */ t(a, { ...o, children: i ? "Validating…" : s });
+    return /* @__PURE__ */ t(s, { ...e, children: c ? "Validating…" : d });
   }, { text: `Kason 171 Latch
 
 This fits part [171] and an invalid token [bad]. Already linked should remain: [171](https://example.com/should-stay).
 
 Another valid numeric: [172].` })
+}, A = {
+  args: {
+    children: `# Admonitions
+
+:::note
+Confirm model and serial number before ordering.
+:::
+
+:::important[Compatibility]
+Fits only selected revisions.
+:::
+
+:::warning[Electrical Hazard]{icon="fa-solid fa-bolt"}
+Disconnect power before servicing this unit.
+:::
+
+:::tip[Screw Size]{icon="fa-solid fa-screwdriver-wrench"}
+Uses (6) #12 Flat Head screws
+:::
+
+:::custom-alert{title="Compatibility Note"}
+Unknown type is preserved and rendered with neutral styling.
+:::
+
+Malformed opening should remain plain markdown:
+
+:::warning[Missing end title
+This block should not be transformed.
+:::
+`
+  }
+}, M = {
+  name: "Live Playground",
+  args: {
+    children: a
+  },
+  render: (e) => /* @__PURE__ */ t(w, { ...e })
 };
 export {
-  x as Basic,
-  f as ItemDescription,
-  g as default
+  A as Admonitions,
+  k as Basic,
+  C as ItemDescription,
+  M as Playground,
+  x as default
 };

package/dist/atoms/Markdown/PreprocessedMarkdown.d.ts

@@ -1,9 +1,10 @@
-import { LinkTarget, ValidateToken } from './usePreprocessedMarkdown';
+import { LinkTarget, ValidateToken, BatchValidateTokens } from './usePreprocessedMarkdown';
 export type PreprocessedMarkdownProps = {
     children?: string | null;
     url: LinkTarget;
-    validate: ValidateToken;
+    validate?: ValidateToken;
+    batchValidate?: BatchValidateTokens;
     className?: string;
     debug?: boolean;
 };
-export declare function PreprocessedMarkdown({ url, validate, debug, className, children, }: PreprocessedMarkdownProps): import("react/jsx-runtime").JSX.Element;
+export declare function PreprocessedMarkdown({ url, validate, batchValidate, debug, className, children, }: PreprocessedMarkdownProps): import("react/jsx-runtime").JSX.Element;

package/dist/atoms/Markdown/PreprocessedMarkdown.js

@@ -1,20 +1,27 @@
 import { jsx as r } from "react/jsx-runtime";
-import { Markdown as d } from "./Markdown.js";
-import { usePreprocessedMarkdown as m } from "./usePreprocessedMarkdown.js";
-function k({
+import { Markdown as m } from "./Markdown.js";
+import { usePreprocessedMarkdown as c } from "./usePreprocessedMarkdown.js";
+function l({
   url: o,
   validate: e,
-  debug: n,
-  className: t,
-  children: p
+  batchValidate: n,
+  debug: t,
+  className: p,
+  children: d
 }) {
-  const { output: s } = m(p ?? "", o, e, n);
+  const { output: s } = c(
+    d ?? "",
+    o,
+    e,
+    t,
+    n
+  );
   return /* @__PURE__ */ r(
-    d,
+    m,
     {
-      className: t,
+      className: p,
       components: {
-        a: ({ node: c, ...a }) => /* @__PURE__ */ r(
+        a: ({ node: f, ...a }) => /* @__PURE__ */ r(
           "a",
           {
             ...a,
@@ -28,5 +35,5 @@ function k({
   );
 }
 export {
-  k as PreprocessedMarkdown
+  l as PreprocessedMarkdown
 };

package/dist/atoms/Markdown/PreprocessedMarkdown.stories.d.ts

@@ -5,3 +5,4 @@ export default meta;
 type Story = StoryObj<typeof meta>;
 export declare const Playground: Story;
 export declare const ControlsOnly: Story;
+export declare const BatchValidate: Story;

package/dist/atoms/Markdown/PreprocessedMarkdown.stories.js

@@ -1,17 +1,17 @@
-import { jsx as o, jsxs as i } from "react/jsx-runtime";
+import { jsx as n, jsxs as i } from "react/jsx-runtime";
 import { useState as c, useEffect as m } from "react";
-import { PreprocessedMarkdown as a } from "./PreprocessedMarkdown.js";
-const n = `Preprocessed Markdown
+import { PreprocessedMarkdown as s } from "./PreprocessedMarkdown.js";
+const o = `Preprocessed Markdown
 
 - Valid token [171] will link
 - Invalid token [ABC] shows a warning when debug is on
 
-You can also add more [123] tokens here.`, s = async (e) => {
+You can also add more [123] tokens here.`, l = async (e) => {
   if (await new Promise((t) => setTimeout(t, 150)), /^\d+$/.test(e)) return !0;
   throw new Error("Invalid token");
-}, l = (e) => `https://example.com/items/${encodeURIComponent(e)}`, g = {
+}, u = async (e) => (await new Promise((t) => setTimeout(t, 150)), new Set(e.filter((t) => /^\d+$/.test(t)))), r = (e) => `https://example.com/items/${encodeURIComponent(e)}`, k = {
   title: "Case Parts/Atoms/Markdown/PreprocessedMarkdown",
-  component: a,
+  component: s,
   tags: ["autodocs"],
   parameters: {
     controls: { expanded: !0 }
@@ -22,43 +22,52 @@ You can also add more [123] tokens here.`, s = async (e) => {
     className: { control: "text" }
   }
 };
-function u(e) {
-  const [t, r] = c(e.children ?? n);
+function h(e) {
+  const [t, a] = c(e.children ?? o);
   return m(() => {
-    r(e.children ?? n);
+    a(e.children ?? o);
   }, [e.children]), /* @__PURE__ */ i("div", { style: { display: "grid", gap: 12 }, children: [
-    /* @__PURE__ */ o("label", { style: { fontWeight: 600 }, children: "Edit Markdown (live):" }),
-    /* @__PURE__ */ o(
+    /* @__PURE__ */ n("label", { style: { fontWeight: 600 }, children: "Edit Markdown (live):" }),
+    /* @__PURE__ */ n(
       "textarea",
       {
         value: t,
-        onChange: (d) => r(d.target.value),
+        onChange: (d) => a(d.target.value),
         rows: 8,
         style: { width: "100%", fontFamily: "monospace" }
       }
     ),
-    /* @__PURE__ */ o(a, { ...e, children: t })
+    /* @__PURE__ */ n(s, { ...e, children: t })
   ] });
 }
-const k = {
+const f = {
   args: {
-    children: n,
-    url: l,
-    validate: s,
+    children: o,
+    url: r,
+    validate: l,
     debug: !0
   },
-  render: (e) => /* @__PURE__ */ o(u, { ...e })
-}, f = {
+  render: (e) => /* @__PURE__ */ n(h, { ...e })
+}, x = {
   name: "With Controls",
   args: {
-    children: n,
-    url: l,
-    validate: s,
+    children: o,
+    url: r,
+    validate: l,
     debug: !1
   }
+}, y = {
+  name: "Batch Validate",
+  args: {
+    children: o,
+    url: r,
+    batchValidate: u,
+    debug: !0
+  }
 };
 export {
-  f as ControlsOnly,
-  k as Playground,
-  g as default
+  y as BatchValidate,
+  x as ControlsOnly,
+  f as Playground,
+  k as default
 };

package/dist/atoms/Markdown/remarkAdmonition.d.ts

@@ -0,0 +1,15 @@
+type MarkdownNode = {
+    type: string;
+    value?: string;
+    children?: MarkdownNode[];
+    data?: {
+        hName?: string;
+        hProperties?: Record<string, unknown>;
+    };
+};
+type MarkdownRoot = {
+    type: "root";
+    children: MarkdownNode[];
+};
+export declare function remarkAdmonition(): (tree: MarkdownRoot) => void;
+export {};

package/dist/atoms/Markdown/remarkAdmonition.js

@@ -0,0 +1,120 @@
+const g = /^[a-z][a-z0-9_-]*/, y = /^\s*(?:[a-z][a-z0-9_-]*="(?:[^"\\]|\\.)*"(?:[ \t]+[a-z][a-z0-9_-]*="(?:[^"\\]|\\.)*")*)?\s*$/, x = /([a-z][a-z0-9_-]*)="((?:[^"\\]|\\.)*)"/g, d = /^:::[ \t]*$/, b = /* @__PURE__ */ new Set(["note", "tip", "important", "caution", "warning"]), f = (n) => {
+  if (n.type !== "paragraph" || !n.children || n.children.length === 0) return null;
+  let t = "";
+  for (const e of n.children) {
+    if (e.type === "text" && typeof e.value == "string") {
+      t += e.value;
+      continue;
+    }
+    if (e.type === "break") {
+      t += `
+`;
+      continue;
+    }
+    return null;
+  }
+  return t;
+}, T = (n) => ({
+  type: "paragraph",
+  children: [{ type: "text", value: n }]
+}), _ = (n) => n.replace(/\\(.)/g, "$1"), v = (n) => {
+  if (!y.test(n)) return null;
+  const t = {};
+  for (const e of n.matchAll(x)) {
+    const i = e[1], o = _(e[2]);
+    (i === "icon" || i === "title") && (t[i] = o);
+  }
+  return t;
+}, E = (n) => {
+  let t = !1, e = !1;
+  for (let i = 1; i < n.length; i += 1) {
+    const o = n[i];
+    if (e) {
+      e = !1;
+      continue;
+    }
+    if (o === "\\") {
+      e = !0;
+      continue;
+    }
+    if (o === '"') {
+      t = !t;
+      continue;
+    }
+    if (o === "}" && !t)
+      return i;
+  }
+  return -1;
+}, I = (n) => {
+  if (!n.startsWith(":::")) return null;
+  let t = n.slice(3);
+  const e = t.match(g);
+  if (!e) return null;
+  const i = e[0];
+  t = t.slice(i.length);
+  let o;
+  if (t.startsWith("[")) {
+    const r = t.indexOf("]");
+    if (r < 0) return null;
+    o = t.slice(1, r), t = t.slice(r + 1);
+  }
+  let c = {};
+  if (t.startsWith("{")) {
+    const r = E(t);
+    if (r < 0) return null;
+    const a = v(t.slice(1, r));
+    if (!a) return null;
+    c = a, t = t.slice(r + 1);
+  }
+  return /^[ \t]*$/.test(t) ? { name: i, title: o, attributes: c } : null;
+}, A = (n, t) => {
+  for (let e = t; e < n.length; e += 1) {
+    const i = f(n[e]);
+    if (i && d.test(i))
+      return e;
+  }
+  return -1;
+}, N = (n) => {
+  const t = n.join(`
+`);
+  return t.trim() ? t.split(/\n{2,}/).map((e) => e.trim()).filter(Boolean).map((e) => T(e)) : [];
+};
+function z() {
+  return (n) => {
+    if (!(!n || n.type !== "root" || !Array.isArray(n.children)))
+      for (let t = 0; t < n.children.length; t += 1) {
+        const e = f(n.children[t]);
+        if (!e) continue;
+        const i = e.split(/\r?\n/), o = I(i[0] ?? "");
+        if (!o) continue;
+        let c = [], r = 0;
+        if (i.length > 1) {
+          const l = i.findIndex((u, m) => m > 0 && d.test(u));
+          if (l < 0 || i.slice(l + 1).some((u) => u.trim().length > 0))
+            continue;
+          c = N(i.slice(1, l)), r = 1;
+        } else {
+          const l = A(n.children, t + 1);
+          if (l < 0) continue;
+          c = n.children.slice(t + 1, l), r = l - t + 1;
+        }
+        const a = o.title ?? o.attributes.title, h = b.has(o.name) ? o.name : "unknown", s = {
+          "data-admonition": o.name,
+          "data-admonition-variant": h
+        };
+        a !== void 0 && (s["data-admonition-title"] = a), o.attributes.icon !== void 0 && (s["data-admonition-icon"] = o.attributes.icon);
+        const p = {
+          type: "admonition",
+          data: {
+            hName: "aside",
+            hProperties: s
+          },
+          children: c
+        };
+        n.children.splice(t, r, p);
+      }
+  };
+}
+export {
+  z as remarkAdmonition
+};

package/dist/atoms/Markdown/usePreprocessedMarkdown.d.ts

@@ -1,4 +1,5 @@
 export type ValidateToken = (_token: string) => Promise<unknown>;
+export type BatchValidateTokens = (_tokens: readonly string[]) => Promise<ReadonlySet<string> | readonly string[]>;
 export type LinkTarget = string | ((_token: string) => string);
 export type PreprocessedMarkdownResult = {
     output: string;
@@ -9,4 +10,4 @@ export type PreprocessedMarkdownResult = {
  * Extracts bracketed tokens not already followed by parentheses, validates them, and
  * returns the input with validated tokens converted to markdown links.
  */
-export declare function usePreprocessedMarkdown(input: string | null | undefined, url: LinkTarget, validate: ValidateToken, debug?: boolean): PreprocessedMarkdownResult;
+export declare function usePreprocessedMarkdown(input: string | null | undefined, url: LinkTarget, validate?: ValidateToken, debug?: boolean, batchValidate?: BatchValidateTokens): PreprocessedMarkdownResult;

package/dist/atoms/Markdown/usePreprocessedMarkdown.js

@@ -1,52 +1,74 @@
-import { useState as w, useRef as S, useMemo as y, useEffect as P } from "react";
-function C(s, l, $, d = !1) {
-  const [v, i] = w(s ?? ""), [A, u] = w(!1), n = S(/* @__PURE__ */ new Map()), M = S($), o = y(() => /\[(.+?)\](?!\()/g, []), a = y(() => {
-    if (!s) return [];
-    const c = Array.from(s.matchAll(o)).map((f) => f[1]);
-    return Array.from(new Set(c));
-  }, [s, o]), m = (c) => {
-    const r = c.split(/\r?\n/);
-    if (r.length === 0) return c;
-    const f = r[0];
-    return /^\s*#\s/.test(f) || (r[0] = `# ${f.trim()}`), r.join(`
+import { useState as q, useRef as p, useEffect as v, useMemo as x } from "react";
+function k(n, i, w, y = !1, S) {
+  const [H, d] = q(n ?? ""), [P, h] = q(!1), r = p(/* @__PURE__ */ new Map()), E = p(w), R = p(
+    S
+  );
+  v(() => {
+    E.current = w, R.current = S;
+  }, [w, S]);
+  const u = x(() => /\[(.+?)\](?!\()/g, []), f = x(() => {
+    if (!n) return [];
+    const o = Array.from(n.matchAll(u)).map((l) => l[1]);
+    return Array.from(new Set(o));
+  }, [n, u]), $ = (o) => {
+    const e = o.split(/\r?\n/);
+    if (e.length === 0) return o;
+    const l = e[0];
+    return /^\s*#\s/.test(l) || (e[0] = `# ${l.trim()}`), e.join(`
 `);
   };
-  return P(() => {
-    if (!s) {
-      i(""), u(!1);
+  return v(() => {
+    if (!n) {
+      d(""), h(!1);
       return;
     }
-    if (!a.length) {
-      i(m(s)), u(!1);
+    if (!f.length) {
+      d($(n)), h(!1);
       return;
     }
-    let c = !1;
-    u(!0);
-    const r = a.filter((h) => !n.current.has(h));
+    let o = !1;
+    h(!0);
+    const e = f.filter((g) => !r.current.has(g));
     return (async () => {
-      r.length && (await Promise.allSettled(
-        r.map(async (e) => {
+      if (e.length) {
+        const t = R.current, s = E.current;
+        if (t)
           try {
-            await M.current(e), n.current.set(e, !0);
+            const c = await t(e), a = c instanceof Set ? c : new Set(c);
+            e.forEach((m) => {
+              r.current.set(m, a.has(m));
+            });
           } catch {
-            n.current.set(e, !1);
+            e.forEach((c) => {
+              r.current.set(c, !1);
+            });
           }
-        })
-      )).forEach((e, H) => {
-        const g = r[H];
-        n.current.has(g) || n.current.set(g, e.status === "fulfilled");
-      });
-      const h = new Set(
-        a.filter((t) => n.current.get(t) === !0)
-      ), R = new Set(
-        a.filter((t) => n.current.get(t) === !1)
-      ), q = (t) => typeof l == "function" ? l(t) : l, p = s.replace(o, (t, e) => h.has(e) ? `**[${e}](${q(e)})**` : t), x = d ? p.replace(o, (t, e) => R.has(e) ? `[${e}]⚠️` : t) : p, E = m(x);
-      c || (i(E), u(!1));
+        else s ? (await Promise.allSettled(
+          e.map(async (a) => {
+            try {
+              await s(a), r.current.set(a, !0);
+            } catch {
+              r.current.set(a, !1);
+            }
+          })
+        )).forEach((a, m) => {
+          const M = e[m];
+          r.current.has(M) || r.current.set(M, a.status === "fulfilled");
+        }) : e.forEach((c) => {
+          r.current.set(c, !0);
+        });
+      }
+      const g = new Set(
+        f.filter((t) => r.current.get(t) === !0)
+      ), j = new Set(
+        f.filter((t) => r.current.get(t) === !1)
+      ), C = (t) => typeof i == "function" ? i(t) : i, A = n.replace(u, (t, s) => g.has(s) ? `**[${s}](${C(s)})**` : t), L = y ? A.replace(u, (t, s) => j.has(s) ? `[${s}]⚠️` : t) : A, O = $(L);
+      o || (d(O), h(!1));
     })(), () => {
-      c = !0;
+      o = !0;
     };
-  }, [s, a, d, l, o]), { output: v, loading: A, tokens: a };
+  }, [n, f, y, i, u]), { output: H, loading: P, tokens: f };
 }
 export {
-  C as usePreprocessedMarkdown
+  k as usePreprocessedMarkdown
 };