@kaskad/component-tree 0.0.1 → 0.0.3

package/esm2022/lib/parsers/parse-node-selector.js

@@ -1,263 +0,0 @@
-import { Delimiters } from '@kaskad/config';
-import { parseComponentSelector } from './parse-component-selector';
-/**
- * Parse a path string into structured segments.
- *
- * ## Path Notation Rules
- *
- * **Dot notation (.)** - Access object properties
- * - `user.profile.name` - Access nested object properties
- * - `config.0` - Access object property named "0" (string key)
- *
- * **Bracket notation ([])** - Access array elements by numeric index
- * - `items[0].name` - Access first array element, then its 'name' property
- * - `matrix[0][1]` - Access multi-dimensional arrays
- *
- * **Optional chaining (?.)** - Safely access potentially missing properties
- * - `user?.profile?.email` - Returns null if any segment is missing
- *
- * **Variable prefix ($)** - Access variables instead of properties
- * - `$config.theme` - Access variable 'config', then its 'theme' property
- * - `$items[0]` - Access variable 'items' array, then first element
- *
- * **Component selector (->)** - Access properties on other components
- * - `&ref->prop.field` - Access 'prop.field' on component with ref
- * - `:Button[disabled=true]->label` - Access 'label' on Button with condition
- * - `^parent->config` - Access 'config' on parent component
- *
- * **Optional component selector (?->)** - Safely access components that might not exist
- * - `&ref?->value` - Returns null if component with ref doesn't exist
- * - `:OptionalType?->property` - Returns null if component type not found
- * - `^Parent?->config` - Returns null if parent doesn't match
- *
- * ## Component Selector Syntax
- *
- * Component selectors support modifiers and conditions:
- * - `&ref` - Select by ref
- * - `:ComponentType` - Select by component type
- * - `^parent` - Select parent component
- * - `[prop=value]` - Filter by property value
- * - Multiple conditions: `:Button[disabled=true][type=submit]`
- *
- * ## Notation Disambiguation
- *
- * The choice between dot and bracket notation determines the access type:
- * ```typescript
- * 'data.0'      // Object property named "0" (string key)
- * 'data[0]'     // Array element at index 0 (numeric index)
- * 'columns.1'   // Object property named "1"
- * 'columns[1]'  // Array element at index 1
- * ```
- *
- * @example
- * parseNodeSelector('users[0].name')
- * // => { kind: 'property', head: 'users', tail: [{ key: 0, optional: false }, { key: 'name', optional: false }] }
- *
- * @example
- * parseNodeSelector('config.0')
- * // => { kind: 'property', head: 'config', tail: [{ key: '0', optional: false }] }
- *
- * @example
- * parseNodeSelector('prop?.nested?.field')
- * // => { kind: 'property', head: 'prop', tail: [{ key: 'nested', optional: true }, { key: 'field', optional: true }] }
- *
- * @example
- * parseNodeSelector('$varName.field')
- * // => { kind: 'variable', head: 'varName', tail: [{ key: 'field', optional: false }] }
- *
- * @example
- * parseNodeSelector('&ref->prop.field')
- * // => {
- * //   componentSelector: [{ qualifier: 'ref', modifier: '&', conditions: [] }],
- * //   kind: 'property',
- * //   head: 'prop',
- * //   tail: [{ key: 'field', optional: false }]
- * // }
- *
- * @example
- * parseNodeSelector(':Button[disabled=true]->label.text')
- * // => {
- * //   componentSelector: [{ qualifier: 'Button', modifier: ':', conditions: [['disabled', 'true']] }],
- * //   kind: 'property',
- * //   head: 'label',
- * //   tail: [{ key: 'text', optional: false }]
- * // }
- */
-export function parseNodeSelector(path) {
-    if (!path) {
-        throw new Error('Empty path provided');
-    }
-    // Handle variable prefix
-    if (path.startsWith(Delimiters.Variable)) {
-        const withoutPrefix = path.slice(1);
-        // Check for both . and ?. separators
-        const dotIndex = withoutPrefix.indexOf(Delimiters.NodePath);
-        const optionalIndex = withoutPrefix.indexOf('?.');
-        // If no separator found, it's just the variable name
-        if (dotIndex === -1 && optionalIndex === -1) {
-            return {
-                kind: 'variable',
-                head: withoutPrefix,
-                tail: [],
-            };
-        }
-        // Find the first separator (. or ?.)
-        let firstSeparatorIndex;
-        let isOptional;
-        if (dotIndex === -1) {
-            firstSeparatorIndex = optionalIndex;
-            isOptional = true;
-        }
-        else if (optionalIndex === -1) {
-            firstSeparatorIndex = dotIndex;
-            isOptional = false;
-        }
-        else {
-            firstSeparatorIndex = Math.min(dotIndex, optionalIndex);
-            isOptional = firstSeparatorIndex === optionalIndex;
-        }
-        const varName = withoutPrefix.substring(0, firstSeparatorIndex);
-        const restPath = withoutPrefix.substring(firstSeparatorIndex + (isOptional ? 2 : 1));
-        return {
-            kind: 'variable',
-            head: varName,
-            tail: parseSegments(restPath, isOptional), // Pass the optional flag
-        };
-    }
-    // Handle component selector arrow (both ?-> and ->)
-    const optionalArrowIndex = path.indexOf('?->');
-    const strictArrowIndex = path.indexOf('->');
-    // Determine which arrow to use (prefer ?-> if both are found)
-    let arrowIndex = -1;
-    let arrowLength = 2;
-    let isOptionalComponent = false;
-    if (optionalArrowIndex !== -1 && (strictArrowIndex === -1 || optionalArrowIndex < strictArrowIndex)) {
-        arrowIndex = optionalArrowIndex;
-        arrowLength = 3;
-        isOptionalComponent = true;
-    }
-    else if (strictArrowIndex !== -1) {
-        arrowIndex = strictArrowIndex;
-        arrowLength = 2;
-        isOptionalComponent = false;
-    }
-    if (arrowIndex !== -1) {
-        const componentSelectorStr = path.substring(0, arrowIndex);
-        const nodePath = path.substring(arrowIndex + arrowLength);
-        const parsed = parseNodeSelector(nodePath);
-        return {
-            component: {
-                selector: parseComponentSelector(componentSelectorStr),
-                optional: isOptionalComponent,
-            },
-            kind: parsed.kind,
-            head: parsed.head,
-            tail: parsed.tail,
-        };
-    }
-    // Regular property path
-    return parsePropertyPath(path);
-}
-/**
- * Parse a property path (no variable prefix or component selector)
- */
-function parsePropertyPath(path) {
-    if (!path) {
-        throw new Error('Empty property path provided');
-    }
-    const allSegments = parseSegments(path);
-    if (allSegments.length === 0) {
-        throw new Error('Empty property path provided');
-    }
-    const [first, ...rest] = allSegments;
-    return {
-        kind: 'property',
-        head: first.key,
-        tail: rest,
-    };
-}
-/**
- * Parse path segments, handling optional chaining and array notation
- * @param path - The path to parse
- * @param startOptional - If true, the first segment should be marked as optional
- */
-function parseSegments(path, startOptional = false) {
-    if (!path)
-        return [];
-    const segments = [];
-    let current = '';
-    let nextOptional = startOptional; // Start with the passed optional flag
-    let i = 0;
-    while (i < path.length) {
-        const char = path[i];
-        const nextChar = path[i + 1];
-        // Handle optional chaining ?.
-        if (char === '?' && nextChar === '.') {
-            if (current) {
-                segments.push(makeSegment(current, nextOptional, false));
-                current = '';
-            }
-            nextOptional = true;
-            i += 2;
-            continue;
-        }
-        // Handle array bracket notation [0]
-        if (char === '[') {
-            if (current) {
-                segments.push(makeSegment(current, nextOptional, false));
-                current = '';
-                nextOptional = false;
-            }
-            let index = '';
-            i++;
-            while (i < path.length && path[i] !== ']') {
-                index += path[i];
-                i++;
-            }
-            if (path[i] === ']') {
-                segments.push(makeSegment(index, nextOptional, true)); // fromBracket = true
-                i++; // Skip ]
-                // Skip following . if present
-                if (path[i] === '.')
-                    i++;
-            }
-            continue;
-        }
-        // Handle regular . separator
-        if (char === '.') {
-            if (current) {
-                segments.push(makeSegment(current, nextOptional, false));
-                current = '';
-                nextOptional = false;
-            }
-            i++;
-            continue;
-        }
-        current += char;
-        i++;
-    }
-    if (current) {
-        segments.push(makeSegment(current, nextOptional, false));
-    }
-    return segments;
-}
-/**
- * Create a path segment, parsing numbers only for bracket notation.
- * Dot notation keeps keys as strings to allow object properties named "0", "1", etc.
- *
- * @param key - The segment key
- * @param optional - Whether this segment uses optional chaining
- * @param fromBracket - True if this came from bracket notation [0], false if from dot notation
- */
-function makeSegment(key, optional, fromBracket = false) {
-    // Only convert to number if it came from bracket notation
-    if (fromBracket) {
-        const asNumber = Number(key);
-        if (!Number.isNaN(asNumber)) {
-            return { key: asNumber, optional };
-        }
-    }
-    // Keep as string for dot notation or non-numeric bracket content
-    return { key, optional };
-}
-//# sourceMappingURL=parse-node-selector.js.map

