@kaskad/component-tree 0.0.1 → 0.0.2

package/lib/computation/computation-stack.d.ts

@@ -1,48 +0,0 @@
-import { ComputationSchema } from '@kaskad/types';
-import { ComputationFrame } from './computation-frame';
-/**
- * Manages a stack of computation frames for nested computations.
- * For example: formula → formula → template chain.
- */
-export 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;
-}

package/lib/computation/index.d.ts

@@ -1,2 +0,0 @@
-export * from './computation-frame';
-export * from './computation-stack';

package/lib/config.d.ts

@@ -1,4 +0,0 @@
-import { CommandNode } from './node/node';
-export declare const componentTreeConfig: {
-    runCommand: (_node: CommandNode, ..._args: unknown[]) => Promise<unknown>;
-};

package/lib/mobx/component.d.ts

@@ -1,45 +0,0 @@
-import { ComponentId, NodePosition, RefSpaceId, ValueType } from '@kaskad/types';
-import { IReactionDisposer } from 'mobx';
-import { AbstractNode } from '../node/node';
-import { NodeSelector } from '../parsers';
-import { NodeChangeHandler } from '../types';
-export interface ComponentCreateConfig {
-    id: ComponentId;
-    componentType: string;
-    position: NodePosition;
-    refSpaceId: RefSpaceId;
-    props: Map<string, AbstractNode<ValueType>>;
-    variables: Map<string, AbstractNode<ValueType>>;
-    onNodeChange: NodeChangeHandler[];
-    sourceUrl?: string;
-}
-export 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;
-}

package/lib/mobx/create-root-node.d.ts

@@ -1,3 +0,0 @@
-import { ComponentId, NodeSchema, RefSpaceId, ValueType } from '@kaskad/types';
-import { AbstractNode } from '../node/node';
-export declare function createRootNode(refSpaceId: RefSpaceId, schema: NodeSchema, ownerComponentId: ComponentId | null, parentRefSpaceId: RefSpaceId | null, sourceUrl?: string): AbstractNode<ValueType>;

package/lib/mobx/ref-space.d.ts

@@ -1,10 +0,0 @@
-import { ComponentId, ComponentRef, RefSpaceId } from '@kaskad/types';
-export 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;
-}

package/lib/mobx/store.d.ts

@@ -1,238 +0,0 @@
-import { ComponentId, NodeSchema, RefSpaceId, ValueType } from '@kaskad/types';
-import { AbstractNode, ArrayNode } from '../node/node';
-import { TComponent } from './component';
-import { RefSpace } from './ref-space';
-export 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;
-}

package/lib/node/create-node-options.d.ts

@@ -1,12 +0,0 @@
-import { ComponentId, ComponentRef, NodePath, NodePosition, RefSpaceId } from '@kaskad/types';
-import { TComponent } from '../mobx/component';
-export interface CreateNodeOptions {
-    readonly refSpaceId: RefSpaceId;
-    readonly position: NodePosition;
-    readonly components: Record<ComponentId, TComponent>;
-    readonly refs: Record<RefSpaceId, Record<ComponentRef, ComponentId>>;
-    readonly sourceUrl?: string;
-}
-export declare function withPath(opts: CreateNodeOptions, newPath: NodePath): CreateNodeOptions;
-export declare function withPosition(opts: CreateNodeOptions, componentId: ComponentId | null, path: NodePath): CreateNodeOptions;
-export declare function appendPath(opts: CreateNodeOptions, ...segments: (string | number)[]): CreateNodeOptions;

package/lib/node/creators/array-creator.d.ts

@@ -1,4 +0,0 @@
-import { ArrayNodeSchema } from '@kaskad/types';
-import { CreateNodeOptions } from '../create-node-options';
-import { ArrayNode } from '../node';
-export declare function createArrayNode(schema: ArrayNodeSchema, opts: CreateNodeOptions): ArrayNode;

package/lib/node/creators/command-creator.d.ts

@@ -1,4 +0,0 @@
-import { CommandNodeSchema } from '@kaskad/types';
-import { CreateNodeOptions } from '../create-node-options';
-import { CommandNode } from '../node';
-export declare function createCommandNode(schema: CommandNodeSchema, opts: CreateNodeOptions): CommandNode;

package/lib/node/creators/component-creator.d.ts

@@ -1,4 +0,0 @@
-import { ComponentNodeSchema, ComponentValueType } from '@kaskad/types';
-import { CreateNodeOptions } from '../create-node-options';
-import { LeafNode } from '../node';
-export declare function createComponentNode(schema: ComponentNodeSchema, opts: CreateNodeOptions): LeafNode<ComponentValueType>;

package/lib/node/creators/leaf-creator.d.ts

@@ -1,4 +0,0 @@
-import { LeafNodeSchema, ValueType } from '@kaskad/types';
-import { CreateNodeOptions } from '../create-node-options';
-import { AbstractNode } from '../node';
-export declare function createLeafNode(schema: LeafNodeSchema, opts: CreateNodeOptions): AbstractNode<ValueType>;

package/lib/node/creators/map-creator.d.ts

