@shwfed/nuxt 0.1.12 → 0.1.15

package/dist/runtime/components/tooltip.vue

@@ -0,0 +1,48 @@
+<script setup>
+import { useForwardPropsEmits } from "reka-ui";
+import { Tooltip } from "reka-ui/namespaced";
+const props = defineProps({
+  defaultOpen: { type: Boolean, required: false },
+  open: { type: Boolean, required: false },
+  delayDuration: { type: Number, required: false },
+  disableHoverableContent: { type: Boolean, required: false },
+  disableClosingTrigger: { type: Boolean, required: false },
+  disabled: { type: Boolean, required: false },
+  ignoreNonKeyboardFocus: { type: Boolean, required: false },
+  content: { type: String, required: false }
+});
+const emits = defineEmits(["update:open"]);
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <Tooltip.Root v-bind="forwarded">
+    <Tooltip.Trigger as-child>
+      <slot />
+    </Tooltip.Trigger>
+    <Tooltip.Content
+      side="top"
+      align="center"
+      :class="[
+  'bg-white text-zinc-700 animate-in fade-in-0 zoom-in-95',
+  'data-[state=closed]:animate-out data-[state=closed]:fade-out-0',
+  'data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2',
+  'data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2',
+  'data-[side=top]:slide-in-from-bottom-2',
+  'z-1024 w-fit rounded border border-zinc-200 px-6 py-2 text-xs',
+  'text-balance shadow-md'
+]"
+    >
+      <span
+        v-if="content"
+        v-html="content"
+      />
+      <Tooltip.Arrow
+        :class="[
+  'bg-white fill-white size-2.5 translate-y-[calc(-50%)] rotate-45 rounded-[2px]',
+  'border-b border-r border-zinc-200'
+]"
+      />
+    </Tooltip.Content>
+  </Tooltip.Root>
+</template>

package/dist/runtime/components/tooltip.vue.d.ts

@@ -0,0 +1,21 @@
+import { type TooltipRootProps } from 'reka-ui';
+type __VLS_Props = TooltipRootProps & {
+    content?: string;
+};
+declare var __VLS_14: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_14) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/composables/useTableRenderers.d.ts

@@ -0,0 +1,8 @@
+import '../table-renderers/builtins.js';
+import { getTableRenderer, resolveTableRenderer } from '../table-renderers/registry.js';
+export { defineTableRenderer } from '../table-renderers/registry.js';
+export type { TableRenderer, TableRendererCellArgs, TableRendererColumnDefOverrides, TableRendererConfigComponent, TableRendererHeaderArgs, TableRendererId, } from '../table-renderers/registry.js';
+export declare function useTableRenderers(): {
+    getTableRenderer: typeof getTableRenderer;
+    resolveTableRenderer: typeof resolveTableRenderer;
+};

package/dist/runtime/composables/useTableRenderers.js

@@ -0,0 +1,9 @@
+import "../table-renderers/builtins";
+import { getTableRenderer, resolveTableRenderer } from "../table-renderers/registry.js";
+export { defineTableRenderer } from "../table-renderers/registry.js";
+export function useTableRenderers() {
+  return {
+    getTableRenderer,
+    resolveTableRenderer
+  };
+}

package/dist/runtime/plugins/cel/index.d.ts

@@ -1,14 +1,23 @@
-import { TypeError, EvaluationError, type Context } from '@marcbachmann/cel-js';
-import { Effect, Either } from 'effect';
+import type { Context } from '@marcbachmann/cel-js';
 declare const _default: import("#app").Plugin<{
     dsl: {
-        check: (source: string) => Either.Either<string, TypeError>;
-        evaluate: <T>(source: string, context?: Context) => Effect.Effect<T, EvaluationError | TypeError, never>;
+        check: (source: string) => import("@marcbachmann/cel-js").TypeCheckResult;
+        /**
+         * Synchronous evaluation for render-time usage (e.g. table accessors).
+         *
+         * Will throw `TypeError` / `EvaluationError` on failure.
+         */
+        evaluate: <T>(source: string, context?: Context) => T;
     };
 }> & import("#app").ObjectPlugin<{
     dsl: {
-        check: (source: string) => Either.Either<string, TypeError>;
-        evaluate: <T>(source: string, context?: Context) => Effect.Effect<T, EvaluationError | TypeError, never>;
+        check: (source: string) => import("@marcbachmann/cel-js").TypeCheckResult;
+        /**
+         * Synchronous evaluation for render-time usage (e.g. table accessors).
+         *
+         * Will throw `TypeError` / `EvaluationError` on failure.
+         */
+        evaluate: <T>(source: string, context?: Context) => T;
     };
 }>;
 export default _default;

