@pagehub/sdk 0.1.0

package/dist/utils/tailwind/className.d.ts

@@ -0,0 +1,148 @@
+/**
+ * className utilities — parse and mutate Tailwind className strings.
+ *
+ * Pure functions, no React, no DOM. Used by the editor settings panels
+ * to read/write className as the source of truth (className-first).
+ */
+/** Map of prop keys to their current Tailwind class value. */
+export type ClassTokens = Record<string, string>;
+export declare function classPropKeyMatches(base: string, propKey: string): boolean;
+/**
+ * Map a Tailwind class to its toolbar prop key.
+ *
+ * Thin wrapper over `resolveClassKey` that aliases text-color tokens to
+ * `color` — the toolbar / `displayLabel` keying system uses `color`, while
+ * `TailwindStyles` stores the same group under `text`. Shadow-bug gates
+ * (`text-` / `border-` / `font-` overloads) live in `resolveClassKey`, so
+ * this wrapper inherits them automatically.
+ */
+export declare function classNameToVar(name: string): string | undefined;
+/** v1 variant segments (canonical stack: responsive, then `dark`, then `hover` — matches twMerge-friendly ordering). */
+export type ParsedVariantSeg = "sm" | "md" | "lg" | "xl" | "2xl" | "dark" | "hover";
+export type ClassScopeOptions = {
+    /** When true, read/write utilities under `dark:` after the breakpoint prefix and before `hover:`. */
+    classDark?: boolean;
+};
+/** Strip leading `sm:` / `md:` / … / `dark:` / `hover:` segments; base is the utility stem. */
+export declare function splitClassVariants(classToken: string): {
+    segments: ParsedVariantSeg[];
+    base: string;
+};
+/** Collapse to canonical order: one max-width breakpoint, then `dark`, then `hover`. */
+export declare function normalizeVariantSegments(segments: ParsedVariantSeg[]): ParsedVariantSeg[];
+/**
+ * Parse a className string into structured tokens keyed by prop name.
+ *
+ * Classes that don't map to a known prop key go under `_unknown`.
+ * Responsive-prefixed classes (md:, lg:, etc.) are stored with their
+ * prefix intact under a `{prefix}:{propKey}` key.
+ *
+ * @example
+ * parseClasses("flex flex-col gap-4 py-8 bg-primary lg:grid-cols-2")
+ * // → {
+ * //   display: "flex",
+ * //   flex: "flex-col",
+ * //   gap: "gap-4",
+ * //   py: "py-8",
+ * //   _unknown: "bg-primary",
+ * //   "lg:gridCols": "lg:grid-cols-2",
+ * // }
+ */
+export declare function parseClasses(className: string): ClassTokens;
+/**
+ * Replace or add a class in a className string by prop key.
+ *
+ * Uses twMerge for conflict resolution — if the new class conflicts
+ * with an existing one in the same Tailwind group, the old one is replaced.
+ *
+ * @example
+ * mutateClass("flex flex-col gap-4 py-8", "gap", "gap-8")
+ * // → "flex flex-col gap-8 py-8"
+ *
+ * mutateClass("flex flex-col", "gridCols", "grid-cols-3")
+ * // → "flex flex-col grid-cols-3"
+ */
+export declare function mutateClass(className: string, _propKey: string, newValue: string): string;
+/**
+ * Remove every class token that matches `propKey` on the utility stem, at any supported variant depth
+ * (`md:dark:font-bold`, `hover:text-lg`, etc.). Key matching aligns with `getClassForView` / toolbar inputs.
+ *
+ * @example
+ * removeClass("flex flex-col gap-4 py-8", "gap")
+ * // → "flex flex-col py-8"
+ */
+export declare function removeClass(className: string, propKey: string): string;
+/**
+ * First class token whose utility stem matches `propKey` (any supported variant prefix chain).
+ * Returns the full token including variants.
+ *
+ * @example
+ * getClass("flex flex-col gap-4 py-8", "gap")
+ * // → "gap-4"
+ *
+ * getClass("flex flex-col gap-4 py-8", "gridCols")
+ * // → undefined
+ */
+export declare function getClass(className: string, propKey: string): string | undefined;
+/** Tailwind default min-widths — used to size the editor canvas for breakpoint previews. */
+export declare const EDITOR_CANVAS_BREAKPOINT_PX: {
+    readonly mobile: 390;
+    readonly sm: 640;
+    readonly md: 768;
+    readonly lg: 1024;
+    readonly xl: 1280;
+    readonly "2xl": 1536;
+};
+export type EditorCanvasBreakpointId = keyof typeof EDITOR_CANVAS_BREAKPOINT_PX;
+export declare function isEditorCanvasBreakpointView(view: string): view is EditorCanvasBreakpointId;
+/**
+ * Resolve canvas breakpoint pixel widths for the active site theme.
+ * `mobile` (390) is always hardcoded — it's a preview convenience, not a Tailwind layer.
+ * `sm`/`md`/`lg`/`xl`/`2xl` come from `theme.breakpoints` if set, else defaults.
+ */
+export declare function getCanvasBreakpointPx(theme?: {
+    breakpoints?: Record<string, number>;
+}): Record<EditorCanvasBreakpointId, number>;
+/** Ordered scope IDs for toolbar “apply to layer” toggles (base + each min-width). */
+export declare const VIEW_BREAKPOINT_SCOPE_KEYS: readonly ["mobile", "sm", "desktop", "lg", "xl", "2xl"];
+export type ViewBreakpointScopeKey = (typeof VIEW_BREAKPOINT_SCOPE_KEYS)[number];
+/** Prefix written before the utility (e.g. `md:` + `gap-4` → `md:gap-4`). */
+export declare function getViewClassPrefix(view: string): string;
+/**
+ * Variant chain for the active editor scope (breakpoint + optional `dark` + optional `hover`).
+ * v1 order (matches twMerge-friendly stacking): `responsive → dark → hover`
+ * (e.g. `md:dark:gap-4`, `dark:hover:text-white` when editing hover colors with dark scope on).
+ */
+export declare function expectedVariantChain(view: string, classDark: boolean): ParsedVariantSeg[];
+/** Full Tailwind variant prefix for writes (`md:dark:` + `gap-4` → `md:dark:gap-4`). */
+export declare function buildVariantPrefix(view: string, classDark?: boolean): string;
+/**
+ * Editor canvas (ViewAtom) → key for `getViewClassPrefix` / className writes.
+ * Full-width canvas id is `desktop` but targets the **base** layer; scope id `desktop` (md row) stays `md` via {@link getViewClassPrefix}.
+ */
+export declare function editorCanvasViewToClassPrefixKey(canvasView: string | undefined | null): string;
+/**
+ * Read a single prop value from a className string for a specific view/breakpoint.
+ *
+ * Returns the base class (without variant prefix chain) so the UI shows "gap-4"
+ * even when stored as "md:dark:gap-4".
+ *
+ * @example
+ * getClassForView("flex md:gap-8 gap-4", "gap", "desktop")  // → "gap-8" (toolbar md scope)
+ * getClassForView("flex md:gap-8 gap-4", "gap", "md")       // → "gap-8"
+ * getClassForView("flex md:gap-8 gap-4", "gap", "mobile")   // → "gap-4"
+ * getClassForView("flex md:gap-8 gap-4", "display", "mobile") // → "flex"
+ */
+export declare function getClassForView(className: string, propKey: string, view: string, options?: ClassScopeOptions): string | undefined;
+/**
+ * Remove classes matching a prop key for a specific view/breakpoint only.
+ *
+ * Unlike `removeClass`, this preserves classes at other breakpoints.
+ *
+ * @example
+ * removeClassForView("gap-4 md:gap-8", "gap", "desktop")  // → "gap-4"
+ * removeClassForView("gap-4 md:gap-8", "gap", "md")       // → "gap-4"
+ * removeClassForView("gap-4 md:gap-8", "gap", "mobile")   // → "md:gap-8"
+ */
+export declare function removeClassForView(className: string, propKey: string, view: string, options?: ClassScopeOptions): string;
+//# sourceMappingURL=className.d.ts.map