package/esm2022/lib/parsers/parse-node-selector.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-node-selector.js","sourceRoot":"","sources":["../../../../../../libs/component-tree/src/lib/parsers/parse-node-selector.ts"],"names":[],"mappings":"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","sourcesContent":["import { Delimiters } from '@kaskad/config';\n\nimport { NodeSelector, PathSegment } from './node-selector.types';\nimport { parseComponentSelector } from './parse-component-selector';\n\nexport type PathPart = string | number;\nexport type PathArray = PathPart[];\n\n/**\n * Parse a path string into structured segments.\n *\n * ## Path Notation Rules\n *\n * **Dot notation (.)** - Access object properties\n * - `user.profile.name` - Access nested object properties\n * - `config.0` - Access object property named \"0\" (string key)\n *\n * **Bracket notation ([])** - Access array elements by numeric index\n * - `items[0].name` - Access first array element, then its 'name' property\n * - `matrix[0][1]` - Access multi-dimensional arrays\n *\n * **Optional chaining (?.)** - Safely access potentially missing properties\n * - `user?.profile?.email` - Returns null if any segment is missing\n *\n * **Variable prefix ($)** - Access variables instead of properties\n * - `$config.theme` - Access variable 'config', then its 'theme' property\n * - `$items[0]` - Access variable 'items' array, then first element\n *\n * **Component selector (->)** - Access properties on other components\n * - `&ref->prop.field` - Access 'prop.field' on component with ref\n * - `:Button[disabled=true]->label` - Access 'label' on Button with condition\n * - `^parent->config` - Access 'config' on parent component\n *\n * **Optional component selector (?->)** - Safely access components that might not exist\n * - `&ref?->value` - Returns null if component with ref doesn't exist\n * - `:OptionalType?->property` - Returns null if component type not found\n * - `^Parent?->config` - Returns null if parent doesn't match\n *\n * ## Component Selector Syntax\n *\n * Component selectors support modifiers and conditions:\n * - `&ref` - Select by ref\n * - `:ComponentType` - Select by component type\n * - `^parent` - Select parent component\n * - `[prop=value]` - Filter by property value\n * - Multiple conditions: `:Button[disabled=true][type=submit]`\n *\n * ## Notation Disambiguation\n *\n * The choice between dot and bracket notation determines the access type:\n * ```typescript\n * 'data.0'      // Object property named \"0\" (string key)\n * 'data[0]'     // Array element at index 0 (numeric index)\n * 'columns.1'   // Object property named \"1\"\n * 'columns[1]'  // Array element at index 1\n * ```\n *\n * @example\n * parseNodeSelector('users[0].name')\n * // => { kind: 'property', head: 'users', tail: [{ key: 0, optional: false }, { key: 'name', optional: false }] }\n *\n * @example\n * parseNodeSelector('config.0')\n * // => { kind: 'property', head: 'config', tail: [{ key: '0', optional: false }] }\n *\n * @example\n * parseNodeSelector('prop?.nested?.field')\n * // => { kind: 'property', head: 'prop', tail: [{ key: 'nested', optional: true }, { key: 'field', optional: true }] }\n *\n * @example\n * parseNodeSelector('$varName.field')\n * // => { kind: 'variable', head: 'varName', tail: [{ key: 'field', optional: false }] }\n *\n * @example\n * parseNodeSelector('&ref->prop.field')\n * // => {\n * //   componentSelector: [{ qualifier: 'ref', modifier: '&', conditions: [] }],\n * //   kind: 'property',\n * //   head: 'prop',\n * //   tail: [{ key: 'field', optional: false }]\n * // }\n *\n * @example\n * parseNodeSelector(':Button[disabled=true]->label.text')\n * // => {\n * //   componentSelector: [{ qualifier: 'Button', modifier: ':', conditions: [['disabled', 'true']] }],\n * //   kind: 'property',\n * //   head: 'label',\n * //   tail: [{ key: 'text', optional: false }]\n * // }\n */\nexport function parseNodeSelector(path: string): NodeSelector {\n  if (!path) {\n    throw new Error('Empty path provided');\n  }\n\n  // Handle variable prefix\n  if (path.startsWith(Delimiters.Variable)) {\n    const withoutPrefix = path.slice(1);\n\n    // Check for both . and ?. separators\n    const dotIndex = withoutPrefix.indexOf(Delimiters.NodePath);\n    const optionalIndex = withoutPrefix.indexOf('?.');\n\n    // If no separator found, it's just the variable name\n    if (dotIndex === -1 && optionalIndex === -1) {\n      return {\n        kind: 'variable',\n        head: withoutPrefix,\n        tail: [],\n      };\n    }\n\n    // Find the first separator (. or ?.)\n    let firstSeparatorIndex: number;\n    let isOptional: boolean;\n\n    if (dotIndex === -1) {\n      firstSeparatorIndex = optionalIndex;\n      isOptional = true;\n    } else if (optionalIndex === -1) {\n      firstSeparatorIndex = dotIndex;\n      isOptional = false;\n    } else {\n      firstSeparatorIndex = Math.min(dotIndex, optionalIndex);\n      isOptional = firstSeparatorIndex === optionalIndex;\n    }\n\n    const varName = withoutPrefix.substring(0, firstSeparatorIndex);\n    const restPath = withoutPrefix.substring(firstSeparatorIndex + (isOptional ? 2 : 1));\n\n    return {\n      kind: 'variable',\n      head: varName,\n      tail: parseSegments(restPath, isOptional), // Pass the optional flag\n    };\n  }\n\n  // Handle component selector arrow (both ?-> and ->)\n  const optionalArrowIndex = path.indexOf('?->');\n  const strictArrowIndex = path.indexOf('->');\n\n  // Determine which arrow to use (prefer ?-> if both are found)\n  let arrowIndex = -1;\n  let arrowLength = 2;\n  let isOptionalComponent = false;\n\n  if (optionalArrowIndex !== -1 && (strictArrowIndex === -1 || optionalArrowIndex < strictArrowIndex)) {\n    arrowIndex = optionalArrowIndex;\n    arrowLength = 3;\n    isOptionalComponent = true;\n  } else if (strictArrowIndex !== -1) {\n    arrowIndex = strictArrowIndex;\n    arrowLength = 2;\n    isOptionalComponent = false;\n  }\n\n  if (arrowIndex !== -1) {\n    const componentSelectorStr = path.substring(0, arrowIndex);\n    const nodePath = path.substring(arrowIndex + arrowLength);\n    const parsed = parseNodeSelector(nodePath);\n\n    return {\n      component: {\n        selector: parseComponentSelector(componentSelectorStr),\n        optional: isOptionalComponent,\n      },\n      kind: parsed.kind,\n      head: parsed.head,\n      tail: parsed.tail,\n    };\n  }\n\n  // Regular property path\n  return parsePropertyPath(path);\n}\n\n/**\n * Parse a property path (no variable prefix or component selector)\n */\nfunction parsePropertyPath(path: string): NodeSelector {\n  if (!path) {\n    throw new Error('Empty property path provided');\n  }\n\n  const allSegments = parseSegments(path);\n\n  if (allSegments.length === 0) {\n    throw new Error('Empty property path provided');\n  }\n\n  const [first, ...rest] = allSegments;\n\n  return {\n    kind: 'property',\n    head: first.key as string,\n    tail: rest,\n  };\n}\n\n/**\n * Parse path segments, handling optional chaining and array notation\n * @param path - The path to parse\n * @param startOptional - If true, the first segment should be marked as optional\n */\nfunction parseSegments(path: string, startOptional = false): PathSegment[] {\n  if (!path) return [];\n\n  const segments: PathSegment[] = [];\n  let current = '';\n  let nextOptional = startOptional; // Start with the passed optional flag\n  let i = 0;\n\n  while (i < path.length) {\n    const char = path[i];\n    const nextChar = path[i + 1];\n\n    // Handle optional chaining ?.\n    if (char === '?' && nextChar === '.') {\n      if (current) {\n        segments.push(makeSegment(current, nextOptional, false));\n        current = '';\n      }\n      nextOptional = true;\n      i += 2;\n      continue;\n    }\n\n    // Handle array bracket notation [0]\n    if (char === '[') {\n      if (current) {\n        segments.push(makeSegment(current, nextOptional, false));\n        current = '';\n        nextOptional = false;\n      }\n\n      let index = '';\n      i++;\n      while (i < path.length && path[i] !== ']') {\n        index += path[i];\n        i++;\n      }\n\n      if (path[i] === ']') {\n        segments.push(makeSegment(index, nextOptional, true)); // fromBracket = true\n        i++; // Skip ]\n\n        // Skip following . if present\n        if (path[i] === '.') i++;\n      }\n      continue;\n    }\n\n    // Handle regular . separator\n    if (char === '.') {\n      if (current) {\n        segments.push(makeSegment(current, nextOptional, false));\n        current = '';\n        nextOptional = false;\n      }\n      i++;\n      continue;\n    }\n\n    current += char;\n    i++;\n  }\n\n  if (current) {\n    segments.push(makeSegment(current, nextOptional, false));\n  }\n\n  return segments;\n}\n\n/**\n * Create a path segment, parsing numbers only for bracket notation.\n * Dot notation keeps keys as strings to allow object properties named \"0\", \"1\", etc.\n *\n * @param key - The segment key\n * @param optional - Whether this segment uses optional chaining\n * @param fromBracket - True if this came from bracket notation [0], false if from dot notation\n */\nfunction makeSegment(key: string, optional: boolean, fromBracket = false): PathSegment {\n  // Only convert to number if it came from bracket notation\n  if (fromBracket) {\n    const asNumber = Number(key);\n    if (!Number.isNaN(asNumber)) {\n      return { key: asNumber, optional };\n    }\n  }\n\n  // Keep as string for dot notation or non-numeric bracket content\n  return { key, optional };\n}\n"]}

package/esm2022/lib/types/command.js

@@ -1 +0,0 @@
-//# sourceMappingURL=command.js.map

package/esm2022/lib/types/command.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"command.js","sourceRoot":"","sources":["../../../../../../libs/component-tree/src/lib/types/command.ts"],"names":[],"mappings":"","sourcesContent":["export interface CommandRef<_TParams = unknown[], TResult = unknown> {\n  execute(...params: unknown[]): Promise<TResult>;\n}\n"]}