@@ -1,4 +0,0 @@
-import { MapNodeSchema } from '@kaskad/types';
-import { CreateNodeOptions } from '../create-node-options';
-import { MapNode } from '../node';
-export declare function createMapNode(schema: MapNodeSchema, opts: CreateNodeOptions): MapNode;

package/lib/node/creators/object-creator.d.ts

@@ -1,4 +0,0 @@
-import { ObjectNodeSchema } from '@kaskad/types';
-import { CreateNodeOptions } from '../create-node-options';
-import { ObjectNode } from '../node';
-export declare function createObjectNode(schema: ObjectNodeSchema, opts: CreateNodeOptions): ObjectNode;

package/lib/node/creators/set-creator.d.ts

@@ -1,4 +0,0 @@
-import { SetNodeSchema } from '@kaskad/types';
-import { CreateNodeOptions } from '../create-node-options';
-import { SetNode } from '../node';
-export declare function createSetNode(schema: SetNodeSchema, opts: CreateNodeOptions): SetNode;

package/lib/node/creators/shape-creator.d.ts

@@ -1,4 +0,0 @@
-import { ShapeNodeSchema } from '@kaskad/types';
-import { CreateNodeOptions } from '../create-node-options';
-import { ShapeNode } from '../node';
-export declare function createShapeNode(schema: ShapeNodeSchema, opts: CreateNodeOptions): ShapeNode;

package/lib/node/creators/variant-shape-creator.d.ts

@@ -1,4 +0,0 @@
-import { VariantShapeNodeSchema } from '@kaskad/types';
-import { CreateNodeOptions } from '../create-node-options';
-import { VariantShapeNode } from '../node';
-export declare function createVariantShapeNode(schema: VariantShapeNodeSchema, opts: CreateNodeOptions): VariantShapeNode;

package/lib/node/guards.d.ts

@@ -1,3 +0,0 @@
-import { ValueType } from '@kaskad/types';
-import { AbstractNode } from './node';
-export declare function isNode(value: unknown): value is AbstractNode<ValueType>;

package/lib/node/node-creation.d.ts

@@ -1,4 +0,0 @@
-import { NodeSchema, ValueType } from '@kaskad/types';
-import { CreateNodeOptions } from './create-node-options';
-import { AbstractNode } from './node';
-export declare function createNode<T extends AbstractNode<ValueType> = AbstractNode<ValueType>>(unfolded: NodeSchema, opts: CreateNodeOptions): T;

package/lib/node/node-type.d.ts

@@ -1,49 +0,0 @@
-import { ComponentId, ValueType } from '@kaskad/types';
-import { CommandNodeStructure } from '../types';
-import { AbstractNode } from './node';
-type NodeType = AbstractNode<ValueType>;
-export 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;
-};
-export 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;
-};
-export type CommandNodeViewModel = {
-    execute: (...args: unknown[]) => Promise<unknown>;
-    executing: boolean;
-    failed: boolean;
-};
-export type NodeViewModelMap = NodeExtractedValueMap & {
-    command: CommandNodeViewModel;
-};
-export type NodeStructure<T extends ValueType> = NodeStructureMap[T['type']];
-export type NodeExtractedValue<T extends ValueType> = NodeExtractedValueMap[T['type']];
-export type NodeViewModel<T extends ValueType> = NodeViewModelMap[T['type']];
-export {};

package/lib/node/node.d.ts

@@ -1,107 +0,0 @@
-import { ArrayValueType, BindingSchema, CommandValueType, MapValueType, NodePosition, ObjectValueType, SetValueType, ShapeValueType, ValueType, VariantShapeValueType } from '@kaskad/types';
-import { IReactionDisposer } from 'mobx';
-import { ComputationStack } from '../computation';
-import { NodeExtractedValue, NodeStructure, NodeViewModel } from './node-type';
-export 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;
-}
-export 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;
-}
-export 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>;
-}
-export 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;
-}
-export 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;
-}
-export 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;
-}
-export 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;
-}
-export 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;
-}
-export 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;
-}
-export 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;
-}

package/lib/parsers/index.d.ts

@@ -1,5 +0,0 @@
-export { parseNodeSelector } from './parse-node-selector';
-export type { PathPart, PathArray } from './parse-node-selector';
-export type { NodeSelector, PathSegment } from './node-selector.types';
-export { parseComponentSelector } from './parse-component-selector';
-export type { SelectorSegment, SelectorSegmentModifier } from './parse-component-selector';

package/lib/parsers/node-selector.types.d.ts

@@ -1,25 +0,0 @@
-import { SelectorSegment } from './parse-component-selector';
-export 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;
-}
-export interface NodeSelector {
-    kind: 'property' | 'variable';
-    head: string;
-    tail: PathSegment[];
-    /**
-     * If present, the selector references another component.
-     */
-    component?: ComponentSelectorInfo;
-}
-export interface PathSegment {
-    key: string | number;
-    optional: boolean;
-}

package/lib/parsers/parse-component-selector.d.ts

@@ -1,8 +0,0 @@
-export type SelectorSegmentModifier = null | ':' | '^' | '&';
-export interface SelectorSegment {
-    qualifier: string;
-    modifier: SelectorSegmentModifier;
-    conditions: string[][];
-    index?: number;
-}
-export declare function parseComponentSelector(selector: string): SelectorSegment[];