package/dist/utils/tailwind/className.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"className.d.ts","sourceRoot":"","sources":["../../../src/utils/tailwind/className.ts"],"names":[],"mappings":"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"}

package/dist/utils/tailwind/daisyuiToTailwind.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Pure Tailwind export — replaces DaisyUI component classes and spatial tokens
+ * with standard Tailwind utility equivalents.
+ *
+ * Used by code previews (block library), static HTML export, and framework
+ * exports (React/Next/Vue/Nuxt) so output is copy-paste ready without DaisyUI
+ * or the spatial token package.
+ */
+/**
+ * Replace DaisyUI component classes, spatial tokens, and custom radius/layout
+ * tokens with standard Tailwind utility equivalents.
+ *
+ * Pure function — no side effects, no DOM, works in Node and browser.
+ */
+export declare function purifyToTailwind(className: string): string;
+//# sourceMappingURL=daisyuiToTailwind.d.ts.map

package/dist/utils/tailwind/daisyuiToTailwind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daisyuiToTailwind.d.ts","sourceRoot":"","sources":["../../../src/utils/tailwind/daisyuiToTailwind.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAmPH;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAgF1D"}

package/dist/utils/tailwind/displayLabel.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Render a Tailwind token as a more human-readable label.
+ *
+ * Keeps the underlying class string untouched; only the visible UI label changes.
+ */
+export declare function formatTailwindDisplayLabel(value: string, propKey?: string): string;
+//# sourceMappingURL=displayLabel.d.ts.map