package/esm2022/lib/types/index.js

@@ -1,5 +0,0 @@
-export * from './schema';
-export * from './command';
-export * from './node.guards';
-export * from '../computation';
-//# sourceMappingURL=index.js.map

package/esm2022/lib/types/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../libs/component-tree/src/lib/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC","sourcesContent":["export * from './schema';\nexport * from './command';\nexport * from './node.guards';\nexport * from '../computation';\n"]}

package/esm2022/lib/types/node.guards.js

@@ -1,7 +0,0 @@
-export function isArrayNode(node) {
-    return node.valueType.type === 'array';
-}
-export function isCommandNode(node) {
-    return node.valueType.type === 'command';
-}
-//# sourceMappingURL=node.guards.js.map

package/esm2022/lib/types/node.guards.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"node.guards.js","sourceRoot":"","sources":["../../../../../../libs/component-tree/src/lib/types/node.guards.ts"],"names":[],"mappings":"AAIA,MAAM,UAAU,WAAW,CAAC,IAA6B;IACvD,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,KAAK,OAAO,CAAC;AACzC,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,IAA6B;IACzD,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,KAAK,SAAS,CAAC;AAC3C,CAAC","sourcesContent":["import { ValueType } from '@kaskad/types';\n\nimport { AbstractNode, ArrayNode, CommandNode } from '../node/node';\n\nexport function isArrayNode(node: AbstractNode<ValueType>): node is ArrayNode {\n  return node.valueType.type === 'array';\n}\n\nexport function isCommandNode(node: AbstractNode<ValueType>): node is CommandNode {\n  return node.valueType.type === 'command';\n}\n"]}

