@kaskad/component-tree 0.0.1 → 0.0.3

package/types/kaskad-component-tree.d.ts

@@ -0,0 +1,582 @@
+import { ComputationSchema, ValueType, ComponentId, NodePosition, BindingSchema, CommandValueType, ArrayValueType, MapValueType, SetValueType, ObjectValueType, ShapeValueType, VariantShapeValueType, RefSpaceId, ComponentRef, NodeSchema } from '@kaskad/types';
+import { IReactionDisposer } from 'mobx';
+
+declare class ComputationFrame {
+    readonly schema: ComputationSchema;
+    readonly disposers: IReactionDisposer[];
+    activated: boolean;
+    constructor(schema: ComputationSchema, disposers?: IReactionDisposer[], activated?: boolean);
+    /**
+     * Mark this computation frame as activated.
+     * This is an action that ensures MobX compliance.
+     */
+    markActivated(): void;
+    dispose(): void;
+}
+
+/**
+ * Manages a stack of computation frames for nested computations.
+ * For example: formula → formula → template chain.
+ */
+declare class ComputationStack {
+    /**
+     * Maximum allowed stack depth to prevent infinite recursion.
+     */
+    static readonly MAX_DEPTH = 10;
+    private readonly _frames;
+    constructor();
+    /**
+     * Get the topmost computation frame from the stack.
+     * Returns null if stack is empty.
+     */
+    get top(): ComputationFrame | null;
+    /**
+     * Returns true if all frames in the stack are activated.
+     * Empty stack returns true (vacuously).
+     */
+    get allActivated(): boolean;
+    /**
+     * Get the current stack depth.
+     */
+    get depth(): number;
+    /**
+     * Check if the stack is empty.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Push a new computation frame onto the stack.
+     * Throws if depth limit is exceeded.
+     */
+    push(schema: ComputationSchema): ComputationFrame;
+    /**
+     * Pop all frames from the given depth onward.
+     * For example, if depth=2, this removes frames at indices 2, 3, 4, etc.
+     * Useful when a computation at a specific depth re-evaluates and needs
+     * to clear its results without affecting parent computations.
+     */
+    popFrom(depth: number): void;
+    /**
+     * Dispose all frames in the stack.
+     */
+    dispose(): void;
+}
+
+type NodeType = AbstractNode<ValueType>;
+type NodeStructureMap = {
+    unknown: unknown;
+    boolean: boolean;
+    number: number;
+    string: string;
+    array: NodeType[];
+    map: Record<string, NodeType>;
+    set: Set<NodeType>;
+    object: Record<string, NodeType>;
+    shape: Record<string, NodeType>;
+    variantShape: {
+        kind: string;
+        fields: Record<string, NodeType>;
+    };
+    command: CommandNodeStructure;
+    component: string;
+    componentSchema: unknown;
+};
+type NodeExtractedValueMap = {
+    unknown: unknown;
+    boolean: boolean;
+    number: number;
+    string: string;
+    array: unknown[];
+    map: Record<string, unknown>;
+    set: Set<unknown>;
+    object: Record<string, unknown>;
+    shape: unknown;
+    variantShape: unknown;
+    command: unknown;
+    component: ComponentId;
+    componentSchema: unknown;
+};
+type CommandNodeViewModel = {
+    execute: (...args: unknown[]) => Promise<unknown>;
+    executing: boolean;
+    failed: boolean;
+};
+type NodeViewModelMap = NodeExtractedValueMap & {
+    command: CommandNodeViewModel;
+};
+type NodeStructure<T extends ValueType> = NodeStructureMap[T['type']];
+type NodeExtractedValue<T extends ValueType> = NodeExtractedValueMap[T['type']];
+type NodeViewModel<T extends ValueType> = NodeViewModelMap[T['type']];
+
+declare abstract class AbstractNode<T extends ValueType> {
+    readonly valueType: T;
+    position: NodePosition;
+    readonly nodeType: T['type'];
+    readonly computationStack: ComputationStack;
+    bindingSchema: BindingSchema | null;
+    extraBinding?: BindingSchema | null;
+    disposers: IReactionDisposer[];
+    protected selfEvaluating: boolean;
+    protected selfFailed: boolean;
+    protected selfActivated: boolean;
+    protected constructor(valueType: T, structure: NodeStructure<T> | null, position: NodePosition);
+    private _structure;
+    get structure(): NodeStructure<T> | null;
+    set structure(value: NodeStructure<T>);
+    abstract get extractedValue(): NodeExtractedValue<T> | null;
+    get evaluating(): boolean;
+    set evaluating(evaluating: boolean);
+    get failed(): boolean;
+    set failed(failed: boolean);
+    get fullyActivated(): boolean;
+    get computationActivated(): boolean;
+    get isSelfActivated(): boolean;
+    get viewModel(): NodeViewModel<T> | null;
+    protected abstract get childrenEvaluating(): boolean;
+    protected abstract get childrenFailed(): boolean;
+    protected abstract get childrenActivated(): boolean;
+    markActivated(): void;
+    dispose(): void;
+    /**
+     * Find a sub-node by following a path of segments.
+     * @param path Array of strings/numbers representing the path to traverse
+     * @returns The found node or null if not found/traversal not possible
+     */
+    abstract getNodeByPath(path: (string | number)[]): AbstractNode<ValueType> | null;
+    protected abstract disposeChildren(): void;
+}
+declare class LeafNode<T extends ValueType> extends AbstractNode<T> {
+    constructor(valueType: T, structure: NodeStructure<T> | null, position: NodePosition);
+    get extractedValue(): NodeExtractedValue<T> | null;
+    protected get childrenEvaluating(): boolean;
+    protected get childrenFailed(): boolean;
+    protected get childrenActivated(): boolean;
+    getNodeByPath(path: (string | number)[]): AbstractNode<ValueType> | null;
+    protected disposeChildren(): void;
+}
+declare class CommandNode extends LeafNode<CommandValueType> {
+    #private;
+    inFlight: number;
+    constructor(valueType: CommandValueType, structure: NodeStructure<CommandValueType> | null, position: NodePosition);
+    get executing(): boolean;
+    get viewModel(): NodeViewModel<CommandValueType>;
+}
+declare class ArrayNode extends AbstractNode<ArrayValueType> {
+    constructor(valueType: ArrayValueType, structure: NodeStructure<ArrayValueType> | null, position: NodePosition);
+    get extractedValue(): NodeExtractedValue<ArrayValueType> | null;
+    protected get childrenEvaluating(): boolean;
+    protected get childrenFailed(): boolean;
+    protected get childrenActivated(): boolean;
+    getNodeByPath(path: (string | number)[]): AbstractNode<ValueType> | null;
+    protected disposeChildren(): void;
+}
+declare abstract class AbstractObjectLikeNode<T extends ValueType> extends AbstractNode<T> {
+    protected constructor(valueType: T, structure: NodeStructure<T> | null, position: NodePosition);
+    protected get childrenEvaluating(): boolean;
+    protected get childrenFailed(): boolean;
+    protected get childrenActivated(): boolean;
+    getNodeByPath(path: (string | number)[]): AbstractNode<ValueType> | null;
+    protected abstract object(): Record<string, AbstractNode<ValueType>> | null;
+    protected disposeChildren(): void;
+    protected mapObjectExtracted(): Record<string, unknown> | null;
+}
+declare class MapNode extends AbstractObjectLikeNode<MapValueType> {
+    constructor(valueType: MapValueType, structure: NodeStructure<MapValueType> | null, position: NodePosition);
+    get extractedValue(): Record<string, unknown> | null;
+    protected object(): Record<string, AbstractNode<ValueType>> | null;
+}
+declare class SetNode extends AbstractNode<SetValueType> {
+    constructor(valueType: SetValueType, structure: NodeStructure<SetValueType> | null, position: NodePosition);
+    get extractedValue(): NodeExtractedValue<SetValueType> | null;
+    protected get childrenEvaluating(): boolean;
+    protected get childrenFailed(): boolean;
+    protected get childrenActivated(): boolean;
+    getNodeByPath(path: (string | number)[]): AbstractNode<ValueType> | null;
+    protected disposeChildren(): void;
+}
+declare class ObjectNode extends AbstractObjectLikeNode<ObjectValueType> {
+    constructor(valueType: ObjectValueType, structure: NodeStructure<ObjectValueType> | null, position: NodePosition);
+    get extractedValue(): Record<string, unknown> | null;
+    protected object(): Record<string, AbstractNode<ValueType>> | null;
+}
+declare class ShapeNode extends AbstractObjectLikeNode<ShapeValueType> {
+    constructor(valueType: ShapeValueType, structure: NodeStructure<ShapeValueType> | null, position: NodePosition);
+    get extractedValue(): Record<string, unknown> | null;
+    protected object(): Record<string, AbstractNode<ValueType>> | null;
+}
+declare class VariantShapeNode extends AbstractObjectLikeNode<VariantShapeValueType> {
+    constructor(valueType: VariantShapeValueType, structure: NodeStructure<VariantShapeValueType> | null, position: NodePosition);
+    get extractedValue(): {
+        [x: string]: unknown;
+    } | null;
+    protected object(): Record<string, AbstractNode<ValueType>> | null;
+}
+
+interface CommandNodeStructure {
+    runnerType: string;
+    owner: ComponentId;
+    target: string;
+    init?: string;
+    finalize?: string;
+}
+interface NodeChangeHandler {
+    readonly selector: string;
+    readonly command: CommandNode;
+}
+
+interface CommandRef<_TParams = unknown[], TResult = unknown> {
+    execute(...params: unknown[]): Promise<TResult>;
+}
+
+declare function isArrayNode(node: AbstractNode<ValueType>): node is ArrayNode;
+declare function isCommandNode(node: AbstractNode<ValueType>): node is CommandNode;
+
+type SelectorSegmentModifier = null | ':' | '^' | '&';
+interface SelectorSegment {
+    qualifier: string;
+    modifier: SelectorSegmentModifier;
+    conditions: string[][];
+    index?: number;
+}
+
+interface ComponentSelectorInfo {
+    /**
+     * Component selector segments (e.g., &ref, :Type, ^Parent with conditions).
+     */
+    selector: SelectorSegment[];
+    /**
+     * If true, uses ?-> instead of ->,
+     * meaning it should return null instead of throwing if the component is not found.
+     */
+    optional: boolean;
+}
+interface NodeSelector {
+    kind: 'property' | 'variable';
+    head: string;
+    tail: PathSegment[];
+    /**
+     * If present, the selector references another component.
+     */
+    component?: ComponentSelectorInfo;
+}
+interface PathSegment {
+    key: string | number;
+    optional: boolean;
+}
+
+interface ComponentCreateConfig {
+    id: ComponentId;
+    componentType: string;
+    position: NodePosition;
+    refSpaceId: RefSpaceId;
+    props: Map<string, AbstractNode<ValueType>>;
+    variables: Map<string, AbstractNode<ValueType>>;
+    onNodeChange: NodeChangeHandler[];
+    sourceUrl?: string;
+}
+declare class TComponent {
+    readonly id: ComponentId;
+    readonly position: NodePosition;
+    readonly refSpaceId: RefSpaceId;
+    sourceUrl: string | null;
+    componentType: string;
+    props: Map<string, AbstractNode<ValueType>>;
+    variables: Map<string, AbstractNode<ValueType>>;
+    onNodeChange: NodeChangeHandler[];
+    handlerDisposers: IReactionDisposer[];
+    constructor(config: ComponentCreateConfig);
+    setVariable(variableName: string, node: AbstractNode<ValueType>): void;
+    /**
+     * Find a node by selector. Returns null if the node is not found.
+     * This is an alias for getNode for consistency with ComponentStore's API.
+     */
+    findNode(nodeSelector: string): AbstractNode<ValueType> | null;
+    /**
+     * Get a node by selector. Throws an error if the node is not found.
+     * Use findNode() for optional lookups that return null instead of throwing.
+     *
+     * Note: Even if the selector contains optional chaining (?.), this method will throw
+     * if the node is not found. Use findNode() for optional chaining support.
+     */
+    getNode(nodeSelector: string): AbstractNode<ValueType>;
+    findNodeFromParsed(parsed: Omit<NodeSelector, 'componentSelector'>): AbstractNode<ValueType> | null;
+    getNodeFromParsed(parsed: Omit<NodeSelector, 'componentSelector'>): AbstractNode<ValueType>;
+    getNodeValue<T>(nodeSelector: string): T | null;
+    dispose(): void;
+}
+
+declare class RefSpace {
+    id: RefSpaceId;
+    parentRefSpaceId: RefSpaceId | null;
+    private readonly byRef;
+    constructor(id: RefSpaceId, parentRefSpaceId?: RefSpaceId | null);
+    get refs(): Map<string, string>;
+    addRefs(refs: Record<ComponentRef, ComponentId>): void;
+    getComponentIdByRef(ref: string): ComponentId | null;
+}
+
+declare class ComponentStore {
+    private static instance;
+    components: Map<ComponentId, TComponent>;
+    refSpaces: Map<RefSpaceId, RefSpace>;
+    componentsToPreload: Set<string>;
+    private componentsByRefSpace;
+    static getInstance(): ComponentStore;
+    static reset(): ComponentStore;
+    addRefSpace(refSpace: RefSpace): void;
+    addComponents(components: Record<ComponentId, TComponent>): void;
+    getRefSpace(refSpaceId: RefSpaceId): RefSpace | null;
+    getRefSpaceOrThrow(refSpaceId: RefSpaceId): RefSpace;
+    getComponent(componentId: string): TComponent | null;
+    getComponentOrThrow(componentId: string): TComponent;
+    findVariable(componentId: ComponentId, variableName: string): AbstractNode<ValueType> | null;
+    /**
+     * Find a single component using a selector relative to another component.
+     * Throws if multiple components match the selector.
+     *
+     * @param relativeTo - The component ID to search relative to
+     * @param selector - Component selector string (e.g., 'Button', '&myRef', '^parent', ':button', 'Button[disabled=true]')
+     * @returns The matching component or null if not found
+     * @throws If the selector matches multiple components
+     *
+     * @example
+     * ```typescript
+     * const button = store.findComponent(componentId, 'Button');
+     * const aliased = store.findComponent(componentId, '&myRef');
+     * const parent = store.findComponent(componentId, '^parent');
+     * const byType = store.findComponent(componentId, ':button');
+     * const filtered = store.findComponent(componentId, 'Button[disabled=true]');
+     * ```
+     */
+    findComponent(relativeTo: ComponentId, selector: string): TComponent | null;
+    /**
+     * Find all components matching a selector relative to another component.
+     *
+     * @param relativeTo - The component ID to search relative to
+     * @param selector - Component selector string (e.g., 'Button', '&myRef', ':button', 'Button[disabled=true]')
+     * @returns Array of matching components (empty if none found)
+     *
+     * @example
+     * ```typescript
+     * const buttons = store.findComponents(componentId, 'Button');
+     * const allOfType = store.findComponents(componentId, ':button');
+     * const filtered = store.findComponents(componentId, 'Button[disabled=true]');
+     * ```
+     */
+    findComponents(relativeTo: ComponentId, selector: string): TComponent[];
+    /**
+     * Get a node by selector relative to a component.
+     * Throws an error if the component or node is not found.
+     * Use findNode() for optional lookups that return null instead of throwing.
+     *
+     * Note: Even if the selector contains optional chaining (?.), this method will throw
+     * if the node is not found. Use findNode() for optional chaining support.
+     *
+     * Component selector behavior:
+     * - `&ref->value` - Throws if component with ref doesn't exist
+     * - `&ref?->value` - Throws if node not found, but allows missing component (returns null for the whole expression)
+     *
+     * @param relativeTo - The component ID to search relative to
+     * @param selector - Node selector string (e.g., 'prop', '$variable', '^Parent->prop', '&ref?->value')
+     * @returns The node
+     * @throws If the component or node is not found (unless using ?-> for component)
+     *
+     * @example
+     * ```typescript
+     * const node = store.getNode(componentId, 'requiredProp'); // throws if not found
+     * const optionalNode = store.findNode(componentId, 'user?.profile'); // returns null if not found
+     * const optionalComponent = store.getNode(componentId, '&optional?->value'); // throws only if value missing, not if component missing
+     * ```
+     */
+    getNode<T extends AbstractNode<ValueType>>(relativeTo: ComponentId, selector: string): T;
+    /**
+     * Find a node by selector relative to a component.
+     * Returns null if the node is not found.
+     *
+     * Component selector behavior:
+     * - `&ref->value` - Throws if component doesn't exist (strict by default)
+     * - `&ref?->value` - Returns null if component doesn't exist (lenient when explicit)
+     *
+     * Use `?->` to explicitly indicate that a missing component is acceptable.
+     * This makes the code self-documenting and prevents accidental null returns.
+     *
+     * @param relativeTo - The component ID to search relative to
+     * @param selector - Node selector string (e.g., 'prop', '$variable', '^Parent->prop', '&ref?->value')
+     * @returns The node or null if not found
+     *
+     * @example
+     * ```typescript
+     * // Strict - throws if component missing
+     * const node = store.findNode(componentId, '&ref->value');
+     *
+     * // Lenient - returns null if component missing
+     * const optionalNode = store.findNode(componentId, '&ref?->value');
+     * if (optionalNode) {
+     *   // Use the node
+     * }
+     * ```
+     */
+    findNode<T extends AbstractNode<ValueType>>(relativeTo: ComponentId, selector: string): T | null;
+    /**
+     * Collect node values from multiple components into an array.
+     * Maps over all components matching the selector and extracts a node value from each.
+     *
+     * @param relativeTo - The component ID to search relative to
+     * @param componentSelector - Selector for finding components (e.g., ':forms.Input', 'Button')
+     * @param nodeSelector - The node path to extract from each component (e.g., 'value', 'inputKey')
+     * @returns Array of node values from matched components
+     *
+     * @example
+     * ```typescript
+     * // Get all input values
+     * const values = store.collectValuesArray(componentId, ':forms.Input', 'value');
+     * // Returns: ['value1', 'value2', 'value3']
+     * ```
+     */
+    collectValuesArray<T = unknown[]>(relativeTo: ComponentId, componentSelector: string, nodeSelector: string): T;
+    /**
+     * Collect node values from multiple components into a map/object.
+     * Reduces over all components matching the selector, using one node as the key and another as the value.
+     *
+     * @param relativeTo - The component ID to search relative to
+     * @param componentSelector - Selector for finding components (e.g., ':forms.Input', 'Button')
+     * @param keyNodeSelector - The node path to use as the object key (e.g., 'inputKey', 'id')
+     * @param valueNodeSelector - The node path to use as the object value (e.g., 'value', 'label')
+     * @returns Object/map with keys and values from matched components
+     *
+     * @example
+     * ```typescript
+     * // Create a map from inputKey to value
+     * const map = store.collectValuesMap(componentId, ':forms.Input', 'inputKey', 'value');
+     * // Returns: { key1: 'value1', key2: 'value2' }
+     * ```
+     */
+    collectValuesMap<T = Record<string, unknown>>(relativeTo: ComponentId, componentSelector: string, keyNodeSelector: string, valueNodeSelector: string): T;
+    /**
+     * Set a node from a raw schema value.
+     * The raw schema will be unfolded before being applied.
+     * Handles structure, computation stack, and nested components.
+     *
+     * @param node - The node to update
+     * @param rawSchema - The raw schema value (will be unfolded into a NodeSchema)
+     */
+    setNodeRawSchema(node: AbstractNode<ValueType>, rawSchema: unknown): void;
+    /**
+     * Set a node from an already-unfolded schema.
+     * Use this when you already have a NodeSchema to avoid double-unfolding.
+     * Handles structure, nested components, and computation stack.
+     *
+     * @param node - The node to update
+     * @param schema - The unfolded NodeSchema to set
+     */
+    setNodeSchema(node: AbstractNode<ValueType>, schema: NodeSchema): void;
+    /**
+     * Remove an item from an array node.
+     * Handles cleanup of nested components in the removed item.
+     *
+     * @param arrayNode - The array node to remove from
+     * @param index - The index of the item to remove
+     */
+    removeArrayItem(arrayNode: ArrayNode, index: number): void;
+    /**
+     * Insert an item into an array node at a specific index.
+     * Creates a node structure from the raw value and inserts it at the specified position.
+     * Shifts existing items to the right.
+     *
+     * @param arrayNode - The array node to insert into
+     * @param index - The index at which to insert the item
+     * @param value - The raw value to insert (will be transformed into a node structure)
+     */
+    insertArrayItem(arrayNode: ArrayNode, index: number, value: unknown): void;
+    /**
+     * Replace an item in an array node at a specific index.
+     * Creates a node structure from the raw value and replaces the item at the specified position.
+     * Properly cleans up nested components in the replaced item.
+     *
+     * @param arrayNode - The array node containing the item to replace
+     * @param index - The index of the item to replace
+     * @param value - The raw value to set (will be transformed into a node structure)
+     */
+    replaceArrayItem(arrayNode: ArrayNode, index: number, value: unknown): void;
+    /**
+     * Append an item to the end of an array node.
+     * Creates a node structure from the raw value and appends it to the array.
+     *
+     * @param arrayNode - The array node to append to
+     * @param value - The raw value to append (will be transformed into a node structure)
+     */
+    appendArrayItem(arrayNode: ArrayNode, value: unknown): void;
+    /**
+     * Reconcile for-loop children using key-based diffing.
+     * Instead of destroying all children and recreating them,
+     * this method compares old vs new keys and only creates/destroys what's necessary.
+     *
+     * @param arrayNode - The array node containing for-loop children
+     * @param newSchemas - The new schemas to reconcile
+     * @returns Indices of newly added items for activation
+     */
+    reconcileForLoopChildren(arrayNode: ArrayNode, newSchemas: unknown[]): number[];
+    /**
+     * Apply for-loop reconciliation by building new structure and cleaning up removed components.
+     */
+    private applyForLoopReconciliation;
+    /**
+     * Update loop variables (including item variable) on components that have been repositioned or whose data changed.
+     */
+    private updateLoopVariables;
+    /**
+     * Check if schemas have explicit trackBy keys that can be used for diffing.
+     */
+    private checkForExplicitKeys;
+    /**
+     * Extract keys from existing children (RefSpace components with $trackBy variable)
+     */
+    private extractOldKeys;
+    /**
+     * Extract keys from new schemas (generated by repeat())
+     */
+    private extractNewKeys;
+    /**
+     * Find duplicate keys in an array
+     */
+    private findDuplicateKeys;
+    removeComponent(componentId: ComponentId): void;
+    /**
+     * Creates a new node for an array item from a raw value.
+     * Returns the created node and the options used (for registering components/refs).
+     * @throws If the array node has no parent component
+     */
+    private createArrayItemNode;
+    private collectRefSpacesToRemove;
+}
+
+declare function createRootNode(refSpaceId: RefSpaceId, schema: NodeSchema, ownerComponentId: ComponentId | null, parentRefSpaceId: RefSpaceId | null, sourceUrl?: string): AbstractNode<ValueType>;
+
+declare function getComponent(node: AbstractNode<ValueType>): TComponent;
+
+declare function formatSource(sourceUrl: string | null | undefined, path?: (string | number)[]): string;
+
+declare const componentTreeConfig: {
+    runCommand: (_node: CommandNode, ..._args: unknown[]) => Promise<unknown>;
+};
+
+declare class ComponentTreeApi {
+    private static store;
+    static findComponent(relativeTo: ComponentId, componentSelector: string): TComponent | null;
+    static findComponentsIds(relativeTo: ComponentId, componentSelector: string): ComponentId[];
+    static findComponents(relativeTo: ComponentId, componentSelector: string): TComponent[];
+    static getComponent(relativeTo: ComponentId, componentSelector: string): TComponent;
+    static findNode(relativeTo: ComponentId, componentSelector: string): AbstractNode<ValueType> | null;
+    static getNode(relativeTo: ComponentId, componentSelector: string): AbstractNode<ValueType>;
+    static collectValuesArray<T>(componentId: ComponentId, componentSelector: string, nodeSelector: string): T;
+    static collectValuesMap<T>(componentId: ComponentId, componentSelector: string, keyNodeSelector: string, valueNodeSelector: string): T;
+    static isCommandRunning(componentId: ComponentId, selector: string): boolean;
+    static runCommandNode(componentId: ComponentId, selector: string, ...args: unknown[]): unknown;
+    static setNodeRawSchema(componentId: ComponentId, selector: string, value: unknown): void;
+    static appendArrayItem(componentId: ComponentId, selector: string, item: unknown): void;
+    static insertArrayItem(componentId: ComponentId, selector: string, index: number, item: unknown): void;
+    static removeArrayItem(componentId: ComponentId, selector: string, index: number): void;
+    static replaceArrayItem(componentId: ComponentId, selector: string, index: number, item: unknown): void;
+}
+
+export { AbstractNode, AbstractObjectLikeNode, ArrayNode, CommandNode, ComponentStore, ComponentTreeApi, ComputationFrame, ComputationStack, LeafNode, MapNode, ObjectNode, RefSpace, SetNode, ShapeNode, TComponent, VariantShapeNode, componentTreeConfig, createRootNode, formatSource, getComponent, isArrayNode, isCommandNode };
+export type { CommandNodeStructure, CommandNodeViewModel, CommandRef, ComponentCreateConfig, NodeChangeHandler, NodeExtractedValue, NodeExtractedValueMap, NodeStructure, NodeStructureMap, NodeViewModel, NodeViewModelMap };