package/dist/runtime/plugins/cel/index.js

@@ -1,7 +1,5 @@
 import { defineNuxtPlugin } from "#app";
-import { TypeError, EvaluationError } from "@marcbachmann/cel-js";
 import defu from "defu";
-import { Effect, Either } from "effect";
 import { createEnvironment } from "./env.js";
 export default defineNuxtPlugin(() => {
   const env = createEnvironment();
@@ -9,28 +7,18 @@ export default defineNuxtPlugin(() => {
     provide: {
       dsl: {
         check: (source) => {
-          const result = env.check(source);
-          if (result.valid) {
-            return Either.right(result.type);
-          } else {
-            return Either.left(result.error);
-          }
+          return env.check(source);
         },
-        evaluate: (source, context) => Effect.gen(function* () {
-          return yield* Effect.tryPromise({
-            try: async () => env.evaluate(source, defu(context, {
-              now: /* @__PURE__ */ new Date()
-            })),
-            catch: (error) => {
-              if (error instanceof TypeError) {
-                return error;
-              } else if (error instanceof EvaluationError) {
-                return error;
-              }
-              throw error;
-            }
-          });
-        })
+        /**
+         * Synchronous evaluation for render-time usage (e.g. table accessors).
+         *
+         * Will throw `TypeError` / `EvaluationError` on failure.
+         */
+        evaluate: (source, context) => {
+          return env.evaluate(source, defu(context, {
+            now: /* @__PURE__ */ new Date()
+          }));
+        }
       }
     }
   };

package/dist/runtime/plugins/markdown/index.d.ts

@@ -1,7 +1,15 @@
 import { md } from './md.js';
 declare const _default: import("#app").Plugin<{
     md: typeof md;
+    markdown: {
+        render: (source: string) => string;
+        renderInline: (source: string) => string;
+    };
 }> & import("#app").ObjectPlugin<{
     md: typeof md;
+    markdown: {
+        render: (source: string) => string;
+        renderInline: (source: string) => string;
+    };
 }>;
 export default _default;

package/dist/runtime/plugins/markdown/index.js

@@ -14,12 +14,20 @@ export default defineNuxtPlugin((app) => {
       }
     },
     beforeUpdate(el, v) {
-      el.innerHTML = engine.renderInline(v.value);
+      if (["inline", "inline-flex", "inline-block"].includes(getComputedStyle(el).display)) {
+        el.innerHTML = engine.renderInline(v.value);
+      } else {
+        el.innerHTML = engine.render(v.value);
+      }
     }
   });
   return {
     provide: {
-      md
+      md,
+      markdown: {
+        render: (source) => engine.render(source),
+        renderInline: (source) => engine.renderInline(source)
+      }
     }
   };
 });

package/dist/runtime/table-renderers/builtins.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/table-renderers/builtins.js