package/esm2022/lib/types/schema.js

@@ -1 +0,0 @@
-//# sourceMappingURL=schema.js.map

package/esm2022/lib/types/schema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../../../../libs/component-tree/src/lib/types/schema.ts"],"names":[],"mappings":"","sourcesContent":["import { ComponentId } from '@kaskad/types';\n\nimport { CommandNode } from '../node/node';\n\nexport interface CommandNodeStructure {\n  runnerType: string;\n  owner: ComponentId;\n  target: string;\n  init?: string;\n  finalize?: string;\n}\n\nexport interface NodeChangeHandler {\n  readonly selector: string;\n  readonly command: CommandNode;\n}\n"]}

package/esm2022/lib/util/extract-node-value.js

@@ -1,45 +0,0 @@
-import { ComponentStore } from '../mobx/store';
-const componentIdExtractors = {
-    array: (value, ids) => {
-        if (!Array.isArray(value))
-            return; // the check is needed for booleanInputGroup value proxies (TODO: verify)
-        for (const node of value) {
-            extractComponentsIds(node, ids);
-        }
-    },
-    object: (value, ids) => {
-        if (!value)
-            return;
-        for (const node of Object.values(value)) {
-            extractComponentsIds(node, ids);
-        }
-    },
-    map: (value, ids) => {
-        if (!value)
-            return;
-        for (const node of Object.values(value)) {
-            extractComponentsIds(node, ids);
-        }
-    },
-    component: (value, ids) => {
-        if (!value)
-            return;
-        const componentId = value;
-        ids.push(componentId);
-        const component = ComponentStore.getInstance().getComponent(componentId);
-        if (component) {
-            for (const [, propNode] of component.props) {
-                extractComponentsIds(propNode, ids);
-            }
-        }
-    },
-};
-export function extractComponentsIds(node, ids = []) {
-    const value = node.structure;
-    const extractor = componentIdExtractors[node.valueType.type];
-    if (extractor) {
-        extractor(value, ids);
-    }
-    return ids;
-}
-//# sourceMappingURL=extract-node-value.js.map

