@treenity/core 1.0.48 → 3.0.1

package/src/comp/needs.ts

@@ -0,0 +1,113 @@
+import { AnyType, type ComponentData, getComponent, isComponent, type NodeData } from '#core';
+import { basename, dirname, join } from '#core/path';
+import { type Tree } from '#tree';
+
+// ── Types ──
+
+export type NeedSpec =
+  | { kind: 'sibling'; name: string; key: string }
+  | { kind: 'field-ref'; field: string; key: string }
+  | { kind: 'path'; path: string; key: string }
+  | { kind: 'children'; path: string; key: string };
+
+export type ResolvedDeps = Record<string, ComponentData | NodeData | NodeData[]>;
+
+// ── Needs store ──
+// Local map keyed by type@action. Populated by registerActionNeeds (called from registerType).
+// Separate from registry meta because needs are registered before actions exist in the registry.
+
+const needsMap = new Map<string, NeedSpec[]>();
+
+export function registerActionNeeds(type: string, action: string, patterns: string[]): void {
+  needsMap.set(`${type}@${action}`, patterns.map(parseNeedPattern));
+}
+
+export function getActionNeeds(type: string, action: string): NeedSpec[] {
+  return needsMap.get(`${type}@${action}`)
+    ?? needsMap.get(`${type}@*`)
+    ?? [];
+}
+
+// ── Pattern parsing ──
+
+export function parseNeedPattern(p: string): NeedSpec {
+  if (p.startsWith('@')) return { kind: 'field-ref', field: p.slice(1), key: p.slice(1) };
+  if (p.endsWith('/*')) return { kind: 'children', path: p.slice(0, -2), key: basename(p.slice(0, -2)) };
+  if (p[0] === '/' || p.startsWith('./') || p.startsWith('../')) return { kind: 'path', path: p, key: basename(p) };
+  return { kind: 'sibling', name: p, key: p };
+}
+
+function resolvePath(base: string, rel: string): string {
+  if (rel[0] === '/') return rel;
+  if (rel.startsWith('./')) return join(base, rel.slice(2));
+  if (!rel.startsWith('../')) throw new Error(`Invalid relative path: ${rel}`);
+  const parent = dirname(base);
+  if (!parent) throw new Error(`Cannot resolve "../" from root`);
+  return join(parent, rel.slice(3));
+}
+
+// ── Dependency collection ──
+
+export async function collectDeps(
+  node: NodeData, componentName: string, actionName: string, store: Tree,
+): Promise<ResolvedDeps> {
+  const cv = getComponent(node, AnyType, componentName);
+  if (!cv) throw new Error(`Component "${componentName}" not found on ${node.$path}`);
+
+  const specs = getActionNeeds(cv.$type, actionName);
+  if (!specs.length) return {};
+
+  const deps: ResolvedDeps = {};
+  const async_: Promise<void>[] = [];
+
+  for (const s of specs) {
+    if (deps[s.key] !== undefined) throw new Error(`Duplicate dep key "${s.key}"`);
+
+    if (s.kind === 'sibling') {
+      const v = node[s.name];
+      if (!isComponent(v)) throw new Error(`Needed sibling "${s.name}" not found on ${node.$path}`);
+      deps[s.key] = v;
+      continue;
+    }
+
+    // cross-node: resolve target path, then fetch
+    let target: string;
+    if (s.kind === 'field-ref') {
+      target = (cv as Record<string, unknown>)[s.field] as string;
+      if (typeof target !== 'string') throw new Error(`Field "${s.field}" on ${componentName} is not a path string`);
+    } else {
+      target = resolvePath(node.$path, s.path);
+    }
+
+    if (s.kind === 'children') {
+      async_.push(store.getChildren(target).then(({ items }) => { deps[s.key] = items; }));
+    } else {
+      async_.push(store.get(target).then(n => {
+        if (!n) throw new Error(`Dep "${s.key}" → "${target}" not found`);
+        deps[s.key] = n;
+      }));
+    }
+  }
+
+  if (async_.length) await Promise.all(async_);
+  return deps;
+}
+
+// ── Backward compat ──
+
+export function collectSiblings(node: NodeData, componentName: string): Record<string, ComponentData> {
+  const cv = getComponent(node, AnyType, componentName);
+  if (!cv) throw new Error(`Component "${componentName}" not found on ${node.$path}`);
+
+  const specs = getActionNeeds(cv.$type, '*');
+  if (!specs.length) return {};
+
+  const out: Record<string, ComponentData> = {};
+  for (const s of specs) {
+    if (s.kind !== 'sibling') continue;
+    const v = node[s.name];
+    if (!isComponent(v)) throw new Error(`Needed component "${s.name}" not found on ${node.$path}`);
+    out[s.key] = v;
+  }
+  return out;
+}