package/dist/utils/tailwind/displayLabel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"displayLabel.d.ts","sourceRoot":"","sources":["../../../src/utils/tailwind/displayLabel.ts"],"names":[],"mappings":"AAwHA;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAalF"}

package/dist/utils/tailwind/displayLabel.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=displayLabel.test.d.ts.map

package/dist/utils/tailwind/displayLabel.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"displayLabel.test.d.ts","sourceRoot":"","sources":["../../../src/utils/tailwind/displayLabel.test.ts"],"names":[],"mappings":""}

package/dist/utils/tailwind/fontFamilyClass.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Font family on nodes is stored only as Tailwind classes:
+ * - Design tokens: `font-heading`
+ * - Google Fonts: `font-['Playfair_Display']` (spaces in name → underscores)
+ */
+/** Strip responsive/dark/hover prefixes to the bare utility stem. */
+export declare function tailwindTokenBase(classToken: string): string;
+/** Build the canonical arbitrary-font utility for a Google Font family name. */
+export declare function googleFontNameToClass(family: string): string;
+/** Parse `font-['Some_Font']` → display name (underscores → spaces). */
+export declare function parseGoogleFontFromArbitraryClass(base: string): string | null;
+/**
+ * For a utility stem starting with `font-`, return `fontFamily` or `fontWeight` when unambiguous.
+ * Otherwise undefined so normal prefix / index matching applies.
+ */
+export declare function fontUtilityStemToKey(base: string): string | undefined;
+/** First font-family utility token in a class string (any variant prefix). */
+export declare function findFontFamilyClassToken(className: string): string | undefined;
+//# sourceMappingURL=fontFamilyClass.d.ts.map

package/dist/utils/tailwind/fontFamilyClass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fontFamilyClass.d.ts","sourceRoot":"","sources":["../../../src/utils/tailwind/fontFamilyClass.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,qEAAqE;AACrE,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAQ5D;AAED,gFAAgF;AAChF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAM5D;AAED,wEAAwE;AACxE,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAO7E;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAsBrE;AAED,8EAA8E;AAC9E,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAS9E"}