@@ -0,0 +1,404 @@
+import { Fragment, jsx, jsxs } from "vue/jsx-runtime";
+import { Icon } from "@iconify/vue";
+import { format as formatDate, isValid, toDate } from "date-fns";
+import { defineComponent } from "vue";
+import { z } from "zod";
+import { defineTableRenderer } from "./registry.js";
+const JUSTIFY_CLASS = {
+  left: "justify-start",
+  center: "justify-center",
+  right: "justify-end"
+};
+const TableRendererTextConfig = defineComponent({
+  name: "TableRendererTextConfig",
+  props: {
+    modelValue: {
+      type: Object,
+      default: null
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(props, { emit }) {
+    const value = () => props.modelValue ?? {};
+    const update = (patch) => {
+      emit("update:modelValue", { ...value(), ...patch });
+    };
+    return () => /* @__PURE__ */ jsxs("div", { class: "flex flex-col gap-3 text-sm text-zinc-700", children: [
+      /* @__PURE__ */ jsxs("label", { class: "flex items-center gap-2 select-none", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "checkbox",
+            checked: Boolean(value().copyable),
+            onInput: (e) => {
+              if (e.target instanceof HTMLInputElement)
+                update({ copyable: e.target.checked });
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { children: "Copyable" })
+      ] }),
+      /* @__PURE__ */ jsxs("label", { class: "flex flex-col gap-1", children: [
+        /* @__PURE__ */ jsx("span", { class: "text-xs text-zinc-500", children: "Copy expression" }),
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            class: "border border-zinc-200 rounded px-2 py-1 text-sm",
+            placeholder: "CEL expression (row, index)",
+            value: value().copyExpression ?? "",
+            onInput: (e) => {
+              if (e.target instanceof HTMLInputElement)
+                update({ copyExpression: e.target.value || null });
+            }
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs("label", { class: "flex flex-col gap-1", children: [
+        /* @__PURE__ */ jsx("span", { class: "text-xs text-zinc-500", children: "Align" }),
+        /* @__PURE__ */ jsxs(
+          "select",
+          {
+            class: "border border-zinc-200 rounded px-2 py-1 text-sm bg-white",
+            value: value().align ?? "left",
+            onChange: (e) => {
+              if (e.target instanceof HTMLSelectElement) {
+                const v = e.target.value;
+                if (v === "left" || v === "center" || v === "right")
+                  update({ align: v });
+              }
+            },
+            children: [
+              /* @__PURE__ */ jsx("option", { value: "left", children: "left" }),
+              /* @__PURE__ */ jsx("option", { value: "center", children: "center" }),
+              /* @__PURE__ */ jsx("option", { value: "right", children: "right" })
+            ]
+          }
+        )
+      ] })
+    ] });
+  }
+});
+const TableRendererSelectionConfig = defineComponent({
+  name: "TableRendererSelectionConfig",
+  props: {
+    modelValue: {
+      type: Object,
+      default: null
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(props, { emit }) {
+    const value = () => props.modelValue ?? {};
+    const update = (patch) => {
+      emit("update:modelValue", { ...value(), ...patch });
+    };
+    return () => /* @__PURE__ */ jsx("div", { class: "flex flex-col gap-3 text-sm text-zinc-700", children: /* @__PURE__ */ jsxs("label", { class: "flex items-center gap-2 select-none", children: [
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "checkbox",
+          checked: Boolean(value().crossPage),
+          onInput: (e) => {
+            if (e.target instanceof HTMLInputElement)
+              update({ crossPage: e.target.checked });
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx("span", { children: "Cross page select-all" })
+    ] }) });
+  }
+});
+const TableRendererDateConfig = defineComponent({
+  name: "TableRendererDateConfig",
+  props: {
+    modelValue: {
+      type: Object,
+      default: null
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(props, { emit }) {
+    const value = () => props.modelValue ?? {};
+    const update = (patch) => {
+      emit("update:modelValue", { ...value(), ...patch });
+    };
+    return () => /* @__PURE__ */ jsx("div", { class: "flex flex-col gap-3 text-sm text-zinc-700", children: /* @__PURE__ */ jsxs("label", { class: "flex flex-col gap-1", children: [
+      /* @__PURE__ */ jsx("span", { class: "text-xs text-zinc-500", children: "Format" }),
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          class: "border border-zinc-200 rounded px-2 py-1 text-sm",
+          placeholder: "yyyy-MM-dd",
+          value: value().format ?? "",
+          onInput: (e) => {
+            if (e.target instanceof HTMLInputElement)
+              update({ format: e.target.value });
+          }
+        }
+      )
+    ] }) });
+  }
+});
+const TableRendererMarkdownConfig = defineComponent({
+  name: "TableRendererMarkdownConfig",
+  props: {
+    modelValue: {
+      type: Object,
+      default: null
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(props, { emit }) {
+    const value = () => props.modelValue ?? {};
+    const update = (patch) => {
+      emit("update:modelValue", { ...value(), ...patch });
+    };
+    return () => /* @__PURE__ */ jsx("div", { class: "flex flex-col gap-3 text-sm text-zinc-700", children: /* @__PURE__ */ jsxs("label", { class: "flex flex-col gap-1", children: [
+      /* @__PURE__ */ jsx("span", { class: "text-xs text-zinc-500", children: "Source" }),
+      /* @__PURE__ */ jsx(
+        "textarea",
+        {
+          class: "border border-zinc-200 rounded px-2 py-1 text-sm min-h-20",
+          placeholder: "Markdown source (leave empty to use cell value)",
+          value: value().source ?? "",
+          onInput: (e) => {
+            if (e.target instanceof HTMLTextAreaElement)
+              update({ source: e.target.value || void 0 });
+          }
+        }
+      )
+    ] }) });
+  }
+});
+const NoOptionsConfig = defineComponent({
+  name: "TableRendererNoOptionsConfig",
+  emits: ["update:modelValue"],
+  setup() {
+    return () => /* @__PURE__ */ jsx("div", { class: "text-xs text-zinc-500", children: "No options." });
+  }
+});
+defineTableRenderer(
+  "table.renderer.text",
+  {
+    copyable: z.boolean().default(false),
+    copyExpression: z.string().nullable().optional().default(null),
+    align: z.enum(["left", "center", "right"]).default("left")
+  },
+  {
+    cell: ({ ctx, options, helpers }) => {
+      const rawValue = ctx.cell.getValue();
+      const isEmpty = rawValue === void 0 || rawValue === null;
+      const align = isEmpty ? "center" : options.align ?? "left";
+      const justifyClass = JUSTIFY_CLASS[align];
+      const onCopy = async () => {
+        try {
+          let text = String(ctx.cell.getValue());
+          if (options.copyExpression && helpers.evaluate) {
+            text = String(helpers.evaluate(options.copyExpression, {
+              row: ctx.row.original,
+              index: BigInt(ctx.row.index)
+            }));
+          }
+          await navigator.clipboard.writeText(text);
+        } catch (e) {
+          console.error(e);
+        }
+      };
+      return /* @__PURE__ */ jsxs(
+        "span",
+        {
+          class: [
+            "relative w-full py-2 px-1 flex items-center text-xs",
+            "text-ellipsis overflow-hidden whitespace-nowrap group",
+            justifyClass,
+            isEmpty ? "font-mono text-zinc-300 select-none" : "text-zinc-600"
+          ],
+          children: [
+            isEmpty ? "-" : String(rawValue),
+            options.copyable && !isEmpty ? /* @__PURE__ */ jsx(
+              "button",
+              {
+                type: "button",
+                class: [
+                  "cursor-pointer absolute right-1 top-1/2 -translate-y-1/2 bg-white border",
+                  "w-6 h-6 flex items-center justify-center group-hover:opacity-100 opacity-0",
+                  "transition-all duration-180 rounded border-zinc-200 text-zinc-500",
+                  "hover:border-[var(--primary)]/50 hover:text-[var(--primary)]/80 hover:bg-[var(--primary)]/10"
+                ],
+                onClick: onCopy,
+                children: /* @__PURE__ */ jsx(Icon, { icon: "fluent:copy-20-regular" })
+              }
+            ) : null
+          ]
+        }
+      );
+    },
+    config: TableRendererTextConfig
+  }
+);
+defineTableRenderer(
+  "table.renderer.selection",
+  {
+    crossPage: z.boolean().default(false)
+  },
+  {
+    cell: ({ ctx }) => {
+      const isSingle = ctx.table.options.enableMultiRowSelection === false;
+      return /* @__PURE__ */ jsx("div", { class: "group w-full h-full flex items-center justify-center", children: /* @__PURE__ */ jsxs("label", { class: "flex items-center has-enabled:cursor-pointer has-disabled:cursor-not-allowed relative", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            id: `${ctx.column.id}-${ctx.row.id}`,
+            type: "checkbox",
+            disabled: !ctx.row.getCanSelect(),
+            checked: ctx.row.getIsSelected(),
+            class: [
+              "peer h-4 w-4 disabled:opacity-50 transition-colors duration-180 appearance-none",
+              "border border-zinc-200 not-checked-enabled-group-hover:border-zinc-300 not-checked-enabled-group-hover:bg-zinc-100 checked:border-[var(--primary)]",
+              isSingle ? "rounded-full" : "rounded"
+            ],
+            onInput: (e) => ctx.row.getToggleSelectedHandler()(e)
+          }
+        ),
+        isSingle ? /* @__PURE__ */ jsx("div", { class: "absolute inset-1 bg-[var(--primary)] pointer-events-none rounded-full peer-checked:opacity-100 opacity-0 transition-opacity duration-180" }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(
+            Icon,
+            {
+              icon: "fluent:checkmark-20-filled",
+              class: "peer-checked:opacity-100 opacity-0 text-white text-xs absolute z-1 -translate-x-1/2 -translate-y-1/2 top-1/2 left-1/2"
+            }
+          ),
+          /* @__PURE__ */ jsx("div", { class: "absolute inset-0 bg-[var(--primary)] rounded pointer-events-none peer-checked:opacity-100 opacity-0 transition-opacity duration-180" })
+        ] })
+      ] }) });
+    },
+    header: ({ ctx, options }) => {
+      if (ctx.table.options.enableMultiRowSelection === false)
+        return null;
+      const crossPage = options.crossPage ?? false;
+      const indeterminate = crossPage ? ctx.table.getIsSomePageRowsSelected() : ctx.table.getIsSomeRowsSelected();
+      const checked = crossPage ? ctx.table.getIsAllPageRowsSelected() : ctx.table.getIsAllRowsSelected();
+      const onInput = crossPage ? ctx.table.getToggleAllPageRowsSelectedHandler() : ctx.table.getToggleAllRowsSelectedHandler();
+      return /* @__PURE__ */ jsx("div", { class: "inline-flex items-center", children: /* @__PURE__ */ jsxs("label", { class: "flex items-center cursor-pointer relative", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            id: `${ctx.column.id}-header`,
+            type: "checkbox",
+            checked,
+            class: [
+              "peer h-4 w-4 cursor-pointer transition-colors duration-180 appearance-none rounded",
+              "border border-[color-mix(in_srgb,var(--primary)_10%,#00000033)] not-checked-group-hover:border-[color-mix(in_srgb,var(--primary)_20%,#00000033)]",
+              "not-checked-group-hover:bg-[color-mix(in_srgb,var(--primary)_5%,#00000011)] checked:border-[var(--primary)] checked:bg-[var(--primary)]"
+            ],
+            ref: (el) => {
+              if (el instanceof HTMLInputElement)
+                el.indeterminate = Boolean(indeterminate);
+            },
+            onInput: (e) => onInput(e)
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { class: "absolute text-white opacity-0 peer-checked:opacity-100 top-1/2 left-1/2 transform -translate-x-1/2 -translate-y-1/2 pointer-events-none", children: /* @__PURE__ */ jsx(Icon, { icon: "fluent:checkmark-20-filled", class: "text-white text-xs" }) })
+      ] }) });
+    },
+    config: TableRendererSelectionConfig,
+    columnDefOverrides: {
+      enableResizing: false
+    }
+  }
+);
+defineTableRenderer(
+  "table.renderer.expand",
+  {},
+  {
+    cell: ({ ctx }) => {
+      if (!ctx.row.getCanExpand())
+        return null;
+      return /* @__PURE__ */ jsx("div", { class: "group w-full h-full flex items-center justify-center text-zinc-700", children: /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          class: "cursor-pointer bg-transparent",
+          onClick: () => ctx.row.getToggleExpandedHandler()(),
+          children: /* @__PURE__ */ jsx(Icon, { icon: ctx.row.getIsExpanded() ? "fluent:subtract-square-20-regular" : "fluent:add-square-20-regular" })
+        }
+      ) });
+    },
+    header: ({ ctx }) => /* @__PURE__ */ jsx("div", { class: "group w-full h-full flex items-center justify-center text-base text-zinc-700", children: /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        class: "cursor-pointer bg-transparent",
+        onClick: (e) => ctx.table.getToggleAllRowsExpandedHandler()(e),
+        children: /* @__PURE__ */ jsx(Icon, { icon: ctx.table.getIsAllRowsExpanded() ? "fluent:subtract-square-20-regular" : "fluent:add-square-20-regular" })
+      }
+    ) }),
+    config: NoOptionsConfig
+  }
+);
+defineTableRenderer(
+  "table.renderer.money",
+  {},
+  {
+    cell: ({ ctx }) => {
+      const n = Number.parseFloat(String(ctx.cell.getValue()));
+      const isNan = Number.isNaN(n);
+      const formatted = isNan ? "-" : n.toLocaleString(void 0, { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+      return /* @__PURE__ */ jsx(
+        "div",
+        {
+          class: [
+            "relative w-full py-2 px-1 flex items-center",
+            "text-xs font-mono",
+            isNan ? "justify-center text-zinc-300 select-none" : "justify-end text-zinc-600"
+          ],
+          children: formatted
+        }
+      );
+    },
+    config: NoOptionsConfig
+  }
+);
+defineTableRenderer(
+  "table.renderer.date",
+  {
+    format: z.string().default("yyyy-MM-dd")
+  },
+  {
+    cell: ({ ctx, options }) => {
+      const value = ctx.cell.getValue();
+      let d = null;
+      try {
+        d = typeof value === "string" || typeof value === "number" || value instanceof Date ? toDate(value) : null;
+      } catch {
+      }
+      const date = isValid(d) ? d : null;
+      const formatted = date ? formatDate(date, options.format ?? "yyyy-MM-dd") : "-";
+      return /* @__PURE__ */ jsx(
+        "div",
+        {
+          class: [
+            "relative w-full py-2 px-1 flex items-center justify-center text-xs",
+            date ? "text-zinc-600" : "text-zinc-300 select-none"
+          ],
+          children: formatted
+        }
+      );
+    },
+    config: TableRendererDateConfig
+  }
+);
+defineTableRenderer(
+  "table.renderer.markdown",
+  {
+    source: z.string().optional()
+  },
+  {
+    cell: ({ ctx, options, helpers }) => {
+      const source = options.source ?? String(ctx.cell.getValue());
+      const html = helpers.renderInline(source);
+      return /* @__PURE__ */ jsx("div", { class: "relative w-full py-2 px-1 flex items-center justify-center text-xs", children: /* @__PURE__ */ jsx("span", { class: "prose prose-zinc text-xs", innerHTML: html }) });
+    },
+    config: TableRendererMarkdownConfig
+  }
+);

package/dist/runtime/table-renderers/registry.d.ts

@@ -0,0 +1,40 @@
+import type { CellContext, ColumnDef, HeaderContext, RowData } from '@tanstack/vue-table';
+import type { VNodeChild } from 'vue';
+import { z } from 'zod';
+export type TableRendererId = string;
+export type TableRendererColumnDefOverrides<TData extends RowData = unknown> = Partial<Pick<ColumnDef<TData, unknown>, 'enableResizing' | 'enableSorting' | 'enableMultiSort' | 'enablePinning' | 'size' | 'meta'>>;
+export type TableRendererCellArgs<TData extends RowData, TValue, TOptions> = Readonly<{
+    ctx: CellContext<TData, TValue>;
+    options: TOptions;
+    helpers: Readonly<{
+        renderInline: (source: string) => string;
+        evaluate?: (source: string, context?: Record<string, unknown>) => unknown;
+    }>;
+}>;
+export type TableRendererHeaderArgs<TData extends RowData, TValue, TOptions> = Readonly<{
+    ctx: HeaderContext<TData, TValue>;
+    title?: string;
+    options: TOptions;
+    helpers: Readonly<{
+        renderInline: (source: string) => string;
+        evaluate?: (source: string, context?: Record<string, unknown>) => unknown;
+    }>;
+}>;
+export type TableRendererConfigComponent<_TOptions> = unknown;
+export type TableRenderer<TOptions> = Readonly<{
+    id: TableRendererId;
+    optionsSchema: z.ZodType<TOptions>;
+    parseOptions: (input: unknown) => TOptions;
+    cell: (args: TableRendererCellArgs<unknown, unknown, TOptions>) => VNodeChild;
+    header?: (args: TableRendererHeaderArgs<unknown, unknown, TOptions>) => VNodeChild;
+    config?: TableRendererConfigComponent<TOptions>;
+    columnDefOverrides?: TableRendererColumnDefOverrides;
+}>;
+export declare function defineTableRenderer<const TShape extends z.ZodRawShape, const TOptions = z.infer<z.ZodObject<TShape>>>(id: TableRendererId, shape: TShape, impl: Readonly<{
+    cell: TableRenderer<TOptions>['cell'];
+    header?: TableRenderer<TOptions>['header'];
+    config?: TableRenderer<TOptions>['config'];
+    columnDefOverrides?: TableRenderer<TOptions>['columnDefOverrides'];
+}>): TableRenderer<TOptions>;
+export declare function getTableRenderer(id: TableRendererId): TableRenderer<unknown> | undefined;
+export declare function resolveTableRenderer(id: TableRendererId): TableRenderer<unknown>;