pagepilot-visual-editor 1.0.33 → 1.0.35

package/dist/editor-sample/documents/editor/changeSectionDesign.d.ts

@@ -0,0 +1,36 @@
+import { TemplateSource } from './sectionScope';
+/**
+ * "Change design": swap one section on the page for another block template
+ * while keeping the section's content.
+ *
+ * The new design takes the old section's place and its field scope (`__<n>`),
+ * and each of its fields takes the old value with the same plain id. A repeat
+ * list keeps all of its rows — the new design's row blocks are added/removed
+ * (growing its grid if needed) to match. Values the new design has no field
+ * for are dropped, so a section only ever carries its current design's data.
+ *
+ * Pure: returns the next document; the caller commits it.
+ */
+type Doc = Record<string, any>;
+type Field = Record<string, any>;
+export type ChangeSectionDesignResult = {
+    doc: Doc;
+    newRootIds: string[];
+    /** Plain ids of fields whose value came from the old design. */
+    carried: string[];
+    /** Plain ids of old values the new design has no field for (removed). */
+    dropped: string[];
+    /** Repeat fields that couldn't get a row block for every row. */
+    capacityLimited: string[];
+};
+export declare function changeSectionDesign({ doc, sectionRootId, configuration, templateFields, source, }: {
+    doc: Doc;
+    /** Top-level block of the section being replaced. */
+    sectionRootId: string;
+    /** The new block template's configuration ({ rootBlockId, blocks, childrenIds? }). */
+    configuration: any;
+    /** The new template's authored formFields. */
+    templateFields: Field[];
+    source: TemplateSource;
+}): ChangeSectionDesignResult | null;
+export {};

package/dist/editor-sample/documents/editor/core.d.ts

