@cancia/astro 0.0.1 → 0.1.0

package/dist/portable-text-BikSqS9T.d.ts

@@ -0,0 +1,117 @@
+import { z } from 'zod';
+
+/** The four block styles the subset permits. */
+declare const PT_STYLES: readonly ["normal", "h2", "h3", "blockquote"];
+type PtStyle = (typeof PT_STYLES)[number];
+/** The two list kinds the subset permits (absent = not a list item). */
+declare const PT_LIST_ITEMS: readonly ["bullet", "number"];
+type PtListItem = (typeof PT_LIST_ITEMS)[number];
+/** The two decorators (marks that are not annotation keys) the subset permits. */
+declare const PT_DECORATORS: readonly ["strong", "em"];
+type PtDecorator = (typeof PT_DECORATORS)[number];
+/**
+ * Whether a link href uses a SAFE scheme. This is the XSS gate for the only
+ * annotation the subset carries: astro-portabletext renders `href` straight
+ * into an <a href> without scheme filtering, so a link authored as
+ * `javascript:alert(1)` or `data:text/html,…` would be a live injection vector
+ * — exactly what the "no raw HTML" design (D4) exists to prevent. Only allow:
+ *   - http(s), mailto:, tel: absolute URLs
+ *   - root-relative (`/…`), fragment (`#…`), and relative (`./…`, `../…`, or a
+ *     bare path) links that carry NO scheme at all.
+ * Everything with any other scheme (javascript:, data:, vbscript:, file:, …)
+ * is rejected. Exported so the parser and tests share one definition.
+ */
+declare function isSafeHref(href: string): boolean;
+/**
+ * A link annotation. Stored in a block's `markDefs`; a span references it by
+ * putting the markDef's `_key` in its `marks` array. `href` is the only
+ * carried property (no title/target — kept minimal and sanitizable), and it is
+ * constrained to safe schemes (see isSafeHref) so a stored value can never
+ * carry a javascript:/data: XSS payload.
+ */
+declare const ptLinkMarkDefSchema: z.ZodObject<{
+    _type: z.ZodLiteral<"link">;
+    _key: z.ZodString;
+    href: z.ZodString;
+}, z.core.$strip>;
+type PtLinkMarkDef = z.infer<typeof ptLinkMarkDefSchema>;
+/**
+ * A text span. `marks` entries are EITHER a decorator ("strong"/"em") OR a
+ * markDef `_key` present in the parent block's `markDefs`. We validate the
+ * decorator-or-string shape here; the cross-reference (every non-decorator mark
+ * resolves to a markDef) is enforced by the refine on the block below.
+ */
+declare const ptSpanSchema: z.ZodObject<{
+    _type: z.ZodLiteral<"span">;
+    _key: z.ZodString;
+    text: z.ZodString;
+    marks: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type PtSpan = z.infer<typeof ptSpanSchema>;
+/**
+ * A single block. `listItem`/`level` are present only for list rows. Every
+ * span mark that is not a decorator must reference a link markDef by key —
+ * that guard is what keeps arbitrary annotations out of the stored value.
+ */
+declare const ptBlockSchema: z.ZodObject<{
+    _type: z.ZodLiteral<"block">;
+    _key: z.ZodString;
+    style: z.ZodEnum<{
+        normal: "normal";
+        h2: "h2";
+        h3: "h3";
+        blockquote: "blockquote";
+    }>;
+    listItem: z.ZodOptional<z.ZodEnum<{
+        number: "number";
+        bullet: "bullet";
+    }>>;
+    level: z.ZodOptional<z.ZodNumber>;
+    markDefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        _type: z.ZodLiteral<"link">;
+        _key: z.ZodString;
+        href: z.ZodString;
+    }, z.core.$strip>>>;
+    children: z.ZodArray<z.ZodObject<{
+        _type: z.ZodLiteral<"span">;
+        _key: z.ZodString;
+        text: z.ZodString;
+        marks: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type PtBlock = z.infer<typeof ptBlockSchema>;
+/**
+ * The stored rich-text value: an array of subset blocks. Attach
+ * `.meta({ widget: "richtext" })` in defineField so describeList can identify
+ * it (its JSON-Schema type is "array", so the explicit widget is the only
+ * reliable signal — see the guard in describeProperty).
+ */
+declare const portableTextSubsetSchema: z.ZodArray<z.ZodObject<{
+    _type: z.ZodLiteral<"block">;
+    _key: z.ZodString;
+    style: z.ZodEnum<{
+        normal: "normal";
+        h2: "h2";
+        h3: "h3";
+        blockquote: "blockquote";
+    }>;
+    listItem: z.ZodOptional<z.ZodEnum<{
+        number: "number";
+        bullet: "bullet";
+    }>>;
+    level: z.ZodOptional<z.ZodNumber>;
+    markDefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        _type: z.ZodLiteral<"link">;
+        _key: z.ZodString;
+        href: z.ZodString;
+    }, z.core.$strip>>>;
+    children: z.ZodArray<z.ZodObject<{
+        _type: z.ZodLiteral<"span">;
+        _key: z.ZodString;
+        text: z.ZodString;
+        marks: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+type PortableTextValue = z.infer<typeof portableTextSubsetSchema>;
+
+export { PT_DECORATORS as P, PT_LIST_ITEMS as a, PT_STYLES as b, type PortableTextValue as c, type PtBlock as d, type PtDecorator as e, type PtLinkMarkDef as f, type PtListItem as g, type PtSpan as h, type PtStyle as i, isSafeHref as j, ptBlockSchema as k, portableTextSubsetSchema as p };

package/dist/richtext/CanciaRichText.astro

@@ -0,0 +1,44 @@
+---
+// =============================================================================
+// <CanciaRichText> — render a Cancia rich-text (Portable-Text SUBSET) value
+// =============================================================================
+// Renders the stored PT-subset array (see schema/portable-text.ts) to real
+// HTML using astro-portabletext. The subset — normal/h2/h3/blockquote blocks,
+// bullet/number lists, strong/em marks, link annotations — is a strict subset
+// of Portable Text, so astro-portabletext's DEFAULT components already cover
+// every case; we only override `link` to add rel/target hardening for external
+// hrefs. There is no raw HTML in the value (D4), so nothing is dangerouslySet.
+//
+// Usage in a page/template:
+//   ---
+//   import CanciaRichText from "@cancia/astro/richtext/CanciaRichText.astro";
+//   const { body } = entry.data;
+//   ---
+//   <CanciaRichText value={body} />
+//
+// This file ships as a raw .astro under dist/richtext/ (an .astro file can't be
+// a tsup entry) and is Vite-free at the package boundary — importing it does
+// NOT pull in the Cancia integration.
+// =============================================================================
+import { PortableText } from "astro-portabletext";
+import Link from "./Link.astro";
+
+export interface Props {
+  /** The stored PT-subset value. Undefined / empty renders nothing. */
+  value?: unknown;
+}
+
+const { value } = Astro.props;
+
+// Normalise: only render for a non-empty array of blocks. undefined, null, or
+// [] all render nothing (empty-value handling — [] vs undefined both no-op).
+const blocks = Array.isArray(value) ? value : [];
+---
+
+{
+  blocks.length > 0 && (
+    <div class="cancia-richtext">
+      <PortableText value={blocks} components={{ mark: { link: Link } }} />
+    </div>
+  )
+}

package/dist/richtext/Link.astro

@@ -0,0 +1,25 @@
+---
+// =============================================================================
+// Link mark for <CanciaRichText>
+// =============================================================================
+// astro-portabletext hands a mark component the resolved markDef on `node`. For
+// the subset's only annotation (link) that markDef is { _type:"link", href }.
+// We render an <a> and harden EXTERNAL hrefs (anything with a scheme) with
+// rel="noopener noreferrer" + target="_blank"; in-page/relative links stay
+// plain. The href is a plain string from the validated value — never HTML.
+// =============================================================================
+const { node } = Astro.props as {
+  node: { markDef?: { href?: string } };
+};
+
+const href = node?.markDef?.href ?? "#";
+const isExternal = /^[a-z][a-z0-9+.-]*:/i.test(href) || href.startsWith("//");
+---
+
+{
+  isExternal ? (
+    <a href={href} rel="noopener noreferrer" target="_blank"><slot /></a>
+  ) : (
+    <a href={href}><slot /></a>
+  )
+}

package/dist/richtext/index.d.ts

@@ -0,0 +1,23 @@
+import { i as PtStyle, g as PtListItem, d as PtBlock } from '../portable-text-BikSqS9T.js';
+export { P as PT_DECORATORS, a as PT_LIST_ITEMS, b as PT_STYLES, c as PortableTextValue, e as PtDecorator, f as PtLinkMarkDef, h as PtSpan, j as isSafeHref, p as portableTextSubsetSchema, k as ptBlockSchema } from '../portable-text-BikSqS9T.js';
+import 'zod';
+
+/** A row as the editor holds it: raw shorthand text + style + optional list kind. */
+interface RichTextRow {
+    text: string;
+    style: PtStyle;
+    listItem?: PtListItem;
+}
+/**
+ * Turn one editor row into a PT-subset block. Empty text still yields a block
+ * with a single empty span (PT convention) so the row survives a round-trip.
+ */
+declare function rowToBlock(row: RichTextRow): PtBlock;
+/** Serialise a list of editor rows into a PT-subset value (block array). */
+declare function rowsToPortableText(rows: RichTextRow[]): PtBlock[];
+/** Turn a PT-subset block back into an editable row (text + style + list). */
+declare function blockToRow(block: PtBlock): RichTextRow;
+/** Deserialise a PT-subset value into editor rows. */
+declare function portableTextToRows(value: PtBlock[]): RichTextRow[];
+
+export { PtBlock, PtListItem, PtStyle, type RichTextRow, blockToRow, portableTextToRows, rowToBlock, rowsToPortableText };

package/dist/richtext/index.js

@@ -0,0 +1,142 @@
+import {
+  PT_DECORATORS,
+  PT_LIST_ITEMS,
+  PT_STYLES,
+  isSafeHref,
+  portableTextSubsetSchema,
+  ptBlockSchema
+} from "../chunk-BOIQNZAO.js";
+
+// src/richtext/markdown.ts
+function keyGen(prefix) {
+  let n = 0;
+  return () => `${prefix}${(n++).toString(36)}`;
+}
+function parseInline(input) {
+  const segments = [];
+  let plain = "";
+  let i = 0;
+  const flushPlain = () => {
+    if (plain) {
+      segments.push({ text: plain, marks: [] });
+      plain = "";
+    }
+  };
+  while (i < input.length) {
+    if (input[i] === "\\" && i + 1 < input.length) {
+      plain += input[i + 1];
+      i += 2;
+      continue;
+    }
+    if (input[i] === "[") {
+      const close = input.indexOf("]", i + 1);
+      if (close !== -1 && input[close + 1] === "(") {
+        const paren = input.indexOf(")", close + 2);
+        if (paren !== -1) {
+          const text = input.slice(i + 1, close);
+          const href = input.slice(close + 2, paren);
+          flushPlain();
+          segments.push({ text, marks: [], href });
+          i = paren + 1;
+          continue;
+        }
+      }
+    }
+    if (input[i] === "*" && input[i + 1] === "*") {
+      const end = input.indexOf("**", i + 2);
+      if (end !== -1 && end > i + 2) {
+        flushPlain();
+        segments.push({ text: input.slice(i + 2, end), marks: ["strong"] });
+        i = end + 2;
+        continue;
+      }
+    }
+    if (input[i] === "*") {
+      const end = input.indexOf("*", i + 1);
+      if (end !== -1 && end > i + 1) {
+        flushPlain();
+        segments.push({ text: input.slice(i + 1, end), marks: ["em"] });
+        i = end + 1;
+        continue;
+      }
+    }
+    plain += input[i];
+    i += 1;
+  }
+  flushPlain();
+  return segments;
+}
+function rowToBlock(row) {
+  const spanKey = keyGen("s");
+  const linkKey = keyGen("l");
+  const segments = parseInline(row.text);
+  const markDefs = [];
+  const children = [];
+  for (const seg of segments) {
+    const marks = [...seg.marks];
+    if (seg.href !== void 0 && isSafeHref(seg.href)) {
+      const _key = linkKey();
+      markDefs.push({ _type: "link", _key, href: seg.href });
+      marks.push(_key);
+    }
+    children.push({ _type: "span", _key: spanKey(), text: seg.text, marks });
+  }
+  if (children.length === 0) {
+    children.push({ _type: "span", _key: spanKey(), text: "", marks: [] });
+  }
+  const style = PT_STYLES.includes(row.style) ? row.style : "normal";
+  const block = {
+    _type: "block",
+    _key: keyGen("b")(),
+    style,
+    markDefs,
+    children
+  };
+  if (row.listItem && PT_LIST_ITEMS.includes(row.listItem)) {
+    block.listItem = row.listItem;
+    block.level = 1;
+  }
+  return block;
+}
+function rowsToPortableText(rows) {
+  return rows.map(rowToBlock);
+}
+function escapeShorthand(text) {
+  return text.replace(/([\\*\[\]])/g, "\\$1");
+}
+function spanToShorthand(span, linkHrefByKey) {
+  let out = escapeShorthand(span.text);
+  const href = span.marks.map((m) => linkHrefByKey.get(m)).find((h) => h !== void 0);
+  if (href !== void 0) out = `[${out}](${href})`;
+  if (span.marks.includes("strong")) out = `**${out}**`;
+  if (span.marks.includes("em")) out = `*${out}*`;
+  return out;
+}
+function blockToRow(block) {
+  const linkHrefByKey = /* @__PURE__ */ new Map();
+  for (const def of block.markDefs ?? []) {
+    if (def._type === "link") linkHrefByKey.set(def._key, def.href);
+  }
+  const text = (block.children ?? []).map((span) => spanToShorthand(span, linkHrefByKey)).join("");
+  const row = {
+    text,
+    style: PT_STYLES.includes(block.style) ? block.style : "normal"
+  };
+  if (block.listItem && PT_LIST_ITEMS.includes(block.listItem)) row.listItem = block.listItem;
+  return row;
+}
+function portableTextToRows(value) {
+  return value.map(blockToRow);
+}
+export {
+  PT_DECORATORS,
+  PT_LIST_ITEMS,
+  PT_STYLES,
+  blockToRow,
+  isSafeHref,
+  portableTextSubsetSchema,
+  portableTextToRows,
+  ptBlockSchema,
+  rowToBlock,
+  rowsToPortableText
+};

package/dist/schema/index.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 export { z } from 'zod';
+export { P as PT_DECORATORS, a as PT_LIST_ITEMS, b as PT_STYLES, c as PortableTextValue, d as PtBlock, e as PtDecorator, f as PtLinkMarkDef, g as PtListItem, h as PtSpan, i as PtStyle, j as isSafeHref, p as portableTextSubsetSchema, k as ptBlockSchema } from '../portable-text-BikSqS9T.js';
 
 /**
  * Widget hint the modal form uses to pick an input element. The Zod type
@@ -15,20 +16,52 @@ export { z } from 'zod';
  *   z.boolean()          → "checkbox"
  *   z.enum([...])        → "select"
  */
-type FieldWidget = "text" | "textarea" | "url" | "email" | "datetime" | "number" | "checkbox" | "select" | "image";
+type FieldWidget = "text" | "textarea" | "url" | "email" | "datetime" | "number" | "checkbox" | "select" | "image" | "slug" | "array" | "object" | "reference" | "richtext";
 /**
- * Metadata attached to a Zod field via `.meta({...})`. All optional.
+ * Fields common to every widget's metadata. All optional.
  */
-interface FieldMeta {
+interface FieldMetaBase {
     /** Display label for the field. Defaults to humanised field name. */
     label?: string;
     /** Help text shown under the input. */
     description?: string;
-    /** Override widget choice. */
-    widget?: FieldWidget;
     /** Placeholder text in the input. */
     placeholder?: string;
 }
+/**
+ * Metadata attached to a Zod field via `.meta({...})`.
+ *
+ * This is a widget-keyed discriminated union: each widget variant only
+ * permits the options that are legal for it. It exists at the type level
+ * only — Zod's `.meta()` accepts any object (its `GlobalMeta` carries an
+ * index signature), so this union is what `defineField` uses to type its
+ * per-widget option parameters. Passing an illegal option to a
+ * `defineField.*` helper is therefore a compile error, while bare
+ * `z.string().meta({ widget: "textarea" })` calls stay valid.
+ *
+ * Later plans extend this union with array / reference / richtext variants.
+ */
+type FieldMeta = (FieldMetaBase & {
+    widget?: "text" | "textarea" | "url" | "email" | "number" | "checkbox" | "datetime";
+}) | (FieldMetaBase & {
+    widget: "select";
+    options?: string[];
+}) | (FieldMetaBase & {
+    widget: "image";
+    alt?: boolean;
+}) | (FieldMetaBase & {
+    widget: "slug";
+    source?: string;
+}) | (FieldMetaBase & {
+    widget: "array";
+}) | (FieldMetaBase & {
+    widget: "object";
+}) | (FieldMetaBase & {
+    widget: "reference";
+    list: string;
+}) | (FieldMetaBase & {
+    widget: "richtext";
+});
 interface ListSchemaOptions<TFields extends Record<string, z.ZodTypeAny>> {
     /** Display label for the list (e.g. "Blog Posts"). */
     label: string;
@@ -79,7 +112,127 @@ interface FieldDescription {
     /** For number widgets: min/max. */
     min?: number;
     max?: number;
+    /** For string widgets: a regex pattern (source, no delimiters) the value must match. */
+    pattern?: string;
+    /** For slug widgets: the field name to auto-generate the slug from. */
+    source?: string;
+    /**
+     * For array widgets: the description of a single item. The item has no name
+     * of its own (arrays are keyed by position), so `of.name` is "".
+     */
+    of?: FieldDescription;
+    /** For object widgets: the sub-field descriptions, in declared order. */
+    fields?: FieldDescription[];
+    /** For reference widgets: the name of the list whose entries this points at. */
+    referenceList?: string;
 }
+/**
+ * Typed field constructors. Each returns the underlying Zod type with a
+ * correctly-typed `.meta()` already attached, so schemas read declaratively:
+ *
+ *   import { defineField as f } from "@cancia/astro/schema";
+ *
+ *   fields: {
+ *     title: f.text({ label: "Title" }),
+ *     slug:  f.slug({ source: "title", label: "URL slug" }),
+ *     status: f.select({ options: ["draft", "published"], label: "Status" }),
+ *   }
+ *
+ * The option parameter of each helper is derived from the matching FieldMeta
+ * variant, so illegal options (e.g. passing `source` to `text`) are compile
+ * errors. `defineField` is purely additive — bare `z.string().meta({...})`
+ * declarations keep working unchanged.
+ */
+/** Options accepted by the plain string/number/etc. widgets (no extras). */
+type PlainFieldOptions = FieldMetaBase;
+declare const defineField: {
+    text: (o?: PlainFieldOptions) => z.ZodString;
+    textarea: (o?: PlainFieldOptions) => z.ZodString;
+    url: (o?: PlainFieldOptions) => z.ZodString;
+    email: (o?: PlainFieldOptions) => z.ZodString;
+    datetime: (o?: PlainFieldOptions) => z.ZodString;
+    checkbox: (o?: PlainFieldOptions) => z.ZodBoolean;
+    number: (o?: PlainFieldOptions & {
+        min?: number;
+        max?: number;
+    }) => z.ZodNumber;
+    slug: (o: FieldMetaBase & {
+        source?: string;
+    }) => z.ZodString;
+    image: (o?: FieldMetaBase & {
+        alt?: boolean;
+    }) => z.ZodString;
+    select: (o: FieldMetaBase & {
+        options: string[];
+    }) => z.ZodEnum<{
+        [x: string]: string;
+    }>;
+    /**
+     * A repeatable list of a single member type. `member` is any Zod type,
+     * typically another `defineField.*` (so it keeps its own `.meta({ widget })`
+     * and recursion carries labels/widgets into each row).
+     *
+     *   bullets: f.array(f.text({ label: "Point" }), { label: "Key points" }),
+     *   faqs:    f.array(f.object({ q: f.text(), a: f.textarea() })),
+     */
+    array: <TMember extends z.ZodTypeAny>(member: TMember, o?: FieldMetaBase) => z.ZodArray<TMember>;
+    /**
+     * A nested group of named sub-fields, rendered as a collapsible fieldset.
+     *
+     *   socials: f.object({ linkedin: f.url(), twitter: f.url() }, { label: "Socials" }),
+     */
+    object: <TShape extends Record<string, z.ZodTypeAny>>(shape: TShape, o?: FieldMetaBase) => z.ZodObject<{ -readonly [P in keyof TShape]: TShape[P]; }, z.core.$strip>;
+    /**
+     * A pointer to an entry in another list. Stored as a plain string — the
+     * target entry's id. Per the v0.1.0 design (D5) there is NO integrity
+     * backend: dangling ids are tolerated and surfaced by the editor, never
+     * prevented. `list` is the target list's name (a key in the schemas module).
+     *
+     *   author:  f.reference({ list: "people", label: "Author" }),
+     *   related: f.array(f.reference({ list: "posts" }), { label: "Related" }),
+     */
+    reference: (o: FieldMetaBase & {
+        list: string;
+    }) => z.ZodString;
+    /**
+     * A constrained rich-text body. Stored as a Portable-Text SUBSET array (D4):
+     * block styles normal/h2/h3/blockquote, bullet/number lists, strong/em marks,
+     * and link annotations — nothing else. The toolbar renders a structured block
+     * editor (approach B) over it, and `<CanciaRichText>` renders it to HTML.
+     *
+     *   body: f.richtext({ label: "Body" }),
+     *
+     * The JSON-Schema type of this field is "array"; the explicit
+     * `widget: "richtext"` meta is what distinguishes it from a plain array in
+     * describeProperty.
+     */
+    richtext: (o?: PlainFieldOptions) => z.ZodArray<z.ZodObject<{
+        _type: z.ZodLiteral<"block">;
+        _key: z.ZodString;
+        style: z.ZodEnum<{
+            normal: "normal";
+            h2: "h2";
+            h3: "h3";
+            blockquote: "blockquote";
+        }>;
+        listItem: z.ZodOptional<z.ZodEnum<{
+            number: "number";
+            bullet: "bullet";
+        }>>;
+        level: z.ZodOptional<z.ZodNumber>;
+        markDefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            _type: z.ZodLiteral<"link">;
+            _key: z.ZodString;
+            href: z.ZodString;
+        }, z.core.$strip>>>;
+        children: z.ZodArray<z.ZodObject<{
+            _type: z.ZodLiteral<"span">;
+            _key: z.ZodString;
+            text: z.ZodString;
+            marks: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+};
 interface ListDescription {
     name: string;
     label: string;
@@ -89,8 +242,22 @@ interface ListDescription {
     slugField?: string;
     fields: FieldDescription[];
 }
+/**
+ * Turn arbitrary text into a URL-safe slug: lowercase, spaces → hyphens,
+ * strip anything outside [a-z0-9-], collapse runs of hyphens, trim leading
+ * and trailing hyphens. Matches the slug field regex `^[a-z0-9-]+$`.
+ *
+ * Used by the toolbar to auto-derive a slug from a title as the editor types
+ * (plan 025). Kept here (not in the toolbar) so it is unit-tested alongside the
+ * schema helpers and stays the single definition of "what a slug looks like".
+ *
+ *   slugify("Hello, World!")   → "hello-world"
+ *   slugify("  Multiple   spaces ") → "multiple-spaces"
+ *   slugify("Café déjà vu")    → "caf-dj-vu"  (non-ASCII stripped)
+ */
+declare function slugify(input: string): string;
 declare function describeList(name: string, schema: ListSchema): ListDescription;
 /** Map of list name → schema. What users export from src/cms/schemas.ts. */
 type SchemasModule = Record<string, ListSchema>;
 
-export { type FieldDescription, type FieldMeta, type FieldWidget, type ListDescription, type ListSchema, type ListSchemaOptions, type SchemasModule, defineList, describeList };
+export { type FieldDescription, type FieldMeta, type FieldMetaBase, type FieldWidget, type ListDescription, type ListSchema, type ListSchemaOptions, type SchemasModule, defineField, defineList, describeList, slugify };

package/dist/schema/index.js

@@ -1,10 +1,28 @@
 import {
+  defineField,
   defineList,
   describeList,
+  slugify,
   z
-} from "../chunk-QAM5VKAF.js";
+} from "../chunk-MCHQV6Y7.js";
+import {
+  PT_DECORATORS,
+  PT_LIST_ITEMS,
+  PT_STYLES,
+  isSafeHref,
+  portableTextSubsetSchema,
+  ptBlockSchema
+} from "../chunk-BOIQNZAO.js";
 export {
+  PT_DECORATORS,
+  PT_LIST_ITEMS,
+  PT_STYLES,
+  defineField,
   defineList,
   describeList,
+  isSafeHref,
+  portableTextSubsetSchema,
+  ptBlockSchema,
+  slugify,
   z
 };

package/dist/storage/index.d.ts

@@ -0,0 +1,20 @@
+import { C as CanciaStorage, a as CanciaStorageV2 } from '../types-BMlLS-OS.js';
+export { b as CanciaKVStore, c as CanciaListStore, d as CanciaPageStore, L as ListEntry, P as PageMeta, e as PageRecord, f as PageSEO, R as Rev, g as RevConflictError } from '../types-BMlLS-OS.js';
+
+declare function createJsonFileAdapter(filePath?: string): CanciaStorage;
+
+interface JsonFileV2Options {
+    /** Project root. Defaults to process.cwd(). */
+    projectRoot?: string;
+    /** Override the KV file path. Defaults to <root>/cancia-content.json. */
+    kvPath?: string;
+    /** Override the pages file path. Defaults to <root>/.cancia/pages.json. */
+    pagesPath?: string;
+    /** Override the lists directory. Defaults to <root>/.cancia/lists. */
+    listsDir?: string;
+}
+declare function createJsonFileAdapterV2(opts?: JsonFileV2Options): CanciaStorageV2;
+
+declare function createSQLiteAdapter(dbPath?: string): CanciaStorage;
+
+export { CanciaStorage, CanciaStorageV2, createJsonFileAdapter, createJsonFileAdapterV2, createSQLiteAdapter };

package/dist/storage/index.js

@@ -0,0 +1,16 @@
+import {
+  createSQLiteAdapter
+} from "../chunk-AE4SIY24.js";
+import {
+  createJsonFileAdapter,
+  createJsonFileAdapterV2
+} from "../chunk-ST44VULL.js";
+import {
+  RevConflictError
+} from "../chunk-7IA5B5CF.js";
+export {
+  RevConflictError,
+  createJsonFileAdapter,
+  createJsonFileAdapterV2,
+  createSQLiteAdapter
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cancia/astro",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Astro integration for Cancia CMS — inline editing with zero separate server",
   "license": "MIT",
   "repository": {
@@ -23,7 +23,16 @@
     "./loader": {
       "types": "./dist/loader/index.d.ts",
       "import": "./dist/loader/index.js"
-    }
+    },
+    "./storage": {
+      "types": "./dist/storage/index.d.ts",
+      "import": "./dist/storage/index.js"
+    },
+    "./richtext": {
+      "types": "./dist/richtext/index.d.ts",
+      "import": "./dist/richtext/index.js"
+    },
+    "./richtext/CanciaRichText.astro": "./dist/richtext/CanciaRichText.astro"
   },
   "files": [
     "dist"
@@ -46,13 +55,16 @@
     "better-sqlite3": "^11.0.0",
     "tsup": "^8.0.0",
     "typescript": "^5.4.0",
-    "vite": "^8.0.0"
+    "vite": "^8.0.0",
+    "vitest": "^4.1.9"
   },
   "dependencies": {
+    "astro-portabletext": "^0.13.0",
     "zod": "^4.4.3"
   },
   "scripts": {
     "build": "tsup",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
   }
 }