@mintjamsinc/ichigojs 0.1.80 → 0.1.82

package/dist/types/ichigo/VNode.d.ts

@@ -32,8 +32,17 @@ export declare class VNode {
      * Walking only {@link childVNodes} keeps the traversal inside this
      * application: the internals of an expanded component were never compiled
      * here, so they are not reachable and are left to their own application.
-     * A templatized node is skipped whole — it is a template source, and its
-     * clones expand when they are inserted.
+     * The one exception is content a directive rendered outside its own
+     * children — scoped slot content — reached through
+     * {@link VDirective.expandComponents}.
+     *
+     * Only connected elements are expanded. v-if / v-for call this right after
+     * inserting a clone, but when that clone sits inside another clone that is
+     * still detached (nested directives, or slot content rendered by an outlet
+     * inside a component's v-if), the insertion is not into the document yet;
+     * the outer inserter's walk reaches the same nodes once it is. A
+     * templatized node (a v-if / v-for source) is not expanded itself, but its
+     * rendered clones are its children and are walked.
      */
     expandComponents(): void;
     /**

package/dist/types/ichigo/components/IchigoElement.d.ts

@@ -36,9 +36,13 @@ export interface ScopedSlotEntry {
  *    microtask fires, so data() can read them. A component used without any prop
  *    binding still mounts — with its declared defaults — instead of waiting forever.
  *
- * Slot content is captured on the first connection and cached, so a component
- * that is moved in the DOM (e.g. reordered by v-for) re-expands its template
- * and redistributes the same slot nodes on reconnection.
+ * Slot content is captured on the first expansion and cached. The nodes are the
+ * parent application's compiled nodes and are only ever moved, never cloned:
+ * each `<slot>` outlet the component renders moves them into place
+ * (VStaticSlotOutletDirective; scoped `<template v-slot>` content is rendered
+ * per outlet by VSlotOutletDirective instead). A component that is moved in
+ * the DOM (e.g. reordered by v-for) re-expands its template, and its outlets
+ * move the same nodes into the fresh expansion.
  *
  * Subclasses must set the static fields _template, _props, _propOptions and
  * _buildOptions before calling customElements.define(). defineComponent()
@@ -76,6 +80,13 @@ export declare class IchigoElement extends HTMLElement {
      * VSlotOutletDirective when the component template renders a `<slot>`.
      */
     get _ichigoScopedSlots(): Map<string, ScopedSlotEntry> | undefined;
+    /**
+     * The static slot content captured for the given slot name ('default'
+     * for the unnamed slot): the parent application's nodes, moved into place
+     * by VStaticSlotOutletDirective. Undefined when nothing was provided for
+     * that name, in which case the outlet's fallback content renders.
+     */
+    _ichigoSlotNodes(name: string): Node[] | undefined;
     /**
      * Handles RE-attachment, and nothing else.
      *

package/dist/types/ichigo/directives/VDirective.d.ts

@@ -88,6 +88,14 @@ export interface VDirective {
      * The element reference is still available at this point.
      */
     get onUnmounted(): (() => void) | undefined;
+    /**
+     * Expands the components in a subtree this directive rendered but that is
+     * not reachable through the VNode's children — the scoped slot content of
+     * a `<slot>` outlet, whose VNodes belong to the parent application.
+     * Called by VNode.expandComponents() when it walks this directive's node.
+     * Optional; most directives render nothing outside their own VNode tree.
+     */
+    expandComponents?(): void;
     /**
      * Cleans up any resources used by the directive.
      * This method is called when the directive is no longer needed.

package/dist/types/ichigo/directives/VSlotOutletDirective.d.ts

@@ -26,9 +26,9 @@ import { VDOMUpdater } from "../VDOMUpdater";
  * ```
  *
  * This directive is created only when a scoped template for the slot's name
- * exists (see {@link VSlotOutletDirective.tryCreate}); otherwise `<slot>`
- * elements keep their existing behavior (static distribution at expansion,
- * or fallback content compiled in the component scope).
+ * exists (see {@link VSlotOutletDirective.tryCreate}); otherwise plain slot
+ * content is moved into place by VStaticSlotOutletDirective, and a `<slot>`
+ * with no content at all renders its fallback in the component scope.
  *
  * Rendering happens synchronously in onMount — before the component
  * application would compile the slot's fallback children — by replacing the
@@ -111,4 +111,8 @@ export declare class VSlotOutletDirective implements VDirective {
      * @inheritdoc
      */
     destroy(): void;
+    /**
+     * @inheritdoc
+     */
+    expandComponents(): void;
 }

package/dist/types/ichigo/directives/VStaticSlotOutletDirective.d.ts

@@ -0,0 +1,129 @@
+import type { VNode } from "../VNode";
+import { VBindingsPreparer } from "../VBindingsPreparer";
+import { VDirective } from "./VDirective";
+import { VDOMUpdater } from "../VDOMUpdater";
+/**
+ * Renders a static slot outlet: a `<slot>` element inside a component template
+ * whose host element received plain slot content from the parent — child
+ * nodes for the default slot, or elements carrying `slot="name"`:
+ *
+ * ```html
+ * <!-- component template -->
+ * <div v-if="open" class="body"><slot></slot></div>
+ *
+ * <!-- usage -->
+ * <my-dialog :open="show">
+ *   <my-field :label="title"></my-field>
+ * </my-dialog>
+ * ```
+ *
+ * The slot content is the parent application's own nodes, compiled in the
+ * parent scope; it keeps its bindings, listeners and component props only as
+ * long as those very nodes are displayed. So the outlet MOVES them into place
+ * and never clones them. That is what lets a `<slot>` sit behind a v-if or
+ * v-for in the component template: the directive clones its template source,
+ * the clone carries a fresh `<slot>`, and the outlet created for that clone
+ * moves the live nodes in.
+ *
+ * Nodes can only be in one place, so when the same slot is rendered more than
+ * once (e.g. a `<slot>` inside a v-for), the outlet rendered last receives the
+ * content and the earlier ones are left empty. When the outlet holding the
+ * content goes away while others remain (its row is removed), the content
+ * moves to the last remaining one. For content per row, use a scoped slot
+ * (`<template v-slot:name="scope">`), which renders a copy per outlet
+ * (VSlotOutletDirective).
+ *
+ * The component application never compiles the moved nodes: they are placed
+ * in onMount, after the parent VNode has taken its snapshot of the children
+ * to compile. Components inside them belong to the parent application, which
+ * expands them through {@link expandComponents} once they are in the document.
+ * When the last outlet goes away (its v-if turns false) the nodes leave with
+ * the removed clone and wait there until the next outlet moves them again;
+ * they are not destroyed, because they are not this application's to destroy.
+ *
+ * Created only when the host captured content for the slot's name and no
+ * scoped template claims it; otherwise the `<slot>` element renders its
+ * fallback children in the component scope.
+ */
+export declare class VStaticSlotOutletDirective implements VDirective {
+    #private;
+    /**
+     * Creates a static slot outlet for the given `<slot>` VNode when the host
+     * element captured content for its slot name. Returns undefined when there
+     * is none, so the `<slot>` element keeps rendering its fallback content.
+     */
+    static tryCreate(vNode: VNode): VStaticSlotOutletDirective | undefined;
+    private constructor();
+    /**
+     * @inheritdoc
+     */
+    get name(): string;
+    /**
+     * @inheritdoc
+     */
+    get vNode(): VNode;
+    /**
+     * @inheritdoc
+     */
+    get needsAnchor(): boolean;
+    /**
+     * @inheritdoc
+     */
+    get bindingsPreparer(): VBindingsPreparer | undefined;
+    /**
+     * @inheritdoc
+     */
+    get domUpdater(): VDOMUpdater | undefined;
+    /**
+     * @inheritdoc
+     */
+    get templatize(): boolean;
+    /**
+     * @inheritdoc
+     */
+    get dependentIdentifiers(): string[];
+    /**
+     * @inheritdoc
+     *
+     * Moves the slot content in place of the `<slot>` element — synchronously
+     * during VNode construction, before the component application would
+     * compile the slot's fallback children (which the content replaces).
+     */
+    get onMount(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onMounted(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onUpdate(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onUpdated(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onUnmount(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onUnmounted(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     *
+     * Expands the components in the slot content through the parent
+     * application's VNodes. Called by the walk of whoever inserted this
+     * outlet into the document (VApplication.mount, v-if, v-for), so the
+     * content is connected by now — unless a later outlet took it, in which
+     * case that outlet's walk expands it.
+     */
+    expandComponents(): void;
+    /**
+     * @inheritdoc
+     *
+     * The slot content is the parent application's; nothing to release here.
+     */
+    destroy(): void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mintjamsinc/ichigojs",
-  "version": "0.1.80",
+  "version": "0.1.82",
   "description": "ichigo.js - Simple and intuitive reactive framework. Lightweight, fast, and user-friendly virtual DOM library",
   "main": "./dist/ichigo.cjs",
   "module": "./dist/ichigo.esm.js",