package/dist/utils/tailwind/ringOutlineClassKey.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Map ring / outline utilities to toolbar prop keys (non-exact / non-reverse-index).
+ * Keeps `ring-offset-*` width vs color distinct and avoids greedy `ring-` prefix issues.
+ */
+export declare function isRingOffsetWidthBase(base: string): boolean;
+/**
+ * @returns prop key or `undefined` if this is not a ring/outline utility.
+ */
+export declare function ringOutlineClassKey(cls: string): string | undefined;
+//# sourceMappingURL=ringOutlineClassKey.d.ts.map

package/dist/utils/tailwind/ringOutlineClassKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ringOutlineClassKey.d.ts","sourceRoot":"","sources":["../../../src/utils/tailwind/ringOutlineClassKey.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAWH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAa3D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CA2CnE"}

package/dist/utils/tailwind/tailwind-styles.d.ts

@@ -0,0 +1,219 @@
+/**
+ * AUTO-GENERATED — run: node scripts/generate-tailwind-styles.js
+ *
+ * Tailwind style data for dropdown options, validation, and class ↔ prop key mapping.
+ * Generated from tailwindcss/defaultTheme + tailwindcss/colors.
+ */
+export declare const RootClassGenProps: any[];
+export declare const fonts: string[][];
+export declare function getColorPalette(): {
+    key: string;
+    color: {
+        key: string;
+        color: any;
+    }[];
+}[];
+export declare const TailwindStyles: {
+    m: string[];
+    p: string[];
+    gap: string[];
+    mx: string[];
+    my: string[];
+    px: string[];
+    py: string[];
+    ml: string[];
+    mr: string[];
+    mt: string[];
+    mb: string[];
+    pl: string[];
+    pr: string[];
+    pt: string[];
+    pb: string[];
+    background: string[];
+    text: string[];
+    backgroundRepeat: string[];
+    backgroundSize: string[];
+    backgroundAttachment: string[];
+    backgroundOrigin: string[];
+    backgroundPosition: string[];
+    gradients: string[];
+    fontSize: string[];
+    fontWeight: string[];
+    lineHeight: string[];
+    tracking: string[];
+    radius: string[];
+    border: string[];
+    borderStyle: string[];
+    ringWidth: string[];
+    outlineWidth: string[];
+    ringOffsetWidth: string[];
+    outlineOffset: string[];
+    outlineStyle: string[];
+    shadow: string[];
+    dropShadows: string[];
+    width: string[];
+    allWidths: string[];
+    height: string[];
+    maxWidths: string[];
+    maxHeights: string[];
+    minWidths: string[];
+    minHeights: string[];
+    marginTop: string[];
+    gapX: string[];
+    gapY: string[];
+    spaceX: string[];
+    spaceY: string[];
+    scrollM: string[];
+    scrollMx: string[];
+    scrollMy: string[];
+    scrollMs: string[];
+    scrollMe: string[];
+    scrollMt: string[];
+    scrollMr: string[];
+    scrollMb: string[];
+    scrollMl: string[];
+    scrollP: string[];
+    scrollPx: string[];
+    scrollPy: string[];
+    scrollPt: string[];
+    scrollPr: string[];
+    scrollPb: string[];
+    scrollPl: string[];
+    divideAxis: string[];
+    divideX: string[];
+    divideY: string[];
+    divideStyle: string[];
+    opacity: string[];
+    display: string[];
+    position: string[];
+    overflow: string[];
+    flexDirection: string[];
+    flexBase: string[];
+    helpers: string[];
+    wrap: string[];
+    grow: string[];
+    shrink: string[];
+    alignItems: string[];
+    justifyContent: string[];
+    alignSelf: string[];
+    justifySelf: string[];
+    justifyItems: string[];
+    gridCols: string[];
+    gridRows: string[];
+    gridAutoFlow: string[];
+    gridAutoColumns: string[];
+    gridAutoRows: string[];
+    gridColSpan: string[];
+    gridColStart: string[];
+    gridColEnd: string[];
+    gridRowSpan: string[];
+    gridRowStart: string[];
+    gridRowEnd: string[];
+    placeContent: string[];
+    placeItems: string[];
+    placeSelf: string[];
+    inset: string[];
+    top: string[];
+    right: string[];
+    bottom: string[];
+    left: string[];
+    zIndex: string[];
+    cursor: string[];
+    order: string[];
+    objectFit: string[];
+    objectPosition: string[];
+    aspectRatio: string[];
+    textDecoration: string[];
+    decorationStyle: string[];
+    decorationThickness: string[];
+    transform: string[];
+    wordBreak: string[];
+    textOverflow: string[];
+    textAlign: string[];
+    whiteSpace: string[];
+    textWrap: string[];
+    hyphens: string[];
+    verticalAlign: string[];
+    fontSmoothing: string[];
+    fontStyle: string[];
+    float: string[];
+    visibility: string[];
+    pointerEvents: string[];
+    userSelect: string[];
+    resize: string[];
+    touchAction: string[];
+    scrollBehavior: string[];
+    scrollSnapType: string[];
+    scrollSnapAlign: string[];
+    scrollSnapStop: string[];
+    overscrollBehavior: string[];
+    overscrollBehaviorX: string[];
+    overscrollBehaviorY: string[];
+    appearance: string[];
+    bgClip: string[];
+    bgBlend: string[];
+    mixBlend: string[];
+    boxSizing: string[];
+    isolation: string[];
+    columns: string[];
+    breakBefore: string[];
+    breakInside: string[];
+    breakAfter: string[];
+    listStyleType: string[];
+    listStylePosition: string[];
+    tableLayout: string[];
+    captionSide: string[];
+    content: string[];
+    srOnly: string[];
+    fill: string[];
+    stroke: string[];
+    strokeWidth: string[];
+    indent: string[];
+    transitionProperty: string[];
+    duration: string[];
+    delay: string[];
+    ease: string[];
+    twAnimate: string[];
+    scale: string[];
+    scaleX: string[];
+    scaleY: string[];
+    rotate: string[];
+    skewX: string[];
+    skewY: string[];
+    transformOrigin: string[];
+    translateX: string[];
+    translateY: string[];
+    twTransform: string[];
+    blur: string[];
+    backdropBlur: string[];
+    brightness: string[];
+    backdropBrightness: string[];
+    contrast: string[];
+    backdropContrast: string[];
+    grayscale: string[];
+    backdropGrayscale: string[];
+    hueRotate: string[];
+    backdropHueRotate: string[];
+    invert: string[];
+    backdropInvert: string[];
+    saturate: string[];
+    backdropSaturate: string[];
+    sepia: string[];
+    backdropSepia: string[];
+    backdropOpacity: string[];
+    willChange: string[];
+    fonts: string[][];
+};
+export declare const AllStylesSet: Set<string>;
+export declare const AllStyles: string[];
+export declare const PREFIX_TO_KEY: Record<string, string>;
+export declare const PREFIX_ENTRIES: [string, string][];
+/** Check if a class is a valid Tailwind utility (known or arbitrary value) */
+export declare function isValidTailwindClass(cls: string): boolean;
+/**
+ * Map a Tailwind class to its prop key.
+ * Uses reverse index for known classes, falls back to prefix matching for arbitrary values.
+ * Aligns with toolbar / className-first keys: `TailwindStyles` stores text colors under `text` but UI uses `color`.
+ */
+export declare const classNameToVar: (name: string) => string | undefined;
+//# sourceMappingURL=tailwind-styles.d.ts.map

