@webx-ui/module-blocks 0.7.1 → 0.8.1

package/dist/BlocksTree.d.ts

@@ -32,8 +32,8 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
 }>, {
     disabled: boolean;
     field: string | null;
+    depth: number;
     selected: string | null;
     parentKey: string | null;
-    depth: number;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/completions.d.ts

@@ -0,0 +1,58 @@
+import { CompletionSource } from '@codemirror/autocomplete';
+import { Extension } from '@codemirror/state';
+import { ScreenNode, TypeRegistry } from '@webx-ui/schema';
+/**
+ * What the editor of a block type offers as you type, one source per file. Each reads the
+ * other files of the same type — the template's fields come from the schema, its classes from
+ * the styles, the styles' classes from the template — so the sources take getters, not
+ * values: the editor is built once and the files change under it.
+ *
+ * Registered as language data rather than as an `override`, so that what the language
+ * already offers (CSS properties, HTML tags) stays in the list beside ours.
+ */
+export declare function completions(source: CompletionSource): Extension;
+export interface TemplateSources {
+    schema: () => ScreenNode[];
+    styles: () => string;
+}
+export declare function templateCompletions({ schema, styles }: TemplateSources): CompletionSource;
+export interface StylesSources {
+    slug: () => string;
+    template: () => string;
+}
+export declare function stylesCompletions({ slug, template }: StylesSources): CompletionSource;
+/** Classes a stylesheet declares, nested `&__part` resolved against its parent. */
+export declare function styleClasses(styles: string): string[];
+/** Classes the template writes literally; anything Blade computes is left out. */
+export declare function templateClasses(template: string): string[];
+export interface SchemaSources {
+    types: () => TypeRegistry;
+}
+export declare function schemaCompletions({ types }: SchemaSources): CompletionSource;
+interface Frame {
+    kind: 'object' | 'array';
+    parent: Frame | null;
+    /** For an array: the key it is the value of. */
+    under: string | null;
+    keys: Set<string>;
+    phase: 'key' | 'colon' | 'value' | 'after';
+    key: string | null;
+}
+export interface JsonContext {
+    /** The caret stands in an object that is a screen node. */
+    node: boolean;
+    phase: Frame['phase'];
+    /** The key whose value is being written. */
+    key: string | null;
+    /** Every key the object has, before the caret and after it. */
+    keys: Set<string>;
+    /** Where the string under the caret starts, after its opening quote. */
+    string: number | null;
+}
+/**
+ * Where the caret stands in a schema, by one pass over the text — it has to work on a
+ * document that is broken right there, which is always the case while typing, and a parser
+ * gives up on exactly that.
+ */
+export declare function jsonContext(doc: string, pos: number): JsonContext | null;
+export {};

package/dist/frame.d.ts

@@ -44,10 +44,13 @@ export interface FrameBinding {
 /**
  * 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.
+ * A click inside a block is taken at the document, in the capture phase, and goes no further:
+ * stopped there it never reaches a link, a form or the block's own script. What it does
+ * instead is choose the block it landed in, which is the one thing the editor wants from it.
+ *
+ * A click on the site around the blocks goes on to the site, only never anywhere else (see
+ * `inert`): the layout may open a newsletter popup or a cookie bar over the page, and one whose
+ * close button never hears its click covers the preview for good.
  *
  * Bound per document: an iframe that reloads gets a new one, and the old binding is released
  * with it.
@@ -59,6 +62,9 @@ export declare function bindFrame(doc: Document, handlers: {
  * The same picture without the choosing: nothing in the page navigates, submits or is dragged
  * away. What the block editor's stage needs — the site's header is full of links, and one
  * click on them would leave the frame on another page of the site with the block gone.
+ *
+ * Clicks themselves still reach the page (see `inert`): the block's own script runs as it will
+ * on the site, and the site's popups close.
  */
 export declare function freezeFrame(doc: Document): FrameBinding;
 /** The key the stage draws its block under — `StageController::KEY` on the server. */