package/esm2022/lib/util/extract-node-value.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"extract-node-value.js","sourceRoot":"","sources":["../../../../../../libs/component-tree/src/lib/util/extract-node-value.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAG/C,MAAM,qBAAqB,GAAiE;IAC1F,KAAK,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;QACpB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;YAAE,OAAO,CAAC,yEAAyE;QAC5G,KAAK,MAAM,IAAI,IAAI,KAAkC,EAAE,CAAC;YACtD,oBAAoB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IACD,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;QACrB,IAAI,CAAC,KAAK;YAAE,OAAO;QACnB,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC,KAAgD,CAAC,EAAE,CAAC;YACnF,oBAAoB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IACD,GAAG,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;QAClB,IAAI,CAAC,KAAK;YAAE,OAAO;QACnB,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC,KAAgD,CAAC,EAAE,CAAC;YACnF,oBAAoB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IACD,SAAS,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;QACxB,IAAI,CAAC,KAAK;YAAE,OAAO;QACnB,MAAM,WAAW,GAAG,KAAoB,CAAC;QACzC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAEtB,MAAM,SAAS,GAAG,cAAc,CAAC,WAAW,EAAE,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;QACzE,IAAI,SAAS,EAAE,CAAC;YACd,KAAK,MAAM,CAAC,EAAE,QAAQ,CAAC,IAAI,SAAS,CAAC,KAAK,EAAE,CAAC;gBAC3C,oBAAoB,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;YACtC,CAAC;QACH,CAAC;IACH,CAAC;CACF,CAAC;AAEF,MAAM,UAAU,oBAAoB,CAAC,IAA6B,EAAE,MAAqB,EAAE;IACzF,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC;IAC7B,MAAM,SAAS,GAAG,qBAAqB,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAE7D,IAAI,SAAS,EAAE,CAAC;QACd,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IACxB,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import { ComponentId, ValueType } from '@kaskad/types';\n\nimport { ComponentStore } from '../mobx/store';\nimport { AbstractNode } from '../node/node';\n\nconst componentIdExtractors: Record<string, (value: unknown, ids: ComponentId[]) => void> = {\n  array: (value, ids) => {\n    if (!Array.isArray(value)) return; // the check is needed for booleanInputGroup value proxies (TODO: verify)\n    for (const node of value as AbstractNode<ValueType>[]) {\n      extractComponentsIds(node, ids);\n    }\n  },\n  object: (value, ids) => {\n    if (!value) return;\n    for (const node of Object.values(value as Record<string, AbstractNode<ValueType>>)) {\n      extractComponentsIds(node, ids);\n    }\n  },\n  map: (value, ids) => {\n    if (!value) return;\n    for (const node of Object.values(value as Record<string, AbstractNode<ValueType>>)) {\n      extractComponentsIds(node, ids);\n    }\n  },\n  component: (value, ids) => {\n    if (!value) return;\n    const componentId = value as ComponentId;\n    ids.push(componentId);\n\n    const component = ComponentStore.getInstance().getComponent(componentId);\n    if (component) {\n      for (const [, propNode] of component.props) {\n        extractComponentsIds(propNode, ids);\n      }\n    }\n  },\n};\n\nexport function extractComponentsIds(node: AbstractNode<ValueType>, ids: ComponentId[] = []): ComponentId[] {\n  const value = node.structure;\n  const extractor = componentIdExtractors[node.valueType.type];\n\n  if (extractor) {\n    extractor(value, ids);\n  }\n\n  return ids;\n}\n"]}

