@webx-ui/module-blocks 0.8.9 → 0.9.1

package/dist/BlockCard.d.ts

@@ -1,11 +1,20 @@
 import { BlockType } from './types';
-/** One type in the list: its picture, its name, where it stands and which versions it has. */
+/**
+ * One type in the list: its picture, its name, where it stands and which versions it has.
+ *
+ * A component stands on no page — it stands in other blocks — so its line counts those instead,
+ * and one a module declared says which module's view it replaced.
+ */
 type __VLS_Props = {
     block: BlockType;
+    /** The name of the module that declared this slug, when one did. */
+    module?: string | null;
 };
 declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     open: (block: BlockType) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onOpen?: ((block: BlockType) => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+}>, {
+    module: string | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
 export default _default;

package/dist/BlockDataField.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `wx-data` in a component's sample form: a structure the caller passes from code, which nobody
+ * edits in the panel except to try the component on something else. So it is JSON, as it
+ * travels, in the code editor the rest of this screen is written in (§3.3).
+ *
+ * The text is kept as typed and the value changes only on JSON that parses: half a bracket is
+ * what the text looks like on every keystroke on the way to the next valid one, and a sample
+ * that became `null` in the middle of typing would redraw the stage empty each time. An empty
+ * editor is the one exception: that is `null` on purpose — the call that passes nothing, which
+ * a component has to survive, and which publishing checks when the sample says so.
+ */
+type __VLS_Props = {
+    modelValue?: unknown;
+    disabled?: boolean;
+    /** The shape's name (`recipes.card`): the help under the template describes it. */
+    shape?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: unknown) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: unknown) => any) | undefined;
+}>, {
+    shape: string;
+    modelValue: undefined;
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/BlockDeclaredCard.d.ts

@@ -0,0 +1,25 @@
+import { DeclaredComponent } from './types';
+/**
+ * A place a module declared and the site has not customised: the module draws its own view
+ * there. It stands among the components rather than in a settings page, because otherwise nobody
+ * learns the place can be changed at all (§3.9).
+ *
+ * No picture: there is no type to draw yet, and the module's view is drawn with data only the
+ * module has. The card says whose view it is and offers the one thing to do with it.
+ */
+type __VLS_Props = {
+    declared: DeclaredComponent;
+    /** The module's name as the panel shows it. */
+    module: string;
+    canManage?: boolean;
+    busy?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    customise: (declared: DeclaredComponent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCustomise?: ((declared: DeclaredComponent) => any) | undefined;
+}>, {
+    canManage: boolean;
+    busy: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/BlockEditorPage.d.ts

@@ -7,6 +7,11 @@
  *
  * The loop is closed all the same: edit the schema and the form rebuilds, edit the values and
  * the stage redraws, edit the template or the styles and so does it.
+ *
+ * A component is edited on the same screen (§3.9 of the components spec). What differs is what
+ * its schema means — the input a caller hands it, not a form — so the settings lose what only a
+ * block on a page needs, "Fields" become "Input data", and under the template stands the tag that
+ * calls it. Where it is used is the blocks that call it rather than pages.
  */
 type __VLS_Props = {
     base?: string;

package/dist/BlockPicker.d.ts

@@ -18,9 +18,9 @@ type __VLS_Props = {
     blocksPath?: string | null;
 };
 declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    parent: BlockType | null;
     allow: string[] | null;
     groups: string[];
+    parent: BlockType | null;
     tree: BlockNode[];
     blocksPath: string | null;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

package/dist/BlocksField.d.ts

@@ -27,10 +27,10 @@ declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {},
 }, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: BlockNode[]) => any) | undefined;
 }>, {
-    name: string;
+    allow: string[] | null;
     disabled: boolean;
+    name: string;
     node: ScreenNode;
-    allow: string[] | null;
     localized: boolean;
     max: number | null;
     context: RenderContext;

package/dist/BlocksPage.d.ts

@@ -2,6 +2,10 @@
  * The section: every type as a card with a live thumbnail, grouped the way the picker groups
  * them. Cards rather than a table because a block is recognised by its picture — "Section"
  * says nothing about whether it is a full-width band or a container with columns.
+ *
+ * Two kinds, two groups (§3.9 of the components spec): the blocks editors put on pages, then
+ * the components templates call. The places modules declared and the site has not customised
+ * stand among the components — a place nobody sees is a possibility nobody learns about.
  */
 type __VLS_Props = {
     base?: string;

package/dist/BlocksTree.d.ts

@@ -16,22 +16,22 @@ type __VLS_Props = {
     depth?: number;
 };
 declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    select: (key: string) => any;
     add: (parentKey: string | null, field: string | null, node: ScreenNode | null) => any;
     remove: (key: string) => any;
     duplicate: (key: string) => any;
+    select: (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;
+    onSelect?: ((key: string) => any) | undefined;
     onVisibility?: ((key: string, hidden: boolean) => any) | undefined;
     onReorder?: ((parentKey: string | null, field: string | null, list: BlockNode[]) => any) | undefined;
 }>, {
-    disabled: boolean;
     field: string | null;
+    disabled: boolean;
     depth: number;
     selected: string | null;
     parentKey: string | null;

package/dist/api.d.ts

@@ -1,14 +1,18 @@
 import { AdminContext } from '@webx-ui/module-admin';
-import { BlockInput, BlockType, BlockUsage, BlockVersion, BlockVersionMeta, RenderInput, RenderResult } from './types';
+import { BlockInput, BlockList, BlockType, BlockUsage, BlockVersion, BlockVersionMeta, RenderInput, RenderResult } from './types';
 export interface BlocksApi {
     /** Every type, without content: the section's list. */
     list(): Promise<BlockType[]>;
+    /** The same list with the places modules declared for components beside it. */
+    index(): Promise<BlockList>;
     /** The published types with their content: what the constructor and the picker read. */
     catalog(): Promise<BlockType[]>;
     get(id: number): Promise<BlockType>;
     create(input: BlockInput): Promise<BlockType>;
     update(id: number, input: BlockInput): Promise<BlockType>;
     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>;
     render(id: number, input?: RenderInput): Promise<RenderResult>;
     usage(id: number): Promise<BlockUsage[]>;

package/dist/completions.d.ts

@@ -14,8 +14,36 @@ export declare function completions(source: CompletionSource): Extension;
 export interface TemplateSources {
     schema: () => ScreenNode[];
     styles: () => string;
+    /** The types a tag can call, components among them: what `type="` offers. */
+    types?: () => TagTarget[];
+    /**
+     * The schema of a type, for the attributes and slots of a tag that calls it. May answer later:
+     * the list of types comes without content, and the one schema is asked for when it is needed.
+     */
+    schemaOf?: (slug: string) => ScreenNode[] | null | Promise<ScreenNode[] | null>;
 }
-export declare function templateCompletions({ schema, styles }: TemplateSources): CompletionSource;
+/** A type as a tag names it. */
+export interface TagTarget {
+    slug: string;
+    title: string;
+    kind: 'block' | 'component';
+    /** The module's view, for a declared place: the tag that calls it should carry it. */
+    fallback?: string | null;
+}
+export declare function templateCompletions({ schema, styles, types, schemaOf, }: TemplateSources): CompletionSource;
+interface OpenTag {
+    /** The attributes written so far. */
+    attributes: string;
+    /** The type, once it is written among them. */
+    type: string | null;
+    /** `:` typed before the name. */
+    bound: boolean;
+    word: string;
+}
+/** The caret stands between the attributes of an `<x-webx-block` that is still open. */
+export declare function openTag(before: string): OpenTag | null;
+/** The type of the `<x-webx-block>` whose body the end of the text stands in, if any. */
+export declare function enclosingType(text: string): string | null;
 export interface StylesSources {
     slug: () => string;
     template: () => string;

package/dist/index.d.ts

@@ -5,11 +5,11 @@ export { blocksPreviewKey, provideBlocksPreview, useBlocksPreview, type BlocksPr
 export { cloneNode, countType, insertNode, isNode, isNodeList, locate, makeNode, newKey, removeNode, replaceList, typesIn, updateValues, walk, type Located, } from './content';
 export { lintBlock, undeclared } from './lint';
 export { findRange, highlightBlock, replaceBlock, stageDocument } from './frame';
-export { formSchema } from './schema';
+export { callTag, formSchema, kindOf } from './schema';
 export { default as WxBlocks } from './BlocksField';
 export { default as WxBlocksPage } from './BlocksPage';
 export { default as WxBlockEditorPage } from './BlockEditorPage';
 export { default as WxBlockPicker } from './BlockPicker';
 export { default as WxBlockThumb } from './BlockThumb';
 export { default as WxBlockStage } from './BlockStage';
-export type { BlockContent, BlockInput, BlockNode, BlockSource, BlocksMeta, BlockThumbnail, BlockType, BlockUsage, BlockVersion, BlockVersionMeta, Lint, PublishRefusal, RenderInput, RenderResult, } from './types';
+export type { BlockContent, BlockInput, BlockKind, BlockList, BlockNode, BlockParent, BlockSource, BlocksMeta, BlockThumbnail, BlockType, BlockUsage, BlockVersion, BlockVersionMeta, DeclaredComponent, Lint, PublishRefusal, RenderInput, RenderResult, ShapeField, } from './types';