@@ -2284,6 +2284,9 @@ export declare const EditorBlock: ({ type, data }: import('@usewaypoint/document
         submenuBackgroundColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         submenuRadius: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
         submenuIconSize: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        submenuTextColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        submenuFontSize: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        submenuFontWeight: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         submenuPadding: z.ZodNullable<z.ZodOptional<z.ZodObject<{
             top: z.ZodNumber;
             right: z.ZodNumber;

package/dist/editor-sample/documents/editor/sectionScope.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Section-scoped template fields.
+ *
+ * A block template placed on a page is a "section". Its top-level block(s) are
+ * stamped with `data.templateSource` so the editor knows which template and
+ * category the section came from (used by "Change design" to preselect the
+ * category, and below to tell sections of the same kind apart).
+ *
+ * Fields are page-wide by id: a header and a footer that both use
+ * `{{phoneNumber}}` show one value. A second section of the SAME kind must not
+ * share, though — two FAQ sections need their own title and Q&A list. So when
+ * a section's fields collide with another section of its kind, EVERY field of
+ * the new section gets the same `__<n>` suffix (n ≥ 2) and its `{{tokens}}` are
+ * rewritten to match. The suffix is digits only because bare `{{tokens}}` only
+ * allow `[a-zA-Z0-9_]`.
+ *
+ * Pure functions over the document tree; callers write the results.
+ */
+export type TemplateSource = {
+    templateId?: string;
+    name?: string;
+    category?: string;
+    /** The `__<n>` suffix this section's fields carry; absent for plain ids. */
+    scope?: number;
+};
+type Doc = Record<string, any>;
+type Field = Record<string, any>;
+export declare const baseFieldId: (id: string) => string;
+export declare const getTemplateSource: (block: any) => TemplateSource | undefined;
+export declare const withTemplateSource: (block: any, source: TemplateSource) => any;
+export declare function subtreeIdsOf(doc: Doc, rootId: string): string[];
+/** Top-level `{{token}}` ids used by the given blocks (`{{this.x}}` excluded). */
+export declare function tokenIdsIn(doc: Doc, ids: Iterable<string>): Set<string>;
+/** Repeat fields bound to one block instance (container-repeat or items-array). */
+export declare const isBlockScoped: (f: Field) => boolean;
+export declare const scopedFieldName: (name: string, scope?: number) => string;
+export declare const blockIdsOutside: (doc: Doc, exclude: Set<string>) => string[];
+/** The fields a section uses: tokens inside it plus repeat fields anchored inside it. */
+export declare function sectionFieldsOf(doc: Doc, rootId: string, fields: Field[]): Field[];
+/**
+ * Decide the field ids for a section that was just added to `doc` (its blocks,
+ * `sectionIds`, are already in `doc`).
+ *
+ * - Existing fields with an incoming id that nothing outside the section uses
+ *   any more are dropped, so a swapped-in design takes the plain ids back.
+ * - When an incoming id collides with a field owned by a section of the same
+ *   kind, every incoming field is suffixed `__<n>` and the section's tokens
+ *   are rewritten; `blocks` holds the rewritten blocks and `scope` is `n`.
+ * - Otherwise nothing is renamed: the caller keeps its normal dedupe (scalars
+ *   shared by id, colliding repeat fields suffixed).
+ */
+export declare function scopeSectionFields({ doc, existing, incoming, sectionIds, source, }: {
+    doc: Doc;
+    existing: Field[];
+    incoming: Field[];
+    sectionIds: Set<string>;
+    source?: TemplateSource;
+}): {
+    existing: Field[];
+    incoming: Field[];
+    blocks: Doc;
+    scope?: number;
+};
+/**
+ * After sections are removed: a scoped section whose plain ids are all free
+ * again (no field uses them) takes them back, lowest scope first. Returns null
+ * when nothing changes.
+ */
+export declare function unscopeSections(doc: Doc, fields: Field[]): {
+    blocks: Doc;
+    fields: Field[];
+} | null;
+export {};

package/dist/editor-sample/documents/editor/templateVariables.d.ts

@@ -4,13 +4,14 @@ import { DateFormatPreset, TimeFormatPreset } from '../../../host-stubs/utils/da
  * The kinds of single-value template field. `array` is repeatable and handled
  * separately. `text` / `textarea` substitute as plain strings, `number` as a
  * numeric string, `image` as an image URL (used in Image/Avatar/Logo blocks),
+ * `video` a video URL — media-library file or YouTube link (used in Video blocks),
  * `date` an ISO date string rendered through a display format (see `dateFormat`).
  * `time` an ISO date string rendered as just its time portion (see `timeFormat`).
  * `datetime` one ISO string exposing TWO sub-tokens — `{{id.date}}` (formatted
  *   via `dateFormat`) and `{{id.time}}` (via `timeFormat`) — so a single value /
  *   API mapping can print its date and time in separate blocks.
  */
-export type TemplateScalarType = 'text' | 'textarea' | 'number' | 'image' | 'date' | 'time' | 'datetime';
+export type TemplateScalarType = 'text' | 'textarea' | 'number' | 'image' | 'video' | 'date' | 'time' | 'datetime';
 export type TemplateFormType = TemplateScalarType | 'array';
 /** All scalar types — used by both top-level fields and array sub-fields. */
 export declare const TEMPLATE_SCALAR_TYPES: TemplateScalarType[];
@@ -108,7 +109,15 @@ export type TemplateFormField = {
      */
     dataSource?: {
         /** `api` = fetch an array of objects from a REST endpoint. */
-        type: 'custom' | 'custom-json' | 'api' | 'menu';
+        type: 'custom' | 'custom-json' | 'api' | 'menu' | 'pages';
+        /** `pages`: page group to list (tenant settings → groups). */
+        pageGroup?: string;
+        /** `pages`: sub-field id → page field (name, slug, thumbnailImage, …). */
+        pageFieldMap?: Record<string, string>;
+        /** POST body sent with `apiUrl` (the `pages` source builds it). */
+        apiBody?: Record<string, any>;
+        /** Minutes between automatic refreshes of the published page. 0/empty = off. */
+        ttlMinutes?: number;
         /** Raw JSON text for `custom-json`. */
         customJson?: string;
         /** Endpoint URL for the `api` source. Persisted in config. */

package/dist/email-builder-core/blocks/MenuPicker/MenuColumns.d.ts

@@ -4,10 +4,12 @@ type Props = {
     menuItems: any[];
     menuKey: string;
     textColor: string;
+    submenuTextColor?: string | null;
+    submenuFontSize?: string | null;
     backgroundColor: string;
     fontFamily?: string;
     start?: React.ReactNode;
     end?: React.ReactNode;
 };
-declare const MenuColumns: ({ p, menuItems, menuKey, textColor, backgroundColor, fontFamily, start, end }: Props) => import("react/jsx-runtime").JSX.Element;
+declare const MenuColumns: ({ p, menuItems, menuKey, textColor, submenuTextColor, submenuFontSize, backgroundColor, fontFamily, start, end }: Props) => import("react/jsx-runtime").JSX.Element;
 export default MenuColumns;

package/dist/email-builder-core/blocks/MenuPicker/MenuPropsSchema.d.ts

@@ -34,6 +34,9 @@ declare const MenuPropsInnerSchema: z.ZodObject<{
     submenuBackgroundColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     submenuRadius: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
     submenuIconSize: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    submenuTextColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    submenuFontSize: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    submenuFontWeight: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     submenuPadding: z.ZodNullable<z.ZodOptional<z.ZodObject<{
         top: z.ZodNumber;
         right: z.ZodNumber;
@@ -108,6 +111,9 @@ export declare const MenuPropsSchema: z.ZodObject<{
         submenuBackgroundColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         submenuRadius: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
         submenuIconSize: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        submenuTextColor: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        submenuFontSize: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        submenuFontWeight: z.ZodNullable<z.ZodOptional<z.ZodString>>;
         submenuPadding: z.ZodNullable<z.ZodOptional<z.ZodObject<{
             top: z.ZodNumber;
             right: z.ZodNumber;

package/dist/host-stubs/config.d.ts

@@ -0,0 +1,4 @@
+declare const config: {
+    readonly backendUrl: string;
+};
+export default config;

package/dist/host-stubs/modules/content/view/contentViewSelectors.d.ts

@@ -0,0 +1,4 @@
+declare const contentViewSelectors: {
+    selectRecord: any;
+};
+export default contentViewSelectors;

package/dist/host-stubs/view/page/form/dialog/PageVariablesPreview.d.ts

@@ -0,0 +1,5 @@
+type Props = {
+    document: any;
+};
+declare const PageVariablesPreview: ({ document }: Props) => import("react/jsx-runtime").JSX.Element;
+export default PageVariablesPreview;

package/dist/host-stubs/view/template/form/fields/renameFieldTokens.d.ts

@@ -0,0 +1,26 @@
+import { TemplateFieldDef } from './types';
+/**
+ * Maps of old → new ids for template fields renamed in the dialog.
+ * `fields` are top-level variables (`{{id}}`, `{{id.date}}`), `items` are
+ * array row sub-fields (`{{this.id}}`).
+ */
+export type FieldRenames = {
+    fields: Record<string, string>;
+    items: Record<string, string>;
+};
+export declare const EMPTY_RENAMES: FieldRenames;
+export declare const hasRenames: (r: FieldRenames) => boolean;
+/** `stableId → original id` snapshot taken when the dialog opens. */
+export type OriginalIds = {
+    fields: Map<string, string>;
+    items: Map<string, string>;
+};
+export declare function snapshotOriginalIds(fields: TemplateFieldDef[]): OriginalIds;
+/** Diffs the edited fields against the opening snapshot (matched by stableId). */
+export declare function computeRenames(fields: TemplateFieldDef[], original: OriginalIds): FieldRenames;
+/**
+ * Deep-rewrites `{{oldId}}` tokens inside every string of a JSON-like value.
+ * Returns the SAME reference when nothing changed so callers can cheaply
+ * detect which blocks were touched.
+ */
+export declare function renameTokensDeep<T>(value: T, renames: FieldRenames): T;

package/dist/host-stubs/view/template/form/fields/types.d.ts

@@ -1,3 +1,90 @@
+/** Single-value field kinds (everything except the repeatable `array`). */
+export type TemplateScalarType = 'text' | 'textarea' | 'number' | 'image' | 'video' | 'date' | 'time' | 'datetime';
+export type TemplateFieldType = TemplateScalarType | 'array';
+/** A row sub-field declared on an `array` template field. */
+export type TemplateItemFieldDef = {
+    /**
+     * Authoring-only React list key, distinct from the user-editable `id`.
+     * Generated client-side (see `addItem` / load-time backfill) and stripped
+     * before save — never sent to the backend.
+     */
+    stableId?: string;
+    id: string;
+    name: string;
+    /** Sub-field input kind. Defaults to `text`. */
+    type?: TemplateScalarType;
+    /** Author-set default value used to prefill the row on apply. */
+    defaultValue?: string;
+    /** `date` / `datetime` sub-fields — date display format (+ absolute-only tz). */
+    dateFormat?: import('../../../../utils/dateFormats').DateFormatPreset;
+    /** `time` / `datetime` sub-fields — 24h / AM/PM display. Timezone reuses `dateTz`. */
+    timeFormat?: import('../../../../utils/dateFormats').TimeFormatPreset;
+    dateTz?: string;
+};
+export type TemplateFieldDef = {
+    /**
+     * Authoring-only React list key, distinct from the user-editable `id`.
+     * Generated client-side (see `addField` / load-time backfill) and stripped
+     * before save — never sent to the backend.
+     */
+    stableId?: string;
+    id: string;
+    name: string;
+    type: TemplateFieldType;
+    /**
+     * Author flag: whether this field's block/content is meant to be repeated
+     * (e.g. across grid cells / carousel slides) once the template is applied.
+     * Purely descriptive metadata on the saved field — doesn't change how this
+     * dialog behaves, just carries the author's intent through to `formFields`.
+     */
+    repeatable?: boolean;
+    /** Author-set default — prefills the Variables tab when the template is applied. */
+    defaultValue?: string;
+    /** Declared row sub-fields — only present for `array` fields. */
+    itemFields?: TemplateItemFieldDef[];
+    /**
+     * `array` only — when set, this field repeats the CONTAINER block with this id
+     * instead of looping text. Auto-linked to the container being saved.
+     */
+    sourceBlockId?: string;
+    /**
+     * `array` + `sourceBlockId` only — ids of OTHER existing container blocks on the
+     * canvas (e.g. Carousel slides 2 & 3) that should be treated as pre-existing rows
+     * when the template is applied. These become the initial `rowIds` so all existing
+     * copies are wired up from the start.
+     */
+    additionalSourceBlockIds?: string[];
+    /**
+     * `array` + `sourceBlockId` only — per-row default data, one entry per row
+     * (row 0 = sourceBlock, row 1+ = additionalSourceBlockIds). Each entry is a
+     * map of subFieldId → defaultValue. Prefilled into the Variables tab on apply.
+     */
+    defaultRows?: Record<string, string>[];
+    /**
+     * Authoring-only convenience: blockId → that block's default-row data, so
+     * re-ordering the block selection keeps each block's typed values intact.
+     * Not persisted to the runtime field — `defaultRows` (positional) is the
+     * source of truth that gets saved.
+     */
+    defaultRowsByBlock?: Record<string, Record<string, string>>;
+    /**
+     * Tour/Demo templates only — which step this field belongs to. Zero-based.
+     * `undefined` means the field applies to all steps (legacy / global). On
+     * save, fields are grouped by `stepIndex` and embedded in that step's
+     * `contentMetadata.document.root.data.formFields`, so tokens declared for a
+     * given step travel with its document.
+     */
+    stepIndex?: number;
+};
+export declare const FIELD_TYPE_OPTIONS: {
+    value: TemplateFieldType;
+    label: string;
+}[];
+export declare const SUBFIELD_TYPE_OPTIONS: {
+    value: TemplateScalarType;
+    label: string;
+}[];
+/** Inline `{{token}}` chip styling used in hint text across the fields editor. */
 export declare const codeSx: {
     readonly px: 0.5;
     readonly py: 0.1;
@@ -5,3 +92,17 @@ export declare const codeSx: {
     readonly bgcolor: "action.hover";
     readonly fontSize: "0.85em";
 };
+/** Returns per-type TextField props (placeholder, multiline, input type). */
+export declare function defaultValueInputProps(type: TemplateScalarType | undefined): {
+    placeholder: string;
+    multiline: boolean;
+    minRows: number;
+    maxRows: number;
+    type: string;
+} | {
+    placeholder: string;
+    multiline: boolean;
+    type: string;
+    minRows?: undefined;
+    maxRows?: undefined;
+};