@braincrew-lab/langchain-canvas 0.3.0 → 0.4.9

package/dist/TableRenderer-3ESF577F.js

@@ -0,0 +1,275 @@
+import { mergeRowsIntoSheet } from './chunk-IFNRLN4Y.js';
+import { computeFormulas } from './chunk-SGOPRUQ4.js';
+import './chunk-YZZSJJMQ.js';
+import { useCanvasStore } from './chunk-EHW446VF.js';
+import { lazy, useMemo, useState, useRef, useEffect, useCallback, Suspense } from 'react';
+import '@fortune-sheet/react/dist/index.css';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+var Workbook = lazy(() => import('@fortune-sheet/react').then((m) => ({ default: m.Workbook })));
+var isFormula = (v) => typeof v === "string" && v.startsWith("=");
+function sheetHasContent(sheet) {
+  if (!sheet?.length) return false;
+  return sheet.some((s) => {
+    const celldata = s.celldata;
+    if (celldata?.some((cell) => cell?.v != null)) return true;
+    const data = s.data;
+    return !!data?.some((row) => row?.some((cell) => cell != null));
+  });
+}
+function normalizeSheets(sheet) {
+  if (!sheet?.length) return sheet;
+  return sheet.map((s) => {
+    const { luckysheet_select_save: _selection, data, ...rest } = s;
+    if (!data || rest.celldata) return rest;
+    const celldata = [];
+    data.forEach(
+      (row, r) => row?.forEach((cell, c) => {
+        if (cell != null) celldata.push({ r, c, v: cell });
+      })
+    );
+    return { ...rest, celldata };
+  });
+}
+function toWorkbook(columns, rows, formulas) {
+  const celldata = [];
+  columns.forEach((col, c) => {
+    const label = col.label ?? col.key;
+    celldata.push({ r: 0, c, v: { v: label, m: String(label), bl: 1, bg: "#f3f4f6" } });
+  });
+  rows.forEach((row, r) => {
+    columns.forEach((col, c) => {
+      const val = row[col.key];
+      if (val === void 0 || val === null || val === "") return;
+      if (isFormula(val)) {
+        const computed = formulas.get(`${r + 1},${c}`);
+        const v = { f: val };
+        if (computed !== void 0) {
+          v.v = computed;
+          v.m = String(computed);
+          if (typeof computed === "number") v.ct = { fa: "General", t: "n" };
+        }
+        celldata.push({ r: r + 1, c, v });
+        return;
+      }
+      const numeric = typeof val === "number";
+      celldata.push({
+        r: r + 1,
+        c,
+        v: { v: val, m: String(val), ...numeric ? { ct: { fa: "General", t: "n" } } : {} }
+      });
+    });
+  });
+  const sample = Math.min(rows.length, 400);
+  const columnlen = {};
+  columns.forEach((col, c) => {
+    let widest = String(col.label ?? col.key).length;
+    for (let ri = 0; ri < sample; ri++) {
+      let v = rows[ri][col.key];
+      if (isFormula(v)) v = formulas.get(`${ri + 1},${c}`) ?? "";
+      if (v != null && v !== "") widest = Math.max(widest, String(v).length);
+    }
+    columnlen[c] = Math.min(360, Math.max(64, Math.round(widest * 8.5) + 18));
+  });
+  return [
+    {
+      name: "Sheet1",
+      id: "sheet1",
+      order: 0,
+      // Size the grid to the data plus a modest buffer — big enough to feel like a
+      // real sheet and to keep growing, small enough that the scrollbar stays
+      // proportional (a huge empty grid makes scrolling feel disconnected).
+      row: Math.max(rows.length + 40, 60),
+      column: Math.max(columns.length + 2, 8),
+      celldata,
+      // No frozen pane: a freeze split offsets the initial scroll and hides the
+      // first data rows behind the split line. A plain grid scrolls cleanly.
+      config: { rowlen: { 0: 28 }, columnlen }
+    }
+  ];
+}
+function deriveColumns(rows) {
+  const keys = /* @__PURE__ */ new Set();
+  for (let i = 0; i < Math.min(rows.length, 50); i++) Object.keys(rows[i] ?? {}).forEach((k) => keys.add(k));
+  return [...keys].map((key) => ({ key }));
+}
+var EMPTY_FORMULAS = /* @__PURE__ */ new Map();
+function TableRenderer({ artifact }) {
+  const rows = artifact.data.rows;
+  const columns = useMemo(
+    () => artifact.data.columns.length ? artifact.data.columns : deriveColumns(rows),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [artifact.id, artifact.version, artifact.data.columns.length, rows.length]
+  );
+  const [mounted, setMounted] = useState(false);
+  const rootRef = useRef(null);
+  useEffect(() => setMounted(true), []);
+  useEffect(() => {
+    const root = rootRef.current;
+    if (!root) return;
+    const onWheel = (e) => {
+      const y = root.querySelector(".luckysheet-scrollbar-y");
+      const x = root.querySelector(".luckysheet-scrollbar-x");
+      let moved = false;
+      if (y && e.deltaY && y.scrollHeight > y.clientHeight) {
+        const max = y.scrollHeight - y.clientHeight;
+        const next = Math.max(0, Math.min(max, y.scrollTop + e.deltaY));
+        if (next !== y.scrollTop) {
+          y.scrollTop = next;
+          moved = true;
+        }
+      }
+      if (x && e.deltaX && x.scrollWidth > x.clientWidth) {
+        const max = x.scrollWidth - x.clientWidth;
+        const next = Math.max(0, Math.min(max, x.scrollLeft + e.deltaX));
+        if (next !== x.scrollLeft) {
+          x.scrollLeft = next;
+          moved = true;
+        }
+      }
+      const horizontal = Math.abs(e.deltaX) > Math.abs(e.deltaY);
+      if (moved || horizontal && e.deltaX) {
+        e.preventDefault();
+        e.stopPropagation();
+      }
+    };
+    root.addEventListener("wheel", onWheel, { passive: false, capture: true });
+    return () => root.removeEventListener("wheel", onWheel, { capture: true });
+  }, [mounted]);
+  const rowsSig = useMemo(() => {
+    const json = JSON.stringify(rows);
+    let hash = 5381;
+    for (let i = 0; i < json.length; i++) hash = (hash << 5) + hash + json.charCodeAt(i) | 0;
+    return (hash >>> 0).toString(36);
+  }, [rows]);
+  const dataKey = `${artifact.id}:v${artifact.version}:${columns.length}x${rows.length}:${rowsSig}`;
+  const hasFormulas = useMemo(
+    () => rows.slice(0, 400).some((row) => columns.some((col) => isFormula(row[col.key]))),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [dataKey]
+  );
+  const [formulas, setFormulas] = useState(EMPTY_FORMULAS);
+  const [formulasReady, setFormulasReady] = useState(!hasFormulas);
+  useEffect(() => {
+    if (!hasFormulas) {
+      setFormulas(EMPTY_FORMULAS);
+      setFormulasReady(true);
+      return;
+    }
+    let alive = true;
+    setFormulasReady(false);
+    computeFormulas(columns, rows).then((values) => {
+      if (!alive) return;
+      setFormulas(values);
+      setFormulasReady(true);
+    });
+    return () => {
+      alive = false;
+    };
+  }, [dataKey, hasFormulas]);
+  const hasSheet = sheetHasContent(artifact.data.sheet);
+  const [sortCol, setSortCol] = useState("");
+  const [sortDir, setSortDir] = useState(1);
+  const [filter, setFilter] = useState("");
+  const [appliedFilter, setAppliedFilter] = useState("");
+  useEffect(() => {
+    const t = setTimeout(() => setAppliedFilter(filter), 300);
+    return () => clearTimeout(t);
+  }, [filter]);
+  const viewRows = useMemo(() => {
+    let r = rows;
+    const q = appliedFilter.trim().toLowerCase();
+    if (q) r = r.filter((row) => columns.some((c) => String(row[c.key] ?? "").toLowerCase().includes(q)));
+    if (sortCol) {
+      r = [...r].sort((a, b) => {
+        const av = a[sortCol];
+        const bv = b[sortCol];
+        const cmp = typeof av === "number" && typeof bv === "number" ? av - bv : String(av ?? "").localeCompare(String(bv ?? ""));
+        return cmp * sortDir;
+      });
+    }
+    return r;
+  }, [rows, columns, appliedFilter, sortCol, sortDir]);
+  const viewActive = !!appliedFilter.trim() || !!sortCol;
+  const wbKey = `${dataKey}:${viewActive ? `view-s${sortCol}${sortDir}-f${appliedFilter}` : hasSheet ? "sheet" : "rows"}`;
+  const initialData = useMemo(
+    () => viewActive ? toWorkbook(columns, viewRows, formulas) : hasSheet ? (
+      // Rows the agent wrote after the person's last edit win their cells;
+      // the person's formatting and out-of-table cells survive.
+      mergeRowsIntoSheet(columns, rows, normalizeSheets(artifact.data.sheet), formulas)
+    ) : toWorkbook(columns, rows, formulas),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [wbKey, formulasReady]
+  );
+  const applyEvent = useCanvasStore((s) => s.applyUserEvent);
+  const persistTimer = useRef(null);
+  const handleChange = useCallback(
+    (sheets) => {
+      if (persistTimer.current) clearTimeout(persistTimer.current);
+      persistTimer.current = setTimeout(() => {
+        if (!sheetHasContent(sheets)) return;
+        applyEvent({
+          type: "canvas.patch",
+          id: artifact.id,
+          patch: { sheet: normalizeSheets(sheets) }
+        });
+      }, 400);
+    },
+    [applyEvent, artifact.id]
+  );
+  useEffect(() => () => {
+    if (persistTimer.current) clearTimeout(persistTimer.current);
+  }, []);
+  const wbRef = useRef(null);
+  const insert = (type) => {
+    const sel = wbRef.current?.getSelection?.();
+    const range = sel?.[0]?.[type] ?? [0, 0];
+    wbRef.current?.insertRowOrColumn(type, Math.max(0, range[1]), 1, "rightbottom");
+  };
+  if (!mounted) {
+    return /* @__PURE__ */ jsx("div", { className: "cv-sheet cv-sheet--empty", children: "Loading spreadsheet\u2026" });
+  }
+  if (!hasSheet && columns.length === 0) {
+    return /* @__PURE__ */ jsx("div", { className: "cv-sheet cv-sheet--empty", children: "Waiting for data\u2026" });
+  }
+  if (!formulasReady) {
+    return /* @__PURE__ */ jsx("div", { className: "cv-sheet cv-sheet--empty", children: "Calculating\u2026" });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "cv-sheet-panel", children: [
+    /* @__PURE__ */ jsxs("div", { className: "cv-sheet-tools", children: [
+      /* @__PURE__ */ jsx("button", { type: "button", onClick: () => insert("column"), children: "\uFF0B Column" }),
+      /* @__PURE__ */ jsx("button", { type: "button", onClick: () => insert("row"), children: "\uFF0B Row" }),
+      columns.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx("span", { className: "cv-sheet-tools__sep" }),
+        /* @__PURE__ */ jsxs(
+          "select",
+          {
+            className: "cv-sheet-tools__sort",
+            value: sortCol,
+            title: "Sort by column",
+            onChange: (e) => setSortCol(e.target.value),
+            children: [
+              /* @__PURE__ */ jsx("option", { value: "", children: "Sort\u2026" }),
+              columns.map((c) => /* @__PURE__ */ jsx("option", { value: c.key, children: c.label ?? c.key }, c.key))
+            ]
+          }
+        ),
+        sortCol && /* @__PURE__ */ jsx("button", { type: "button", title: sortDir === 1 ? "Ascending" : "Descending", onClick: () => setSortDir((d) => d === 1 ? -1 : 1), children: sortDir === 1 ? "\u25B2" : "\u25BC" }),
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            className: "cv-sheet-tools__filter",
+            value: filter,
+            placeholder: "Filter\u2026",
+            onChange: (e) => setFilter(e.target.value),
+            title: "Filter rows"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx("span", { className: "cv-sheet-tools__hint", children: "Right-click a header for more, or drag to edit" })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "cv-sheet", ref: rootRef, children: /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx("div", { className: "cv-sheet--empty", children: "Loading\u2026" }), children: /* @__PURE__ */ jsx(Workbook, { ref: wbRef, data: initialData, onChange: handleChange }, wbKey) }) })
+  ] });
+}
+
+export { TableRenderer, normalizeSheets, sheetHasContent };