package/dist/utils/tailwind/tailwind-styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tailwind-styles.d.ts","sourceRoot":"","sources":["../../../src/utils/tailwind/tailwind-styles.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAQH,eAAO,MAAM,iBAAiB,OAAK,CAAC;AAIpC,eAAO,MAAM,KAAK,YAWjB,CAAC;AAMF,wBAAgB,eAAe;;;;;;IAU9B;AAID,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAygK1B,CAAC;AAkBF,eAAO,MAAM,YAAY,aAAU,CAAC;AACpC,eAAO,MAAM,SAAS,EAAE,MAAM,EAAiB,CAAC;AAIhD,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA+GhD,CAAC;AAGF,eAAO,MAAM,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EACD,CAAC;AAI7C,8EAA8E;AAC9E,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAOzD;AAQD;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,KAAG,MAAM,GAAG,SAgCtD,CAAC"}

package/dist/utils/tailwind/tailwind.d.ts

@@ -0,0 +1,17 @@
+import { BaseSelectorProps } from '../../components/selectors';
+export { AllStyles, AllStylesSet, fonts, getColorPalette, isValidTailwindClass, PREFIX_ENTRIES, PREFIX_TO_KEY, RootClassGenProps, TailwindStyles, } from './tailwind-styles';
+export { classNameToVar } from './className';
+export declare const CSStoObj: (pro: any) => any;
+export declare const applyAnimation: (prop: any, props: BaseSelectorProps, query?: any, enabled?: boolean) => any;
+export declare const fontWeightToNumber: {
+    "font-thin": number;
+    "font-extralight": number;
+    "font-light": number;
+    "font-normal": number;
+    "font-medium": number;
+    "font-semibold": number;
+    "font-bold": number;
+    "font-extrabold": number;
+    "font-black": number;
+};
+//# sourceMappingURL=tailwind.d.ts.map