package/esm2022/lib/util/format-source.js

@@ -1,7 +0,0 @@
-export function formatSource(sourceUrl, path) {
-    if (!sourceUrl)
-        return '';
-    const pathStr = path?.length ? ` @ ${path.join('.')}` : '';
-    return `[${sourceUrl}${pathStr}]`;
-}
-//# sourceMappingURL=format-source.js.map

package/esm2022/lib/util/format-source.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"format-source.js","sourceRoot":"","sources":["../../../../../../libs/component-tree/src/lib/util/format-source.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,YAAY,CAAC,SAAoC,EAAE,IAA0B;IAC3F,IAAI,CAAC,SAAS;QAAE,OAAO,EAAE,CAAC;IAC1B,MAAM,OAAO,GAAG,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAC3D,OAAO,IAAI,SAAS,GAAG,OAAO,GAAG,CAAC;AACpC,CAAC","sourcesContent":["export function formatSource(sourceUrl: string | null | undefined, path?: (string | number)[]): string {\n  if (!sourceUrl) return '';\n  const pathStr = path?.length ? ` @ ${path.join('.')}` : '';\n  return `[${sourceUrl}${pathStr}]`;\n}\n"]}

package/esm2022/lib/util/get-component.js

@@ -1,8 +0,0 @@
-import { ComponentStore } from '../mobx/store';
-export function getComponent(node) {
-    if (!node.position.componentId) {
-        throw new Error('Node does not have a component context');
-    }
-    return ComponentStore.getInstance().getComponentOrThrow(node.position.componentId);
-}
-//# sourceMappingURL=get-component.js.map

package/esm2022/lib/util/get-component.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-component.js","sourceRoot":"","sources":["../../../../../../libs/component-tree/src/lib/util/get-component.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAG/C,MAAM,UAAU,YAAY,CAAC,IAA6B;IACxD,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;QAC/B,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;IAC5D,CAAC;IACD,OAAO,cAAc,CAAC,WAAW,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;AACrF,CAAC","sourcesContent":["import { ValueType } from '@kaskad/types';\n\nimport { TComponent } from '../mobx/component';\nimport { ComponentStore } from '../mobx/store';\nimport { AbstractNode } from '../node/node';\n\nexport function getComponent(node: AbstractNode<ValueType>): TComponent {\n  if (!node.position.componentId) {\n    throw new Error('Node does not have a component context');\n  }\n  return ComponentStore.getInstance().getComponentOrThrow(node.position.componentId);\n}\n"]}