package/dist/chunk-7T5DRR3F.js

@@ -0,0 +1,109 @@
+// src/io/canvasAssets.ts
+var ASSET_REFERENCE_PREFIXES = ["assets/", "sources/"];
+function normalizeAssetReference(src) {
+  if (typeof src !== "string") return null;
+  let folded = src;
+  while (folded.startsWith("./") || folded.startsWith("../")) {
+    folded = folded.startsWith("./") ? folded.slice(2) : folded.slice(3);
+  }
+  return ASSET_REFERENCE_PREFIXES.some((p) => folded.startsWith(p)) ? folded : null;
+}
+function isAssetReference(src) {
+  return normalizeAssetReference(src) !== null;
+}
+function resolveAssetUrl(src, assetBaseUrl) {
+  return assetBaseUrl + encodeURIComponent(normalizeAssetReference(src) ?? src);
+}
+var REF_ALTERNATION = ASSET_REFERENCE_PREFIXES.map((p) => p.slice(0, -1)).join("|");
+var srcAttrPattern = () => new RegExp(`(src=(["']))((?:\\.\\.?/)*(?:${REF_ALTERNATION})/[^"']+)(\\2)`, "g");
+var escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+async function fetchAssetDataUri(path, assetBaseUrl) {
+  try {
+    const res = await fetch(resolveAssetUrl(path, assetBaseUrl));
+    if (!res.ok) return null;
+    const type = res.headers.get("content-type")?.split(";")[0] || "application/octet-stream";
+    const bytes = new Uint8Array(await res.arrayBuffer());
+    let binary = "";
+    for (let i = 0; i < bytes.length; i += 32768) {
+      binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+    }
+    return `data:${type};base64,${btoa(binary)}`;
+  } catch {
+    return null;
+  }
+}
+async function inlineHtmlAssets(html, assetBaseUrl) {
+  const relative = srcAttrPattern();
+  const absolute = new RegExp(
+    `(src=(["']))${escapeRegExp(assetBaseUrl)}([^"']+)(\\2)`,
+    "g"
+  );
+  const paths = /* @__PURE__ */ new Set();
+  for (const m of html.matchAll(relative)) paths.add(m[3]);
+  for (const m of html.matchAll(absolute)) {
+    const decoded = safeDecode(m[3]);
+    if (isAssetReference(decoded)) paths.add(decoded);
+  }
+  if (!paths.size) return html;
+  const resolved = /* @__PURE__ */ new Map();
+  await Promise.all(
+    [...paths].map(async (p) => {
+      const uri = await fetchAssetDataUri(p, assetBaseUrl);
+      if (uri) resolved.set(p, uri);
+    })
+  );
+  return html.replace(relative, (whole, pre, _q, path, post) => {
+    const uri = resolved.get(path);
+    return uri ? `${pre}${uri}${post}` : whole;
+  }).replace(absolute, (whole, pre, _q, encoded, post) => {
+    const uri = resolved.get(safeDecode(encoded));
+    return uri ? `${pre}${uri}${post}` : whole;
+  });
+}
+function safeDecode(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+async function inlineArtifactAssets(artifact, assetBaseUrl) {
+  if (!assetBaseUrl) return artifact;
+  if (artifact.type === "html") {
+    const data = artifact.data;
+    const html = await inlineHtmlAssets(data.html, assetBaseUrl);
+    return html === data.html ? artifact : { ...artifact, data: { ...data, html } };
+  }
+  if (artifact.type === "slides") {
+    const data = artifact.data;
+    let changed = false;
+    const slides = await Promise.all(
+      (data.slides ?? []).map(async (slide) => {
+        let next = slide;
+        if (isAssetReference(slide.image)) {
+          const uri = await fetchAssetDataUri(slide.image, assetBaseUrl);
+          if (uri) {
+            next = { ...next, image: uri };
+            changed = true;
+          }
+        }
+        if (next.elements?.some((el) => isAssetReference(el.src))) {
+          const elements = await Promise.all(
+            next.elements.map(async (el) => {
+              if (!isAssetReference(el.src)) return el;
+              const uri = await fetchAssetDataUri(el.src, assetBaseUrl);
+              return uri ? { ...el, src: uri } : el;
+            })
+          );
+          next = { ...next, elements };
+          changed = true;
+        }
+        return next;
+      })
+    );
+    return changed ? { ...artifact, data: { ...data, slides } } : artifact;
+  }
+  return artifact;
+}
+
+export { ASSET_REFERENCE_PREFIXES, fetchAssetDataUri, inlineArtifactAssets, inlineHtmlAssets, isAssetReference, normalizeAssetReference, resolveAssetUrl };

package/dist/{chunk-ZLXAWRUP.js → chunk-EHW446VF.js}

@@ -23,13 +23,13 @@ function reduceCanvas(state, event) {
       const current = state.artifacts[event.id];
       if (!current) return state;
       const data = appendAtPath(current.data, event.path, event.text);
-      return replaceInPlace(state, { ...current, data });
+      return updateLive(state, { ...current, data });
     }
     case "canvas.patch": {
       const current = state.artifacts[event.id];
       if (!current) return state;
       const data = mergePatch(current.data, event.patch);
-      return replaceInPlace(state, { ...current, data });
+      return updateLive(state, { ...current, data });
     }
     case "canvas.node_patch": {
       const current = state.artifacts[event.id];
@@ -37,7 +37,7 @@ function reduceCanvas(state, event) {
       if (!current || typeof html !== "string") return state;
       const next = applyNodePatch(html, event.cid, event.html);
       const data = { ...current.data, html: next };
-      return replaceInPlace(state, { ...current, data });
+      return updateLive(state, { ...current, data });
     }
     case "canvas.replace":
       return pushVersion(state, event.artifact);
@@ -49,19 +49,21 @@ function reduceCanvas(state, event) {
     case "canvas.commit": {
       const current = state.artifacts[event.id];
       if (!current) return state;
-      const snapshot = {
+      const versions = state.history[event.id] ?? [];
+      const committed = {
         ...current,
-        version: current.version + 1,
         meta: {
           ...current.meta ?? {},
           commitDescription: event.description,
           ...event.revision ? { revision: event.revision } : {}
         }
       };
-      return pushVersion(state, snapshot);
+      return {
+        ...state,
+        artifacts: { ...state.artifacts, [event.id]: committed },
+        history: { ...state.history, [event.id]: [...versions.slice(0, -1), committed] }
+      };
     }
-    case "canvas.close":
-      return state.activeId === event.id ? { ...state, activeId: lastOf(state.order, event.id) } : state;
     default:
       return state;
   }
@@ -75,6 +77,20 @@ function create(state, artifact) {
     activeId: artifact.id
   };
 }
+function updateLive(state, artifact) {
+  const versions = state.history[artifact.id] ?? [];
+  const last = versions[versions.length - 1];
+  if (!last || typeof last.meta?.commitDescription !== "string") {
+    return replaceInPlace(state, artifact);
+  }
+  const { commitDescription: _stale, ...meta } = artifact.meta ?? {};
+  const working = { ...artifact, version: last.version + 1, meta };
+  return {
+    ...state,
+    artifacts: { ...state.artifacts, [artifact.id]: working },
+    history: { ...state.history, [artifact.id]: [...versions, working] }
+  };
+}
 function replaceInPlace(state, artifact) {
   const versions = state.history[artifact.id] ?? [];
   const history = versions.length ? { ...state.history, [artifact.id]: [...versions.slice(0, -1), artifact] } : { ...state.history, [artifact.id]: [artifact] };
@@ -141,18 +157,6 @@ function mergePatch(target, patch) {
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function lastOf(order, excludeId) {
-  const remaining = order.filter((id) => id !== excludeId);
-  return remaining.length ? remaining[remaining.length - 1] : null;
-}
-function notifyTimeTravel(store, before) {
-  const handler = store.onUserEdit;
-  if (!handler || store.canvas === before) return;
-  for (const id of Object.keys(store.canvas.artifacts)) {
-    const now = store.canvas.artifacts[id];
-    if (now && now !== before.artifacts[id]) handler(now);
-  }
-}
 function editedArtifactId(event) {
   switch (event.type) {
     case "canvas.create":
@@ -175,7 +179,8 @@ var initialState = () => ({
   iframeCommand: null,
   undoStack: [],
   redoStack: [],
-  onUserEdit: null
+  onUserEdit: null,
+  assetBaseUrl: null
 });
 function createCanvasStore() {
   return createStore((set, get) => ({
@@ -192,34 +197,26 @@ function createCanvasStore() {
       const artifact = id ? state.canvas.artifacts[id] : void 0;
       if (artifact) state.onUserEdit?.(artifact);
     },
-    undo: () => {
-      const before = get().canvas;
-      set((state) => {
-        if (!state.undoStack.length) return state;
-        const previous = state.undoStack[state.undoStack.length - 1];
-        return {
-          canvas: previous,
-          undoStack: state.undoStack.slice(0, -1),
-          redoStack: [...state.redoStack, state.canvas].slice(-50),
-          selections: []
-        };
-      });
-      notifyTimeTravel(get(), before);
-    },
-    redo: () => {
-      const before = get().canvas;
-      set((state) => {
-        if (!state.redoStack.length) return state;
-        const next = state.redoStack[state.redoStack.length - 1];
-        return {
-          canvas: next,
-          redoStack: state.redoStack.slice(0, -1),
-          undoStack: [...state.undoStack, state.canvas].slice(-50),
-          selections: []
-        };
-      });
-      notifyTimeTravel(get(), before);
-    },
+    undo: () => set((state) => {
+      if (!state.undoStack.length) return state;
+      const previous = state.undoStack[state.undoStack.length - 1];
+      return {
+        canvas: previous,
+        undoStack: state.undoStack.slice(0, -1),
+        redoStack: [...state.redoStack, state.canvas].slice(-50),
+        selections: []
+      };
+    }),
+    redo: () => set((state) => {
+      if (!state.redoStack.length) return state;
+      const next = state.redoStack[state.redoStack.length - 1];
+      return {
+        canvas: next,
+        redoStack: state.redoStack.slice(0, -1),
+        undoStack: [...state.undoStack, state.canvas].slice(-50),
+        selections: []
+      };
+    }),
     addUserMessage: (text) => set((state) => ({
       messages: [...state.messages, { id: `user_${state.messages.length}`, role: "user", text }],
       error: null
@@ -229,7 +226,9 @@ function createCanvasStore() {
     setSelections: (selections) => set({ selections }),
     sendIframeCommand: (command) => set((state) => ({ iframeCommand: { ...command, seq: (state.iframeCommand?.seq ?? 0) + 1 } })),
     setOnUserEdit: (handler) => set({ onUserEdit: handler }),
-    reset: () => set(initialState())
+    setAssetBaseUrl: (url) => set({ assetBaseUrl: url }),
+    // Host configuration (the asset endpoint) survives a session reset.
+    reset: () => set({ ...initialState(), assetBaseUrl: get().assetBaseUrl })
   }));
 }
 function foldEvent(state, event) {

package/dist/chunk-FTNRRJ3K.js

@@ -0,0 +1,13 @@
+import { isAssetReference, resolveAssetUrl } from './chunk-7T5DRR3F.js';
+import { useCanvasStore } from './chunk-EHW446VF.js';
+import { useCallback } from 'react';
+
+function useAssetUrl() {
+  const assetBaseUrl = useCanvasStore((s) => s.assetBaseUrl);
+  return useCallback(
+    (src) => src && assetBaseUrl && isAssetReference(src) ? resolveAssetUrl(src, assetBaseUrl) : src,
+    [assetBaseUrl]
+  );
+}
+
+export { useAssetUrl };