package/dist/utils/tailwind/tailwind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tailwind.d.ts","sourceRoot":"","sources":["../../../src/utils/tailwind/tailwind.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAM/D,OAAO,EACL,SAAS,EACT,YAAY,EACZ,KAAK,EACL,eAAe,EACf,oBAAoB,EACpB,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,cAAc,GACf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAoB7C,eAAO,MAAM,QAAQ,GAAG,QAAG,QAQ1B,CAAC;AA+LF,eAAO,MAAM,cAAc,GACzB,MAAM,GAAQ,EACd,OAAO,iBAAiB,EACxB,QAAO,GAAU,EACjB,UAAS,OAAe,QAiIzB,CAAC;AAIF,eAAO,MAAM,kBAAkB;;;;;;;;;;CAU9B,CAAC"}

package/dist/utils/treeSharding.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Client-side tree decomposition for per-page saves.
+ * Minimal subset of lib/sharding.js — pure functions, no DB.
+ *
+ * Only extractPageShard + extractSharedShard are used (by editor.tsx save handler).
+ * The server-side lib/sharding.js owns the full decompose/assemble logic.
+ */
+/**
+ * Extract a single page's subtree from the full flat map.
+ */
+export declare function extractPageShard(flat: Record<string, any>, pageNodeId: string): Record<string, any>;
+/**
+ * Extract the shared shard (ROOT + non-page children + their subtrees).
+ */
+export declare function extractSharedShard(flat: Record<string, any>): Record<string, any>;
+//# sourceMappingURL=treeSharding.d.ts.map

package/dist/utils/treeSharding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeSharding.d.ts","sourceRoot":"","sources":["../../src/utils/treeSharding.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAcH;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACzB,UAAU,EAAE,MAAM,GACjB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAIrB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAejF"}

package/dist/utils/useBlockCategories.d.ts

@@ -0,0 +1,12 @@
+import { BlockCategory, BlockSubcategory } from '../define/blocksProvider';
+export type { BlockCategory, BlockSubcategory };
+/**
+ * Lightweight hook that fetches category metadata (names, counts, subcategories).
+ * Goes through the registered BlocksProvider (HTTP by default — see
+ * `registerBlocksProvider`).
+ */
+export declare function useBlockCategories(): {
+    categories: BlockCategory[];
+    isLoading: boolean;
+};
+//# sourceMappingURL=useBlockCategories.d.ts.map

