@dyrected/vue 2.5.51 → 2.5.53

package/dist/components/Blocks.d.ts

@@ -0,0 +1,57 @@
+import { PropType, Component } from 'vue';
+export interface BlocksItem {
+    /** Discriminator selecting which component renders this item. */
+    blockType: string;
+    /**
+     * Selected presentation variant, when the block defines `variants` in its
+     * schema. Passed straight through to the component so it can switch layout.
+     */
+    variant?: string;
+    /** Optional stable id; used as the render key when present. */
+    id?: string;
+    [key: string]: unknown;
+}
+/**
+ * Blocks — renders an array of block items by `blockType`, wrapping each in a
+ * `DyPathScope` scoped to `${path}.${index}` so child components can call
+ * `useDyPath('field')` without ever writing an index or full path.
+ *
+ * Render-function component (no template/JSX) so the package needs no extra
+ * build tooling.
+ *
+ * @example (render function usage in a page)
+ *   h(Blocks, { items: data.body, components: { hero: HeroBlock } })
+ * @example (template usage)
+ *   <Blocks :items="data.body" :components="{ hero: HeroBlock }" />
+ */
+export declare const Blocks: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    items: {
+        type: PropType<BlocksItem[]>;
+        required: true;
+    };
+    components: {
+        type: PropType<Record<string, Component>>;
+        required: true;
+    };
+    path: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => (import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    items: {
+        type: PropType<BlocksItem[]>;
+        required: true;
+    };
+    components: {
+        type: PropType<Record<string, Component>>;
+        required: true;
+    };
+    path: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    path: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/components/DyPathScope.d.ts

@@ -0,0 +1,25 @@
+/**
+ * DyPathScope — a minimal wrapper component whose sole job is to own one
+ * `provide()` scope for the ambient base path.
+ *
+ * In Vue, `provide()` is bound to the calling component *instance*, not to a
+ * render position, so a single component cannot provide a distinct value per
+ * item in a loop. `<Blocks>` renders one `DyPathScope` per item to give each
+ * block its own scoped base path.
+ *
+ * Written as a render-function component (no template/JSX) so the package needs
+ * no extra build tooling.
+ */
+export declare const DyPathScope: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    path: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    path: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/components/DyrectedIcon.vue.d.ts

@@ -0,0 +1,17 @@
+type __VLS_Props = {
+    /**
+     * The value of an `icon` field — a Lucide icon name such as
+     * `"ChartNoAxesCombined"` or `"BellRing"`. See https://lucide.dev/icons.
+     * Typed as `string` rather than the 1700+ icon-name union to avoid a TS
+     * "union too complex" (TS2590) blow-up in the generated declarations.
+     */
+    name?: string | null;
+    /**
+     * Icon name to render when `name` is missing or not a known icon.
+     * Renders nothing when omitted and `name` cannot be resolved.
+     */
+    fallback?: string;
+};
+declare const __VLS_export: 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>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/composables/useDyPath.d.ts

@@ -0,0 +1,30 @@
+import { InjectionKey } from 'vue';
+/**
+ * Injection key carrying the ambient base path for the block/section currently
+ * being rendered, e.g. "body.2". `provideDyPath` sets it; `useDyPath` reads it.
+ * Defaults to '' (document root).
+ */
+export declare const DY_PATH_KEY: InjectionKey<string>;
+/**
+ * provideDyPath — set the ambient base path for the current component's
+ * subtree. Must be called in `setup()`. `<Blocks>` calls this for you via
+ * `DyPathScope`; use it directly only for a standalone section.
+ */
+export declare function provideDyPath(path: string): void;
+/**
+ * useDyPath — returns an attribute object annotating an element with its
+ * document value path, so the Dyrected live-preview editor can map a click in
+ * the preview back to the exact field. Spread it onto the element (render
+ * functions) or bind with `v-bind` in templates.
+ *
+ * Must be called in `setup()`. Authors pass only the field name relative to the
+ * current block; the ancestor `<Blocks>`/`provideDyPath` supplies the base path.
+ *
+ * @example (render function)
+ *   h('h1', useDyPath('heading'), props.heading)
+ * @example (template)
+ *   <h1 v-bind="useDyPath('heading')">{{ heading }}</h1>
+ */
+export declare function useDyPath(field?: string): {
+    'data-dy-path': string;
+};