package/src/comp/validate.test.ts

@@ -0,0 +1,304 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { validateValue, validateComponent, addTypeValidator, type ValidationError } from './validate';
+import type { PropertySchema, TypeSchema } from '#schema/types';
+import type { ComponentData } from '#core';
+
+// Helper: collect errors from validateValue
+function check(value: unknown, def: Partial<PropertySchema>, path = 'x'): ValidationError[] {
+  const errors: ValidationError[] = [];
+  validateValue(value, def as PropertySchema, path, errors);
+  return errors;
+}
+
+describe('validateValue', () => {
+
+  // ── String ──
+
+  describe('string', () => {
+    it('passes valid string', () => {
+      assert.equal(check('hello', { type: 'string' }).length, 0);
+    });
+
+    it('rejects non-string', () => {
+      const e = check(42, { type: 'string' });
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /expected string/);
+    });
+
+    it('minLength', () => {
+      assert.equal(check('ab', { type: 'string', minLength: 2 } as any).length, 0);
+      const e = check('a', { type: 'string', minLength: 2 } as any);
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /min length 2/);
+    });
+
+    it('maxLength', () => {
+      assert.equal(check('ab', { type: 'string', maxLength: 5 } as any).length, 0);
+      const e = check('toolong', { type: 'string', maxLength: 3 } as any);
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /max length 3/);
+    });
+
+    it('pattern', () => {
+      assert.equal(check('abc123', { type: 'string', pattern: '^[a-z]+\\d+$' } as any).length, 0);
+      const e = check('ABC', { type: 'string', pattern: '^[a-z]+$' } as any);
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /must match/);
+    });
+
+    it('enum', () => {
+      assert.equal(check('a', { type: 'string', enum: ['a', 'b'] }).length, 0);
+      const e = check('c', { type: 'string', enum: ['a', 'b'] });
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /must be one of/);
+    });
+  });
+
+  // ── Number ──
+
+  describe('number', () => {
+    it('passes valid number', () => {
+      assert.equal(check(42, { type: 'number' }).length, 0);
+    });
+
+    it('rejects non-number', () => {
+      const e = check('nope', { type: 'number' });
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /expected number/);
+    });
+
+    it('minimum', () => {
+      assert.equal(check(10, { type: 'number', minimum: 5 } as any).length, 0);
+      const e = check(3, { type: 'number', minimum: 5 } as any);
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /minimum 5/);
+    });
+
+    it('maximum', () => {
+      assert.equal(check(5, { type: 'number', maximum: 10 } as any).length, 0);
+      const e = check(15, { type: 'number', maximum: 10 } as any);
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /maximum 10/);
+    });
+  });
+
+  // ── Boolean ──
+
+  describe('boolean', () => {
+    it('passes valid boolean', () => {
+      assert.equal(check(true, { type: 'boolean' }).length, 0);
+    });
+
+    it('rejects non-boolean', () => {
+      const e = check(1, { type: 'boolean' });
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /expected boolean/);
+    });
+  });
+
+  // ── Array ──
+
+  describe('array', () => {
+    it('passes valid array', () => {
+      assert.equal(check([1, 2], { type: 'array' }).length, 0);
+    });
+
+    it('rejects non-array', () => {
+      const e = check('not array', { type: 'array' });
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /expected array/);
+    });
+
+    it('minItems', () => {
+      assert.equal(check([1, 2], { type: 'array', minItems: 2 } as any).length, 0);
+      const e = check([1], { type: 'array', minItems: 2 } as any);
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /min items 2/);
+    });
+
+    it('maxItems', () => {
+      assert.equal(check([1], { type: 'array', maxItems: 3 } as any).length, 0);
+      const e = check([1, 2, 3, 4], { type: 'array', maxItems: 3 } as any);
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /max items 3/);
+    });
+
+    it('validates primitive items', () => {
+      const def = { type: 'array', items: { type: 'number' } };
+      assert.equal(check([1, 2, 3], def as any).length, 0);
+      const e = check([1, 'bad', 3], def as any);
+      assert.equal(e.length, 1);
+      assert.equal(e[0].path, 'x[1]');
+      assert.match(e[0].message, /expected number/);
+    });
+
+    it('validates object items with properties', () => {
+      const def = {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', title: 'Name' },
+            age: { type: 'number', title: 'Age' },
+          },
+        },
+      };
+      assert.equal(check([{ name: 'Alice', age: 30 }], def as any).length, 0);
+
+      const e = check([{ name: 'Alice', age: 'thirty' }], def as any);
+      assert.equal(e.length, 1);
+      assert.equal(e[0].path, 'x[0].age');
+      assert.match(e[0].message, /expected number/);
+    });
+
+    it('validates nested arrays', () => {
+      const def = {
+        type: 'array',
+        items: { type: 'array', items: { type: 'number' } },
+      };
+      assert.equal(check([[1, 2], [3]], def as any).length, 0);
+
+      const e = check([[1, 'x']], def as any);
+      assert.equal(e.length, 1);
+      assert.equal(e[0].path, 'x[0][1]');
+    });
+
+    it('skips null items in array', () => {
+      const def = { type: 'array', items: { type: 'number' } };
+      assert.equal(check([1, null, 3], def as any).length, 0);
+    });
+
+    it('rejects non-object when properties expected', () => {
+      const def = {
+        type: 'array',
+        items: { properties: { name: { type: 'string', title: 'N' } } },
+      };
+      const e = check(['not-object'], def as any);
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /expected object/);
+    });
+  });
+
+  // ── Object ──
+
+  describe('object', () => {
+    it('passes valid object', () => {
+      assert.equal(check({}, { type: 'object' }).length, 0);
+    });
+
+    it('rejects non-object', () => {
+      const e = check('nope', { type: 'object' });
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /expected object/);
+    });
+
+    it('rejects array as object', () => {
+      const e = check([], { type: 'object' });
+      assert.equal(e.length, 1);
+      assert.match(e[0].message, /expected object, got array/);
+    });
+
+    it('validates nested properties', () => {
+      const def = {
+        type: 'object',
+        properties: {
+          x: { type: 'number', title: 'X' },
+        },
+      };
+      assert.equal(check({ x: 5 }, def as any).length, 0);
+      const e = check({ x: 'bad' }, def as any);
+      assert.equal(e.length, 1);
+      assert.equal(e[0].path, 'x.x');
+    });
+  });
+
+  // ── Edge cases ──
+
+  it('no type = no validation', () => {
+    assert.equal(check('anything', {}).length, 0);
+  });
+
+  it('unknown type = no validation', () => {
+    assert.equal(check('anything', { type: 'custom-widget' }).length, 0);
+  });
+
+  it('preserves path through nesting', () => {
+    const def = {
+      type: 'object',
+      properties: {
+        items: {
+          type: 'array',
+          title: 'Items',
+          items: {
+            properties: {
+              price: { type: 'number', title: 'Price' },
+            },
+          },
+        },
+      },
+    };
+    const e = check({ items: [{ price: 'free' }] }, def as any, 'order');
+    assert.equal(e.length, 1);
+    assert.equal(e[0].path, 'order.items[0].price');
+  });
+});
+
+// ── validateComponent ──
+
+describe('validateComponent', () => {
+  it('validates component against schema', () => {
+    const schema: TypeSchema = {
+      title: 'Money',
+      type: 'object',
+      properties: {
+        amount: { type: 'number', title: 'Amount' },
+        currency: { type: 'string', title: 'Currency' },
+      },
+    };
+    const comp: ComponentData = { $type: 'money', amount: 100, currency: 'USD' };
+    assert.equal(validateComponent(comp, schema, 'budget').length, 0);
+  });
+
+  it('reports errors with component field path', () => {
+    const schema: TypeSchema = {
+      title: 'Money',
+      type: 'object',
+      properties: {
+        amount: { type: 'number', title: 'Amount' },
+      },
+    };
+    const comp: ComponentData = { $type: 'money', amount: 'bad' };
+    const e = validateComponent(comp, schema, 'budget');
+    assert.equal(e.length, 1);
+    assert.equal(e[0].path, 'budget.amount');
+  });
+
+  it('skips null/undefined values', () => {
+    const schema: TypeSchema = {
+      title: 'Test',
+      type: 'object',
+      properties: {
+        name: { type: 'string', title: 'Name' },
+      },
+    };
+    const comp: ComponentData = { $type: 'test' }; // name missing
+    assert.equal(validateComponent(comp, schema, '').length, 0);
+  });
+});
+
+// ── addTypeValidator ──
+
+describe('addTypeValidator', () => {
+  it('extends validation with custom type', () => {
+    addTypeValidator('email', (value, _def, path, errors) => {
+      if (typeof value !== 'string' || !value.includes('@'))
+        errors.push({ path, message: 'invalid email' });
+    });
+
+    assert.equal(check('user@test.com', { type: 'email' }).length, 0);
+    const e = check('not-email', { type: 'email' });
+    assert.equal(e.length, 1);
+    assert.match(e[0].message, /invalid email/);
+  });
+});