package/dist/utils/useBlockCategories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBlockCategories.d.ts","sourceRoot":"","sources":["../../src/utils/useBlockCategories.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAGhF,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,CAAC;AAEhD;;;;GAIG;AACH,wBAAgB,kBAAkB;;;EAQjC"}

package/dist/utils/useCategoryBlocks.d.ts

@@ -0,0 +1,19 @@
+import { BlockItem } from '../define/blocksProvider';
+export type { BlockItem };
+/**
+ * Fetches blocks for a specific category (with full structure) on demand.
+ * Pass `null` as category to skip fetching.
+ */
+export declare function useCategoryBlocks(category: string | null, subcategory?: string | null, style?: string | null): {
+    blocks: BlockItem[];
+    isLoading: boolean;
+};
+/**
+ * Search blocks across all categories by query string.
+ * Returns blocks with structure for preview.
+ */
+export declare function useBlockSearch(query: string | null, style?: string | null): {
+    blocks: BlockItem[];
+    isLoading: boolean;
+};
+//# sourceMappingURL=useCategoryBlocks.d.ts.map

package/dist/utils/useCategoryBlocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCategoryBlocks.d.ts","sourceRoot":"","sources":["../../src/utils/useCategoryBlocks.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAG1D,YAAY,EAAE,SAAS,EAAE,CAAC;AAE1B;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,EAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;;;EAsBtB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;;;EAkBzE"}

package/dist/utils/usePanelUrl.d.ts

@@ -0,0 +1,41 @@
+export interface PanelUrlState {
+    panel: string | null;
+    /** Block category when `panel=blocks`; theme tab (`colors`|`styles`|`typography`) when `panel=theme`. */
+    cat: string | null;
+    sub: string | null;
+    sty: string | null;
+    q: string | null;
+}
+export type PanelType = "menu" | "components" | "blocks" | "publish" | "import-export" | "theme";
+/** Open a panel from outside React (registry commands, dispatcher). */
+export declare function panelOpen(panelType: PanelType, params?: Partial<Omit<PanelUrlState, "panel">>): void;
+/** Close any open panel from outside React. */
+export declare function panelClose(): void;
+/** Toggle a specific panel from outside React (close if open, else open). */
+export declare function panelToggle(panelType: PanelType, params?: Partial<Omit<PanelUrlState, "panel">>): void;
+/** Toggle the toolbox insert panel (components/blocks) from outside React. */
+export declare function panelToggleToolboxInsert(): void;
+/** Read the current panel state from outside React. */
+export declare function getPanelState(): PanelUrlState;
+/** Full-column flyout over the unified settings stack — disable tool column pointer-events and skip click-away close. */
+export declare function isFlyoutBlockingToolColumn(panel: string | null): boolean;
+export declare function usePanelUrl(): {
+    state: PanelUrlState;
+    panel: PanelType;
+    isOpen: boolean;
+    open: (panelType: PanelType, params?: Partial<Omit<PanelUrlState, "panel">>) => void;
+    close: () => void;
+    toggle: (panelType: PanelType, params?: Partial<Omit<PanelUrlState, "panel">>) => void;
+    toggleToolboxInsert: () => void;
+    switchTab: (panelType: PanelType) => void;
+    navigate: (params: Partial<PanelUrlState>) => void;
+    update: (params: Partial<PanelUrlState>) => void;
+    enterSearchMode: () => void;
+    exitSearchMode: () => void;
+};
+export declare function markToolboxHistorySelectionSync(): void;
+/** True once after mark — consume so the next selection delta re-baselines, not closes. */
+export declare function takeToolboxHistorySelectionSyncForRebaseline(): boolean;
+/** If undo/redo did not change selection, clear a stale mark (after React effects). */
+export declare function finalizeToolboxHistorySelectionSync(): void;
+//# sourceMappingURL=usePanelUrl.d.ts.map