package/esm2022/index.js

@@ -1,12 +0,0 @@
-export * from './lib/types';
-export * from './lib/node/node';
-export * from './lib/node/node-type';
-export * from './lib/mobx/component';
-export * from './lib/mobx/ref-space';
-export * from './lib/mobx/store';
-export * from './lib/mobx/create-root-node';
-export * from './lib/util/get-component';
-export * from './lib/util/format-source';
-export * from './lib/config';
-export * from './lib/component-tree-api';
-//# sourceMappingURL=index.js.map

package/esm2022/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/component-tree/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,cAAc,CAAC;AAC7B,cAAc,0BAA0B,CAAC","sourcesContent":["export * from './lib/types';\nexport * from './lib/node/node';\nexport * from './lib/node/node-type';\nexport * from './lib/mobx/component';\nexport * from './lib/mobx/ref-space';\nexport * from './lib/mobx/store';\nexport * from './lib/mobx/create-root-node';\nexport * from './lib/util/get-component';\nexport * from './lib/util/format-source';\nexport * from './lib/config';\nexport * from './lib/component-tree-api';\n"]}

package/esm2022/kaskad-component-tree.js

@@ -1,5 +0,0 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './index';
-//# sourceMappingURL=kaskad-component-tree.js.map

package/esm2022/kaskad-component-tree.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"kaskad-component-tree.js","sourceRoot":"","sources":["../../../../libs/component-tree/src/kaskad-component-tree.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,SAAS,CAAC","sourcesContent":["/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"]}