package/src/comp/validate.ts

@@ -0,0 +1,125 @@
+// Component validation — shared between client and server
+// Type-dispatched validator tree: type check → dispatch → type-specific constraints + recurse
+
+import { AnyType, type ComponentData, getComponents, type NodeData } from '#core';
+import { resolve } from '#core/registry';
+import type { PropertySchema, TypeSchema } from '#schema/types';
+
+export type ValidationError = {
+  path: string;
+  message: string;
+};
+
+// ── Type-dispatched validator tree ──
+
+type TypeValidator = (value: unknown, def: PropertySchema, path: string, errors: ValidationError[]) => void;
+
+const typeValidators: Record<string, TypeValidator> = {
+  string(value, def, path, errors) {
+    if (typeof value !== 'string') { errors.push({ path, message: `expected string, got ${typeof value}` }); return; }
+    const d = def as any;
+    if (typeof d.minLength === 'number' && value.length < d.minLength)
+      errors.push({ path, message: `min length ${d.minLength}, got ${value.length}` });
+    if (typeof d.maxLength === 'number' && value.length > d.maxLength)
+      errors.push({ path, message: `max length ${d.maxLength}, got ${value.length}` });
+    if (typeof d.pattern === 'string' && !new RegExp(d.pattern).test(value))
+      errors.push({ path, message: `must match /${d.pattern}/` });
+    if (def.enum && !def.enum.includes(value))
+      errors.push({ path, message: `must be one of: ${def.enum.join(', ')}` });
+  },
+
+  number(value, def, path, errors) {
+    if (typeof value !== 'number') { errors.push({ path, message: `expected number, got ${typeof value}` }); return; }
+    const d = def as any;
+    if (typeof d.minimum === 'number' && value < d.minimum)
+      errors.push({ path, message: `minimum ${d.minimum}, got ${value}` });
+    if (typeof d.maximum === 'number' && value > d.maximum)
+      errors.push({ path, message: `maximum ${d.maximum}, got ${value}` });
+  },
+
+  boolean(value, _def, path, errors) {
+    if (typeof value !== 'boolean') errors.push({ path, message: `expected boolean, got ${typeof value}` });
+  },
+
+  array(value, def, path, errors) {
+    if (!Array.isArray(value)) { errors.push({ path, message: `expected array, got ${typeof value}` }); return; }
+    const d = def as any;
+    if (typeof d.minItems === 'number' && value.length < d.minItems)
+      errors.push({ path, message: `min items ${d.minItems}, got ${value.length}` });
+    if (typeof d.maxItems === 'number' && value.length > d.maxItems)
+      errors.push({ path, message: `max items ${d.maxItems}, got ${value.length}` });
+
+    if (!def.items) return;
+    const items = def.items;
+
+    for (let i = 0; i < value.length; i++) {
+      if (value[i] === undefined || value[i] === null) continue;
+      const ip = `${path}[${i}]`;
+
+      if (items.properties) {
+        if (typeof value[i] !== 'object' || value[i] === null) {
+          errors.push({ path: ip, message: `expected object, got ${typeof value[i]}` });
+        } else {
+          validateObject(value[i] as Record<string, unknown>, items.properties as Record<string, PropertySchema>, ip, errors);
+        }
+      } else if (items.type) {
+        validateValue(value[i], items as PropertySchema, ip, errors);
+      }
+    }
+  },
+
+  object(value, def, path, errors) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+      errors.push({ path, message: `expected object, got ${Array.isArray(value) ? 'array' : typeof value}` });
+      return;
+    }
+    const props = (def as any).properties as Record<string, PropertySchema> | undefined;
+    if (props) validateObject(value as Record<string, unknown>, props, path, errors);
+  },
+};
+
+// ── Extension point ──
+
+export function addTypeValidator(type: string, fn: TypeValidator): void {
+  typeValidators[type] = fn;
+}
+
+// ── Core ──
+
+export function validateValue(value: unknown, def: PropertySchema, path: string, errors: ValidationError[]): void {
+  if (!def.type) return;
+  const validator = typeValidators[def.type];
+  if (validator) validator(value, def, path, errors);
+}
+
+function validateObject(obj: Record<string, unknown>, properties: Record<string, PropertySchema>, basePath: string, errors: ValidationError[]): void {
+  for (const [prop, propDef] of Object.entries(properties)) {
+    const val = obj[prop];
+    if (val === undefined || val === null) continue;
+    validateValue(val, propDef, basePath ? `${basePath}.${prop}` : prop, errors);
+  }
+}
+
+export function validateComponent(comp: ComponentData, schema: TypeSchema, field: string): ValidationError[] {
+  if (!schema.properties) return [];
+  const errors: ValidationError[] = [];
+  const basePath = field || comp.$type;
+  validateObject(comp as unknown as Record<string, unknown>, schema.properties, basePath, errors);
+  return errors;
+}
+
+export function validateNode(node: NodeData): ValidationError[] {
+  const errors: ValidationError[] = [];
+
+  for (const [name, comp] of getComponents(node, AnyType)) {
+    const schemaHandler = resolve(comp.$type, 'schema');
+    if (!schemaHandler) continue;
+
+    const schema = (schemaHandler as () => TypeSchema)();
+    if (!schema?.properties) continue;
+
+    errors.push(...validateComponent(comp, schema, name));
+  }
+
+  return errors;
+}

package/src/comp.ts

@@ -0,0 +1 @@
+export * from './comp/index.ts';

package/src/contexts/schema/index.ts

@@ -0,0 +1,7 @@
+export type SchemaHandler = () => Record<string, unknown>;
+
+declare module '#core/context' {
+  interface ContextHandlers {
+    schema: SchemaHandler;
+  }
+}

package/src/contexts/schema.ts

@@ -0,0 +1 @@
+export * from './schema/index';