package/esm2022/lib/util/id-generator.js

@@ -1,10 +0,0 @@
-export const componentIdGenerator = {
-    increment: 0,
-    generateId() {
-        return ['csid', ++this.increment].filter((item) => !!item).join('-');
-    },
-    reset() {
-        this.increment = 0;
-    },
-};
-//# sourceMappingURL=id-generator.js.map

package/esm2022/lib/util/id-generator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"id-generator.js","sourceRoot":"","sources":["../../../../../../libs/component-tree/src/lib/util/id-generator.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,SAAS,EAAE,CAAC;IACZ,UAAU;QACR,OAAO,CAAC,MAAM,EAAE,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACvE,CAAC;IACD,KAAK;QACH,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;IACrB,CAAC;CACF,CAAC","sourcesContent":["export const componentIdGenerator = {\n  increment: 0,\n  generateId() {\n    return ['csid', ++this.increment].filter((item) => !!item).join('-');\n  },\n  reset() {\n    this.increment = 0;\n  },\n};\n"]}

package/esm2022/lib/util/traverse-node.js

@@ -1,50 +0,0 @@
-/**
- * Traverse a node using parsed path segments, respecting optional chaining.
- *
- * @param node - The starting node
- * @param segments - Array of path segments to traverse
- * @returns The found node, or null if not found and optional chaining was used
- * @throws Error if a required segment is not found
- *
- * @example
- * const userNode = component.getNode('user');
- * const nameNode = traverseNode(userNode, [
- *   { key: 'profile', optional: false },
- *   { key: 'name', optional: false }
- * ]);
- *
- * @example
- * // With optional chaining - returns null instead of throwing
- * const emailNode = traverseNode(userNode, [
- *   { key: 'contact', optional: true },
- *   { key: 'email', optional: false }
- * ]);
- */
-export function traverseNode(node, segments) {
-    if (segments.length === 0) {
-        return node;
-    }
-    const [head, ...tail] = segments;
-    const found = node.getNodeByPath([head.key]);
-    if (!found) {
-        if (head.optional) {
-            return null; // Optional chaining returns null
-        }
-        // Check if this is a shape/object-like node with null value
-        // In this case, accessing properties should return null instead of throwing
-        // This is common in reactive systems where shape values might not be initialized yet
-        if (node.nodeType === 'shape' ||
-            node.nodeType === 'variantShape' ||
-            node.nodeType === 'object' ||
-            node.nodeType === 'map') {
-            const extracted = node.extractedValue;
-            if (extracted === null || extracted === undefined) {
-                return null;
-            }
-        }
-        throw new Error(`Cannot access ${typeof head.key === 'number' ? 'index' : 'property'} ` +
-            `'${head.key}' on ${node.nodeType} node at path ${node.position.path.join('.')}`);
-    }
-    return traverseNode(found, tail);
-}
-//# sourceMappingURL=traverse-node.js.map

package/esm2022/lib/util/traverse-node.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"traverse-node.js","sourceRoot":"","sources":["../../../../../../libs/component-tree/src/lib/util/traverse-node.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,YAAY,CAAC,IAA6B,EAAE,QAAuB;IACjF,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,GAAG,QAAQ,CAAC;IACjC,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IAE7C,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,OAAO,IAAI,CAAC,CAAC,iCAAiC;QAChD,CAAC;QAED,4DAA4D;QAC5D,4EAA4E;QAC5E,qFAAqF;QACrF,IACE,IAAI,CAAC,QAAQ,KAAK,OAAO;YACzB,IAAI,CAAC,QAAQ,KAAK,cAAc;YAChC,IAAI,CAAC,QAAQ,KAAK,QAAQ;YAC1B,IAAI,CAAC,QAAQ,KAAK,KAAK,EACvB,CAAC;YACD,MAAM,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC;YACtC,IAAI,SAAS,KAAK,IAAI,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;gBAClD,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QAED,MAAM,IAAI,KAAK,CACb,iBAAiB,OAAO,IAAI,CAAC,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,GAAG;YACrE,IAAI,IAAI,CAAC,GAAG,QAAQ,IAAI,CAAC,QAAQ,iBAAiB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CACnF,CAAC;IACJ,CAAC;IAED,OAAO,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AACnC,CAAC","sourcesContent":["import { ValueType } from '@kaskad/types';\n\nimport { AbstractNode } from '../node/node';\nimport { PathSegment } from '../parsers';\n\n/**\n * Traverse a node using parsed path segments, respecting optional chaining.\n *\n * @param node - The starting node\n * @param segments - Array of path segments to traverse\n * @returns The found node, or null if not found and optional chaining was used\n * @throws Error if a required segment is not found\n *\n * @example\n * const userNode = component.getNode('user');\n * const nameNode = traverseNode(userNode, [\n *   { key: 'profile', optional: false },\n *   { key: 'name', optional: false }\n * ]);\n *\n * @example\n * // With optional chaining - returns null instead of throwing\n * const emailNode = traverseNode(userNode, [\n *   { key: 'contact', optional: true },\n *   { key: 'email', optional: false }\n * ]);\n */\nexport function traverseNode(node: AbstractNode<ValueType>, segments: PathSegment[]): AbstractNode<ValueType> | null {\n  if (segments.length === 0) {\n    return node;\n  }\n\n  const [head, ...tail] = segments;\n  const found = node.getNodeByPath([head.key]);\n\n  if (!found) {\n    if (head.optional) {\n      return null; // Optional chaining returns null\n    }\n\n    // Check if this is a shape/object-like node with null value\n    // In this case, accessing properties should return null instead of throwing\n    // This is common in reactive systems where shape values might not be initialized yet\n    if (\n      node.nodeType === 'shape' ||\n      node.nodeType === 'variantShape' ||\n      node.nodeType === 'object' ||\n      node.nodeType === 'map'\n    ) {\n      const extracted = node.extractedValue;\n      if (extracted === null || extracted === undefined) {\n        return null;\n      }\n    }\n\n    throw new Error(\n      `Cannot access ${typeof head.key === 'number' ? 'index' : 'property'} ` +\n        `'${head.key}' on ${node.nodeType} node at path ${node.position.path.join('.')}`,\n    );\n  }\n\n  return traverseNode(found, tail);\n}\n"]}