package/dist/utils/usePanelUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePanelUrl.d.ts","sourceRoot":"","sources":["../../src/utils/usePanelUrl.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,yGAAyG;IACzG,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClB;AAmGD,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,YAAY,GAAG,QAAQ,GAAG,SAAS,GAAG,eAAe,GAAG,OAAO,CAAC;AAEjG,uEAAuE;AACvE,wBAAgB,SAAS,CACvB,SAAS,EAAE,SAAS,EACpB,MAAM,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,GAC7C,IAAI,CAYN;AAED,+CAA+C;AAC/C,wBAAgB,UAAU,IAAI,IAAI,CAKjC;AAED,6EAA6E;AAC7E,wBAAgB,WAAW,CACzB,SAAS,EAAE,SAAS,EACpB,MAAM,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,GAC7C,IAAI,CAkBN;AAED,8EAA8E;AAC9E,wBAAgB,wBAAwB,IAAI,IAAI,CAmB/C;AAED,uDAAuD;AACvD,wBAAgB,aAAa,IAAI,aAAa,CAE7C;AAID,yHAAyH;AACzH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAIxE;AAED,wBAAgB,WAAW;;;;sBAeX,SAAS,WAAW,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;;wBAazD,SAAS,WAAW,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;;2BAe7B,SAAS;uBAOb,OAAO,CAAC,aAAa,CAAC;qBAOxB,OAAO,CAAC,aAAa,CAAC;;;EAkC3D;AASD,wBAAgB,+BAA+B,SAE9C;AAED,2FAA2F;AAC3F,wBAAgB,4CAA4C,IAAI,OAAO,CAItE;AAED,uFAAuF;AACvF,wBAAgB,mCAAmC,SAIlD"}

package/dist/utils/useSectionTemplates.d.ts

@@ -0,0 +1,15 @@
+import { BlockItem } from '../define/blocksProvider';
+interface SectionTemplateData {
+    categories: {
+        id: string;
+        name: string;
+        order?: number;
+    }[];
+    templates: Record<string, BlockItem[]>;
+}
+export declare function useSectionTemplates(): {
+    data: SectionTemplateData | null;
+    isLoading: boolean;
+};
+export {};
+//# sourceMappingURL=useSectionTemplates.d.ts.map

package/dist/utils/useSectionTemplates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSectionTemplates.d.ts","sourceRoot":"","sources":["../../src/utils/useSectionTemplates.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D,UAAU,mBAAmB;IAC3B,UAAU,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC3D,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;CACxC;AAED,wBAAgB,mBAAmB,IAAI;IAAE,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CA6B9F"}

package/dist/utils/validation.d.ts

@@ -0,0 +1,3 @@
+export declare const isCssValid: (code: string) => boolean;
+export declare const isJsValid: (code: string) => boolean;
+//# sourceMappingURL=validation.d.ts.map

package/dist/utils/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/utils/validation.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,KAAG,OAQzC,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,KAAG,OASxC,CAAC"}

package/dist/viewer.d.ts

@@ -0,0 +1,30 @@
+import { default as React } from 'react';
+import { ResolvedComponentDef } from './define/types';
+interface PageHubViewerProps {
+    /** Compressed page content (from PageData.content) */
+    content: string;
+    /** Additional component resolver — merged with default */
+    resolver?: Record<string, React.ComponentType<any>>;
+    /** Custom components registered via defineComponent() */
+    components?: ResolvedComponentDef[];
+    /** Class name for the container */
+    className?: string;
+    /** Inline styles for the container */
+    style?: React.CSSProperties;
+}
+/**
+ * Read-only page viewer.
+ */
+export declare function PageHubViewer({ content, resolver, components, className, style, }: PageHubViewerProps): import("react/jsx-runtime").JSX.Element;
+interface ViewerRenderOptions {
+    container: HTMLElement | string;
+    content: string;
+    resolver?: Record<string, React.ComponentType<any>>;
+    components?: ResolvedComponentDef[];
+}
+/**
+ * Mount the viewer into a DOM element (vanilla JS API).
+ */
+export declare function renderViewer(options: ViewerRenderOptions): () => void;
+export {};
+//# sourceMappingURL=viewer.d.ts.map