@webx-ui/module-blocks 0.11.7 → 0.13.0

package/dist/BlockExportDialog.d.ts

@@ -0,0 +1,14 @@
+/**
+ * "Export" (§17.1): the types to take, ticked, and one file out — the command's documents in a
+ * pack. The components the chosen types call are not offered as a choice: the server adds them,
+ * because a block without them draws nothing on the site it lands on, and a person exporting a
+ * block for another site would only find that out there.
+ *
+ * Opened from a type's editor, it comes with that type ticked: a block for the catalogue of
+ * ready blocks is made one at a time.
+ */
+type __VLS_Props = {
+    selected?: string[];
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/BlockImportDialog.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    picker: HTMLInputElement;
+}, any>;
+export default _default;

package/dist/BlocksField.d.ts

@@ -1,3 +1,4 @@
+import { ShortcodeToken } from '@webx-ui/module-admin';
 import { RenderContext, ScreenNode } from '@webx-ui/schema';
 import { BlockNode, BlockType } from './types';
 type __VLS_Props = {
@@ -18,6 +19,11 @@ type __VLS_Props = {
     disabled?: boolean;
     /** Where the section lives, for the picker's "make one" link. */
     blocksPath?: string;
+    /**
+     * The site's shortcodes, offered in the text fields of a block. Fetched from the panel when
+     * absent, like the catalog.
+     */
+    shortcodes?: ShortcodeToken[] | null;
 };
 type __VLS_PublicProps = {
     modelValue?: BlockNode[];
@@ -28,10 +34,11 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
     "onUpdate:modelValue"?: ((value: BlockNode[]) => any) | undefined;
 }>, {
     allow: string[] | null;
+    shortcodes: ShortcodeToken[] | null;
     disabled: boolean;
     name: string;
-    node: ScreenNode;
     localized: boolean;
+    node: ScreenNode;
     max: number | null;
     context: RenderContext;
     catalog: BlockType[] | null;
@@ -43,6 +50,7 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
         selected?: string | null;
         reload?: number;
         compact?: boolean;
+        hidden?: string[];
     }> & Readonly<{
         onSelect?: ((key: string | null) => any) | undefined;
         onEdit?: (() => any) | undefined;
@@ -54,8 +62,9 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
         select: (key: string | null) => any;
         edit: () => any;
     }, import('vue').PublicProps, {
-        compact: boolean;
+        hidden: string[];
         selected: string | null;
+        compact: boolean;
         reload: number;
     }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
         bar: HTMLDivElement;
@@ -73,6 +82,7 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
         selected?: string | null;
         reload?: number;
         compact?: boolean;
+        hidden?: string[];
     }> & Readonly<{
         onSelect?: ((key: string | null) => any) | undefined;
         onEdit?: (() => any) | undefined;
@@ -81,8 +91,9 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
         refresh: () => void;
         open: () => boolean;
     }, {}, {}, {}, {
-        compact: boolean;
+        hidden: string[];
         selected: string | null;
+        compact: boolean;
         reload: number;
     }> | null;
 }, any>;

package/dist/BlocksPreview.d.ts

@@ -17,6 +17,8 @@ type __VLS_Props = {
      * there is no tree standing next to it to click.
      */
     compact?: boolean;
+    /** Keys of the blocks switched off: marked in the page until it reloads without them. */
+    hidden?: string[];
 };
 /** Swap one block's markup in place; false when the page has to be reloaded instead. */
 declare function replace(key: string, html: string): boolean;