package/index.d.ts

@@ -1,11 +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';

package/kaskad-component-tree.d.ts

@@ -1,5 +0,0 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@kaskad/component-tree" />
-export * from './index';

package/lib/component-lookup/index.d.ts

@@ -1,8 +0,0 @@
-import { ComponentId } from '@kaskad/types';
-import { TComponent } from '../mobx/component';
-import { parseComponentSelector, SelectorSegment } from '../parsers';
-export { parseComponentSelector };
-export type { SelectorSegment };
-export declare function findComponent(relativeTo: ComponentId, selector: SelectorSegment[]): TComponent | null;
-export declare function findComponents(relativeTo: ComponentId, selector: SelectorSegment[]): TComponent[];
-export declare function findComponentsIds(relativeTo: ComponentId, selector: SelectorSegment[]): ComponentId[];

package/lib/component-lookup/traverses/array-traverser.d.ts

@@ -1,3 +0,0 @@
-import { ArrayValueType } from '@kaskad/types';
-import { Context, NodeQueue } from '../types';
-export declare function traversArray(ctx: Context<ArrayValueType>, nodeQueue: NodeQueue): void;

package/lib/component-lookup/traverses/component-traverser.d.ts

@@ -1,3 +0,0 @@
-import { ComponentValueType } from '@kaskad/types';
-import { Context, NodeQueue, TraverseResult } from '../types';
-export declare function traversComponent(ctx: Context<ComponentValueType>, nodeQueue: NodeQueue, foundComponents: TraverseResult): void;

package/lib/component-lookup/traverses/index.d.ts

@@ -1,9 +0,0 @@
-import { ValueType } from '@kaskad/types';
-import { Context, NodeQueue, TraverseResult } from '../types';
-type TraversFn = (ctx: Context<ValueType>, nodeQueue: NodeQueue, foundComponents: TraverseResult) => void;
-type Registry = {
-    _registry: Record<string, unknown>;
-    get(key: string): TraversFn;
-};
-export declare const traversesRegistry: Registry;
-export {};

package/lib/component-lookup/traverses/object-traverser.d.ts

@@ -1,3 +0,0 @@
-import { ObjectValueType } from '@kaskad/types';
-import { Context, NodeQueue } from '../types';
-export declare function traversObject(ctx: Context<ObjectValueType>, nodeQueue: NodeQueue): void;

package/lib/component-lookup/types.d.ts

@@ -1,13 +0,0 @@
-import { ComponentId, ValueType } from '@kaskad/types';
-import { NodeExtractedValue } from '../node/node-type';
-import { SelectorSegment } from '../parsers';
-export interface Context<T extends ValueType> {
-    currentNode: {
-        valueType: T;
-        value: NodeExtractedValue<T> | null;
-    };
-    relativeTo: ComponentId;
-    selectorSegments: SelectorSegment[];
-}
-export type NodeQueue = Array<Context<ValueType>>;
-export type TraverseResult = ComponentId[];

package/lib/component-tree-api.d.ts

@@ -1,21 +0,0 @@
-import { ComponentId, ValueType } from '@kaskad/types';
-import { TComponent } from './mobx/component';
-import { AbstractNode } from './node/node';
-export 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;
-}

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

@@ -1,14 +0,0 @@
-import { ComputationSchema } from '@kaskad/types';
-import { IReactionDisposer } from 'mobx';
-export 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;
-}