@webx-ui/module-blocks 0.2.0 → 0.4.0

package/dist/BlocksField.d.ts

@@ -54,11 +54,15 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
         mode?: "wide" | "phone";
         reload?: number;
         fill?: boolean;
-    }> & Readonly<{}>, {
+    }> & Readonly<{
+        onSelect?: ((key: string | null) => any) | undefined;
+    }>, {
         replace: (key: string, html: string) => boolean;
         refresh: () => void;
         open: () => boolean;
-    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        select: (key: string | null) => any;
+    }, import('vue').PublicProps, {
         fill: boolean;
         mode: "wide" | "phone";
         selected: string | null;
@@ -79,7 +83,9 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
         mode?: "wide" | "phone";
         reload?: number;
         fill?: boolean;
-    }> & Readonly<{}>, {
+    }> & Readonly<{
+        onSelect?: ((key: string | null) => any) | undefined;
+    }>, {
         replace: (key: string, html: string) => boolean;
         refresh: () => void;
         open: () => boolean;

package/dist/BlocksPreview.d.ts

@@ -25,7 +25,11 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {
     replace: typeof replace;
     refresh: typeof refresh;
     open: () => boolean;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (key: string | null) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((key: string | null) => any) | undefined;
+}>, {
     fill: boolean;
     mode: "wide" | "phone";
     selected: string | null;

package/dist/BlocksTree.d.ts

@@ -20,12 +20,14 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
     add: (parentKey: string | null, field: string | null, node: ScreenNode | null) => any;
     remove: (key: string) => any;
     duplicate: (key: string) => any;
+    visibility: (key: string, hidden: boolean) => any;
     reorder: (parentKey: string | null, field: string | null, list: BlockNode[]) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onSelect?: ((key: string) => any) | undefined;
     onAdd?: ((parentKey: string | null, field: string | null, node: ScreenNode | null) => any) | undefined;
     onRemove?: ((key: string) => any) | undefined;
     onDuplicate?: ((key: string) => any) | undefined;
+    onVisibility?: ((key: string, hidden: boolean) => any) | undefined;
     onReorder?: ((parentKey: string | null, field: string | null, list: BlockNode[]) => any) | undefined;
 }>, {
     disabled: boolean;

package/dist/content.d.ts

@@ -28,12 +28,22 @@ export declare function locate(tree: BlockNode[], key: string): Located | null;
 export declare function walk(tree: BlockNode[], visit: (node: BlockNode, depth: number, parent: BlockNode | null) => void, depth?: number, parent?: BlockNode | null): void;
 /** How many instances of a type the tree holds, nested ones included. */
 export declare function countType(tree: BlockNode[], slug: string): number;
+/** How many blocks sit inside a node, at any depth — what removing it takes with it. */
+export declare function countInside(node: BlockNode): number;
 /** The distinct types a tree uses, in first-seen order. */
 export declare function typesIn(tree: BlockNode[]): string[];
 /** The `wx-blocks` nodes of a schema, through cards and tabs. */
 export declare function nestedFields(schema: ScreenNode[]): ScreenNode[];
 /** A copy with fresh keys all the way down — what a duplicate is. */
 export declare function cloneNode(node: BlockNode): BlockNode;
+/**
+ * Switch a block off, or back on.
+ *
+ * Showing it removes the key rather than writing `false`, so a block that was never hidden and
+ * one that was hidden and shown again are the same content — and the revision that guards a
+ * save says so.
+ */
+export declare function setHidden(tree: BlockNode[], key: string, hidden: boolean): BlockNode[];
 export declare function insertNode(tree: BlockNode[], parentKey: string | null, field: string | null, index: number, node: BlockNode): BlockNode[];
 export declare function removeNode(tree: BlockNode[], key: string): BlockNode[];
 export declare function updateValues(tree: BlockNode[], key: string, values: Record<string, unknown>): BlockNode[];

package/dist/frame.d.ts

@@ -8,6 +8,7 @@
  * reachable and nothing has to be injected into the site's markup beyond one stylesheet.
  */
 export declare const SELECTED_CLASS = "wx-preview-selected";
+export declare const HOVER_CLASS = "wx-preview-hover";
 export interface MarkerRange {
     start: Comment;
     end: Comment;
@@ -24,6 +25,36 @@ export declare function replaceBlock(doc: Document, key: string, html: string):
 export declare function blockElement(root: Node, key: string): Element | null;
 /** Mark one block as the selected one, and nothing else. Null clears the selection. */
 export declare function highlightBlock(doc: Document, key: string | null): Element | null;
+/** Mark one block as the one under the pointer. Null clears it. */
+export declare function hoverBlock(doc: Document, key: string | null): void;
+/**
+ * Which block an element inside the page belongs to — the innermost one, since a block nested
+ * in a container is what somebody pointing at it means.
+ *
+ * The markers are comments among an element's siblings rather than around it, so this walks
+ * back through the previous siblings counting closers: a `/wx:` met on the way out belongs to
+ * a block that has already ended, and its opener is not ours. Nothing found at this level
+ * means the search carries on in the parent.
+ */
+export declare function keyAt(node: Node | null): string | null;
+/** What was bound to the page, so that a reload can let go of the old document. */
+export interface FrameBinding {
+    release(): void;
+}
+/**
+ * Make the preview a picture of the page rather than the page itself.
+ *
+ * Every pointer event is taken at the document, in the capture phase, and goes no further:
+ * stopped there it never reaches a link, a form or a block's own script, so nothing in the
+ * preview navigates, submits or opens anything. What a click does instead is choose the block
+ * it landed in, which is the one thing the editor wants from it.
+ *
+ * Bound per document: an iframe that reloads gets a new one, and the old binding is released
+ * with it.
+ */
+export declare function bindFrame(doc: Document, handlers: {
+    select: (key: string | null) => void;
+}): FrameBinding;
 export interface StageInput {
     html: string;
     styles: string;