package/esm2022/lib/component-lookup/index.js

@@ -1,68 +0,0 @@
-import { ComponentStore } from '../mobx/store';
-import { parseComponentSelector } from '../parsers';
-import { traversesRegistry } from './traverses';
-export { parseComponentSelector };
-export function findComponent(relativeTo, selector) {
-    const ids = findComponentsIds(relativeTo, selector);
-    if (!ids.length) {
-        return null;
-    }
-    if (ids.length > 1) {
-        throw new Error(`Selector matched ${ids.length} components (expected 1): ${ids.join(', ')}`);
-    }
-    return ComponentStore.getInstance().getComponentOrThrow(ids[0]);
-}
-export function findComponents(relativeTo, selector) {
-    const ids = findComponentsIds(relativeTo, selector);
-    return ids.map((componentId) => ComponentStore.getInstance().getComponentOrThrow(componentId));
-}
-export function findComponentsIds(relativeTo, selector) {
-    const selectors = [selector];
-    const foundComponents = [];
-    for (const parsedSelector of selectors) {
-        if (parsedSelector.length === 0) {
-            foundComponents.push(relativeTo);
-            continue;
-        }
-        const startFrom = {
-            currentNode: {
-                valueType: { type: 'component' },
-                value: relativeTo,
-            },
-            selectorSegments: parsedSelector,
-            relativeTo,
-        };
-        const nodeQueue = [startFrom];
-        while (nodeQueue.length > 0) {
-            const ctx = nodeQueue.shift();
-            if (!ctx)
-                break;
-            const traverser = traversesRegistry.get(ctx.currentNode.valueType.type);
-            traverser(ctx, nodeQueue, foundComponents);
-        }
-    }
-    const uniqueComponents = Array.from(new Set(foundComponents));
-    // Apply :nth(N) filtering if the last segment has an index
-    const lastSegment = selector[selector.length - 1];
-    if (lastSegment && lastSegment.index !== undefined) {
-        const index = lastSegment.index;
-        const actualIndex = index < 0 ? uniqueComponents.length + index : index;
-        if (actualIndex < 0 || actualIndex >= uniqueComponents.length) {
-            const selectorStr = selector.map(formatSelectorSegment).join(' ');
-            throw new Error(`Index ${index} out of bounds for selector "${selectorStr}" (found ${uniqueComponents.length} elements)`);
-        }
-        return [uniqueComponents[actualIndex]];
-    }
-    return uniqueComponents;
-}
-function formatSelectorSegment(segment) {
-    let result = segment.modifier ? segment.modifier + segment.qualifier : segment.qualifier;
-    if (segment.conditions.length > 0) {
-        result += segment.conditions.map(([key, value]) => `[${key}=${value}]`).join('');
-    }
-    if (segment.index !== undefined) {
-        result += `:nth(${segment.index})`;
-    }
-    return result;
-}
-//# sourceMappingURL=index.js.map