@@ -32,8 +34,9 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {
     onSelect?: ((key: string | null) => any) | undefined;
     onEdit?: (() => any) | undefined;
 }>, {
-    compact: boolean;
+    hidden: string[];
     selected: string | null;
+    compact: boolean;
     reload: number;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     bar: HTMLDivElement;

package/dist/BlocksTree.d.ts

@@ -18,11 +18,17 @@ type __VLS_Props = {
     selected?: string | null;
     disabled?: boolean;
     depth?: number;
+    /** What the last save was refused for, by block key. */
+    errors?: Record<string, string[]>;
+    /** What "Copy" put aside, for the paste lines; null while there is nothing. */
+    clip?: BlockNode[] | null;
 };
 declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     add: (parentKey: string | null, field: string | null, node: ScreenNode | null, index?: number | undefined) => any;
     remove: (key: string) => any;
     duplicate: (key: string) => any;
+    copy: (key: string) => any;
+    paste: (parentKey: string | null, field: string | null, node: ScreenNode | null, index?: number | undefined) => any;
     move: (key: string) => any;
     select: (key: string) => any;
     visibility: (key: string, hidden: boolean) => any;
@@ -31,6 +37,8 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
     onAdd?: ((parentKey: string | null, field: string | null, node: ScreenNode | null, index?: number | undefined) => any) | undefined;
     onRemove?: ((key: string) => any) | undefined;
     onDuplicate?: ((key: string) => any) | undefined;
+    onCopy?: ((key: string) => any) | undefined;
+    onPaste?: ((parentKey: string | null, field: string | null, node: ScreenNode | null, index?: number | undefined) => any) | undefined;
     onMove?: ((key: string) => any) | undefined;
     onSelect?: ((key: string) => any) | undefined;
     onVisibility?: ((key: string, hidden: boolean) => any) | undefined;
@@ -38,10 +46,12 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
 }>, {
     field: string | null;
     disabled: boolean;
+    selected: string | null;
     depth: number;
+    errors: Record<string, string[]>;
     max: number | null;
-    selected: string | null;
     parentKey: string | null;
     fieldNode: ScreenNode | null;
+    clip: BlockNode[] | null;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/api.d.ts

@@ -1,5 +1,5 @@
 import { AdminContext } from '@webx-ui/module-admin';
-import { BlockInput, BlockList, BlockType, BlockUsage, BlockVersion, BlockNode, BlockVersionMeta, RegionAdopted, RegionDetail, RegionRow, RegionVersion, RenderInput, RenderResult } from './types';
+import { BlockExport, BlockImportRow, BlockInput, BlockList, BlockType, BlockUsage, BlockVersion, BlockNode, BlockVersionMeta, RegionAdopted, RegionDetail, RegionRow, RegionVersion, RenderInput, RenderResult } from './types';
 export interface BlocksApi {
     /** Every type, without content: the section's list. */
     list(): Promise<BlockType[]>;
@@ -13,7 +13,10 @@ export interface BlocksApi {
     remove(id: number): Promise<void>;
     /** A declared place made into the site's own type: an unpublished draft of the module's view. */
     customise(slug: string): Promise<BlockType>;
-    publish(id: number): Promise<BlockType>;
+    /** `dropTranslations` agrees to keep one language where a field stops being localized. */
+    publish(id: number, options?: {
+        dropTranslations?: boolean;
+    }): Promise<BlockType>;
     render(id: number, input?: RenderInput): Promise<RenderResult>;
     usage(id: number): Promise<BlockUsage[]>;
     versions(id: number): Promise<BlockVersionMeta[]>;
@@ -21,6 +24,19 @@ export interface BlocksApi {
     restore(id: number, number: number): Promise<BlockType>;
     /** The new order of some types — a group — in the places they held; the rest stay put. */
     reorder(ids: number[]): Promise<void>;
+    /** A pack of the types named — every type when none is — and the components they call. */
+    exportPack(slugs: string[], options?: {
+        draft?: boolean;
+    }): Promise<BlockExport>;
+    /**
+     * What the file would do (`dryRun`), or what it did. Drafts, unless `publish` is asked for.
+     * The file goes as its text: the server compares it with what is stored, whitespace included.
+     */
+    importPack(file: string, options?: {
+        name?: string;
+        dryRun?: boolean;
+        publish?: boolean;
+    }): Promise<BlockImportRow[]>;
 }
 /** Everything under `/blocks`, below the panel's API path. */
 export declare function createBlocksApi(admin: AdminContext): BlocksApi;
@@ -30,13 +46,14 @@ export interface RegionsApi {
     get(name: string): Promise<RegionDetail>;
     /**
      * Save the draft. Refused with a 409 when the revision is not the current one — the error's
-     * body is a {@link RegionConflict} carrying the revision to write over.
+     * body is a {@link RegionConflict}: the region as it now is, to merge with.
      */
     save(name: string, input: {
         blocks: BlockNode[];
         revision?: string;
     }): Promise<RegionDetail>;
-    publish(name: string): Promise<RegionDetail>;
+    /** `revision` is what the editor held: a draft that moved on since is answered 409, not published. */
+    publish(name: string, revision?: string): Promise<RegionDetail>;
     /** Off the site: the code's view comes back, the blocks stay as the draft. */
     unpublish(name: string): Promise<RegionDetail>;
     discardDraft(name: string): Promise<RegionDetail>;

package/dist/clipboard.d.ts

@@ -0,0 +1,64 @@
+import { Ref } from 'vue';
+import { ScreenNode } from '@webx-ui/schema';
+import { BlockNode, BlockType } from './types';
+/**
+ * Copy and paste of blocks, across pages and across modules of the same panel.
+ *
+ * The clipboard is the browser's storage rather than the system one: a block is not text, the
+ * system clipboard asks for permission to be read, and what is copied here is only ever pasted
+ * into a constructor of the same site — every module stores the same `{ key, type, values }`.
+ * One entry, kept after a paste, so the same block can go onto several pages; every tab sees
+ * what another one copied.
+ */
+export declare const CLIPBOARD_KEY = "wx-blocks-clipboard";
+export interface BlocksClip {
+    format: 'webx-blocks-clip';
+    /** Bumped when the shape changes; a clip of another version is treated as empty. */
+    format_version: 1;
+    copied_at: string;
+    nodes: BlockNode[];
+}
+/** What is stored, if it is a clip this code understands — anything else is no clip at all. */
+export declare function parseClip(raw: string | null): BlocksClip | null;
+export declare function useBlocksClipboard(): {
+    clip: Readonly<Ref<BlocksClip | null>>;
+    copy: (nodes: BlockNode[]) => void;
+    clear: () => void;
+};
+/** Why a block of the clip did not go in. */
+export type SkipReason = 'unknown' | 'place' | 'limit' | 'full';
+/** The list a paste goes into, and the rules that list stands under. */
+export interface PasteTarget {
+    /** The whole tree of the page, for the per-page limits of the types. */
+    tree: BlockNode[];
+    /** The list itself — the tree, or a container's field. */
+    list: BlockNode[];
+    /** The container's type, or the top level's owner (a block's sample form), or null. */
+    parent: BlockType | null;
+    allow: string[] | null;
+    max: number | null;
+    /** What the list is called in `allowed_in`; only the top level is ever anything but `root`. */
+    root: string;
+}
+export interface PastePlan {
+    /** Fresh copies, keys renewed all the way down, in the clip's order. */
+    accepted: BlockNode[];
+    skipped: {
+        node: BlockNode;
+        reason: SkipReason;
+    }[];
+}
+/**
+ * What of the clip may go into this list, judged by the same rules the picker and "Move to"
+ * go by, so a paste never puts down what adding by hand would not.
+ *
+ * Block by block rather than all or nothing: a page copied whole into a region that takes half
+ * of it gets that half, and the rest is named. A block whose type — or the type of anything
+ * inside it — this site does not offer is left out whole: half a section is not that section.
+ */
+export declare function planPaste(nodes: BlockNode[], target: PasteTarget, catalog: BlockType[]): PastePlan;
+/** A container field's own rules, read off its node in the type's schema. */
+export declare function slotRules(slot: ScreenNode | null): {
+    allow: string[] | null;
+    max: number | null;
+};

package/dist/frame.d.ts

@@ -25,6 +25,13 @@ 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;
+export declare const HIDDEN_CLASS = "wx-preview-hidden";
+/**
+ * Mark the blocks switched off. The page drawn under the preview token leaves a hidden block out,
+ * but one hidden after the page was drawn is still in the frame until it reloads — and it looked
+ * exactly like the blocks that will be on the site.
+ */
+export declare function markHidden(doc: Document, keys: string[]): void;
 /** Mark one block as the one under the pointer. Null clears it. */
 export declare function hoverBlock(doc: Document, key: string | null): void;
 /**