@constela/core 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -6,10 +6,16 @@
  */
 declare const BINARY_OPERATORS: readonly ["+", "-", "*", "/", "==", "!=", "<", "<=", ">", ">=", "&&", "||"];
 type BinaryOperator = (typeof BINARY_OPERATORS)[number];
-declare const UPDATE_OPERATIONS: readonly ["increment", "decrement", "push", "pop", "remove"];
+declare const UPDATE_OPERATIONS: readonly ["increment", "decrement", "push", "pop", "remove", "toggle", "merge", "replaceAt", "insertAt", "splice"];
 type UpdateOperation = (typeof UPDATE_OPERATIONS)[number];
 declare const HTTP_METHODS: readonly ["GET", "POST", "PUT", "DELETE"];
 type HttpMethod = (typeof HTTP_METHODS)[number];
+declare const PARAM_TYPES: readonly ["string", "number", "boolean", "json"];
+type ParamType = (typeof PARAM_TYPES)[number];
+interface ParamDef {
+    type: ParamType;
+    required?: boolean;
+}
 /**
  * Literal expression - represents a constant value
  */
@@ -48,7 +54,32 @@ interface NotExpr {
     expr: 'not';
     operand: Expression;
 }
-type Expression = LitExpr | StateExpr | VarExpr | BinExpr | NotExpr;
+/**
+ * Param expression - references a component parameter
+ */
+interface ParamExpr {
+    expr: 'param';
+    name: string;
+    path?: string;
+}
+/**
+ * Cond expression - conditional if/then/else
+ */
+interface CondExpr {
+    expr: 'cond';
+    if: Expression;
+    then: Expression;
+    else: Expression;
+}
+/**
+ * Get expression - property access
+ */
+interface GetExpr {
+    expr: 'get';
+    base: Expression;
+    path: string;
+}
+type Expression = LitExpr | StateExpr | VarExpr | BinExpr | NotExpr | ParamExpr | CondExpr | GetExpr;
 /**
  * Number state field
  */
@@ -70,7 +101,21 @@ interface ListField {
     type: 'list';
     initial: unknown[];
 }
-type StateField = NumberField | StringField | ListField;
+/**
+ * Boolean state field
+ */
+interface BooleanField {
+    type: 'boolean';
+    initial: boolean;
+}
+/**
+ * Object state field
+ */
+interface ObjectField {
+    type: 'object';
+    initial: Record<string, unknown>;
+}
+type StateField = NumberField | StringField | ListField | BooleanField | ObjectField;
 /**
  * Set step - sets a state field to a new value
  */
@@ -81,12 +126,31 @@ interface SetStep {
 }
 /**
  * Update step - performs an operation on a state field
+ *
+ * Operations and their required fields:
+ * - increment/decrement: Numeric operations. Optional `value` for amount (default: 1)
+ * - push: Add item to array. Requires `value`
+ * - pop: Remove last item from array. No additional fields
+ * - remove: Remove item from array by value or index. Requires `value`
+ * - toggle: Flip boolean value. No additional fields
+ * - merge: Shallow merge object. Requires `value` (object)
+ * - replaceAt: Replace array item at index. Requires `index` and `value`
+ * - insertAt: Insert item at array index. Requires `index` and `value`
+ * - splice: Delete and/or insert items. Requires `index` and `deleteCount`, optional `value` (array)
+ *
+ * @property target - The state field name to update
+ * @property operation - The update operation to perform
+ * @property value - Value for push/merge/replaceAt/insertAt/splice operations
+ * @property index - Array index for replaceAt/insertAt/splice operations
+ * @property deleteCount - Number of items to delete for splice operation
  */
 interface UpdateStep {
     do: 'update';
     target: string;
     operation: UpdateOperation;
     value?: Expression;
+    index?: Expression;
+    deleteCount?: Expression;
 }
 /**
  * Fetch step - makes an HTTP request
@@ -152,7 +216,26 @@ interface EachNode {
     key?: Expression;
     body: ViewNode;
 }
-type ViewNode = ElementNode | TextNode | IfNode | EachNode;
+/**
+ * Component node - invokes a defined component
+ */
+interface ComponentNode {
+    kind: 'component';
+    name: string;
+    props?: Record<string, Expression>;
+    children?: ViewNode[];
+}
+/**
+ * Slot node - placeholder for children in component definition
+ */
+interface SlotNode {
+    kind: 'slot';
+}
+type ViewNode = ElementNode | TextNode | IfNode | EachNode | ComponentNode | SlotNode;
+interface ComponentDef {
+    params?: Record<string, ParamDef>;
+    view: ViewNode;
+}
 /**
  * Program - the root of a Constela AST
  */
@@ -161,6 +244,7 @@ interface Program {
     state: Record<string, StateField>;
     actions: ActionDefinition[];
     view: ViewNode;
+    components?: Record<string, ComponentDef>;
 }
 type ConstelaAst = Program;
 
@@ -202,6 +286,30 @@ declare function isBinExpr(value: unknown): value is BinExpr;
  * Use the AST validator for full recursive validation instead.
  */
 declare function isNotExpr(value: unknown): value is NotExpr;
+/**
+ * Checks if value is a param expression
+ */
+declare function isParamExpr(value: unknown): value is ParamExpr;
+/**
+ * Checks if value is a cond expression
+ *
+ * Note: This performs shallow validation only - it checks that `if`, `then`, and `else`
+ * are objects but does not recursively validate they are valid Expressions.
+ * This is intentional for performance: deep validation would require traversing
+ * potentially deeply nested expression trees on every type guard call.
+ * Use the AST validator for full recursive validation instead.
+ */
+declare function isCondExpr(value: unknown): value is CondExpr;
+/**
+ * Checks if value is a get expression
+ *
+ * Note: This performs shallow validation only - it checks that `base` is
+ * an object but does not recursively validate it is a valid Expression.
+ * This is intentional for performance: deep validation would require traversing
+ * potentially deeply nested expression trees on every type guard call.
+ * Use the AST validator for full recursive validation instead.
+ */
+declare function isGetExpr(value: unknown): value is GetExpr;
 /**
  * Checks if value is any valid expression
  */
@@ -222,6 +330,14 @@ declare function isIfNode(value: unknown): value is IfNode;
  * Checks if value is an each node
  */
 declare function isEachNode(value: unknown): value is EachNode;
+/**
+ * Checks if value is a component node
+ */
+declare function isComponentNode(value: unknown): value is ComponentNode;
+/**
+ * Checks if value is a slot node
+ */
+declare function isSlotNode(value: unknown): value is SlotNode;
 /**
  * Checks if value is any valid view node
  */
@@ -254,6 +370,14 @@ declare function isStringField(value: unknown): value is StringField;
  * Checks if value is a list field
  */
 declare function isListField(value: unknown): value is ListField;
+/**
+ * Checks if value is a boolean field
+ */
+declare function isBooleanField(value: unknown): value is BooleanField;
+/**
+ * Checks if value is an object field
+ */
+declare function isObjectField(value: unknown): value is ObjectField;
 /**
  * Checks if value is any valid state field
  */
@@ -269,7 +393,7 @@ declare function isEventHandler(value: unknown): value is EventHandler;
  * This module defines error types, the ConstelaError class,
  * and factory functions for creating specific errors.
  */
-type ErrorCode = 'SCHEMA_INVALID' | 'UNDEFINED_STATE' | 'UNDEFINED_ACTION' | 'VAR_UNDEFINED' | 'DUPLICATE_ACTION' | 'UNSUPPORTED_VERSION';
+type ErrorCode = 'SCHEMA_INVALID' | 'UNDEFINED_STATE' | 'UNDEFINED_ACTION' | 'VAR_UNDEFINED' | 'DUPLICATE_ACTION' | 'UNSUPPORTED_VERSION' | 'COMPONENT_NOT_FOUND' | 'COMPONENT_PROP_MISSING' | 'COMPONENT_CYCLE' | 'COMPONENT_PROP_TYPE' | 'PARAM_UNDEFINED' | 'OPERATION_INVALID_FOR_TYPE' | 'OPERATION_MISSING_FIELD' | 'OPERATION_UNKNOWN' | 'EXPR_INVALID_BASE' | 'EXPR_INVALID_CONDITION' | 'EXPR_COND_ELSE_REQUIRED';
 /**
  * Custom error class for Constela validation errors
  */
@@ -314,6 +438,42 @@ declare function createUndefinedVarError(varName: string, path?: string): Conste
  * Creates an unsupported version error
  */
 declare function createUnsupportedVersionError(version: string): ConstelaError;
+/**
+ * Creates a component not found error
+ */
+declare function createComponentNotFoundError(name: string, path?: string): ConstelaError;
+/**
+ * Creates a missing required prop error
+ */
+declare function createComponentPropMissingError(componentName: string, propName: string, path?: string): ConstelaError;
+/**
+ * Creates a component cycle error
+ */
+declare function createComponentCycleError(cycle: string[], path?: string): ConstelaError;
+/**
+ * Creates a prop type mismatch error
+ */
+declare function createComponentPropTypeError(componentName: string, propName: string, expected: string, actual: string, path?: string): ConstelaError;
+/**
+ * Creates an undefined param reference error
+ */
+declare function createUndefinedParamError(paramName: string, path?: string): ConstelaError;
+/**
+ * Creates an operation invalid for type error
+ */
+declare function createOperationInvalidForTypeError(operation: string, stateType: string, path?: string): ConstelaError;
+/**
+ * Creates an operation missing field error
+ */
+declare function createOperationMissingFieldError(operation: string, field: string, path?: string): ConstelaError;
+/**
+ * Creates an operation unknown error
+ */
+declare function createOperationUnknownError(operation: string, path?: string): ConstelaError;
+/**
+ * Creates a cond else required error
+ */
+declare function createCondElseRequiredError(path?: string): ConstelaError;
 
 /**
  * AST Validator for Constela
@@ -372,6 +532,12 @@ declare const astSchema: {
         readonly view: {
             readonly $ref: "#/$defs/ViewNode";
         };
+        readonly components: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly $ref: "#/$defs/ComponentDef";
+            };
+        };
     };
     readonly $defs: {
         readonly Expression: {
@@ -385,6 +551,12 @@ declare const astSchema: {
                 readonly $ref: "#/$defs/BinExpr";
             }, {
                 readonly $ref: "#/$defs/NotExpr";
+            }, {
+                readonly $ref: "#/$defs/ParamExpr";
+            }, {
+                readonly $ref: "#/$defs/CondExpr";
+            }, {
+                readonly $ref: "#/$defs/GetExpr";
             }];
         };
         readonly LitExpr: {
@@ -477,6 +649,60 @@ declare const astSchema: {
                 };
             };
         };
+        readonly ParamExpr: {
+            readonly type: "object";
+            readonly required: readonly ["expr", "name"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly expr: {
+                    readonly type: "string";
+                    readonly const: "param";
+                };
+                readonly name: {
+                    readonly type: "string";
+                };
+                readonly path: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly CondExpr: {
+            readonly type: "object";
+            readonly required: readonly ["expr", "if", "then", "else"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly expr: {
+                    readonly type: "string";
+                    readonly const: "cond";
+                };
+                readonly if: {
+                    readonly $ref: "#/$defs/Expression";
+                };
+                readonly then: {
+                    readonly $ref: "#/$defs/Expression";
+                };
+                readonly else: {
+                    readonly $ref: "#/$defs/Expression";
+                };
+            };
+        };
+        readonly GetExpr: {
+            readonly type: "object";
+            readonly required: readonly ["expr", "base", "path"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly expr: {
+                    readonly type: "string";
+                    readonly const: "get";
+                };
+                readonly base: {
+                    readonly $ref: "#/$defs/Expression";
+                };
+                readonly path: {
+                    readonly type: "string";
+                };
+            };
+        };
         readonly StateField: {
             readonly oneOf: readonly [{
                 readonly $ref: "#/$defs/NumberField";
@@ -484,6 +710,10 @@ declare const astSchema: {
                 readonly $ref: "#/$defs/StringField";
             }, {
                 readonly $ref: "#/$defs/ListField";
+            }, {
+                readonly $ref: "#/$defs/BooleanField";
+            }, {
+                readonly $ref: "#/$defs/ObjectField";
             }];
         };
         readonly NumberField: {
@@ -528,6 +758,34 @@ declare const astSchema: {
                 };
             };
         };
+        readonly BooleanField: {
+            readonly type: "object";
+            readonly required: readonly ["type", "initial"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly type: {
+                    readonly type: "string";
+                    readonly const: "boolean";
+                };
+                readonly initial: {
+                    readonly type: "boolean";
+                };
+            };
+        };
+        readonly ObjectField: {
+            readonly type: "object";
+            readonly required: readonly ["type", "initial"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly type: {
+                    readonly type: "string";
+                    readonly const: "object";
+                };
+                readonly initial: {
+                    readonly type: "object";
+                };
+            };
+        };
         readonly ActionStep: {
             readonly oneOf: readonly [{
                 readonly $ref: "#/$defs/SetStep";
@@ -568,11 +826,17 @@ declare const astSchema: {
                 };
                 readonly operation: {
                     readonly type: "string";
-                    readonly enum: readonly ["increment", "decrement", "push", "pop", "remove"];
+                    readonly enum: readonly ["increment", "decrement", "push", "pop", "remove", "toggle", "merge", "replaceAt", "insertAt", "splice"];
                 };
                 readonly value: {
                     readonly $ref: "#/$defs/Expression";
                 };
+                readonly index: {
+                    readonly $ref: "#/$defs/Expression";
+                };
+                readonly deleteCount: {
+                    readonly $ref: "#/$defs/Expression";
+                };
             };
         };
         readonly FetchStep: {
@@ -652,6 +916,10 @@ declare const astSchema: {
                 readonly $ref: "#/$defs/IfNode";
             }, {
                 readonly $ref: "#/$defs/EachNode";
+            }, {
+                readonly $ref: "#/$defs/ComponentNode";
+            }, {
+                readonly $ref: "#/$defs/SlotNode";
             }];
         };
         readonly ElementNode: {
@@ -744,7 +1012,74 @@ declare const astSchema: {
                 };
             };
         };
+        readonly ComponentNode: {
+            readonly type: "object";
+            readonly required: readonly ["kind", "name"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly kind: {
+                    readonly type: "string";
+                    readonly const: "component";
+                };
+                readonly name: {
+                    readonly type: "string";
+                };
+                readonly props: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly $ref: "#/$defs/Expression";
+                    };
+                };
+                readonly children: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/ViewNode";
+                    };
+                };
+            };
+        };
+        readonly SlotNode: {
+            readonly type: "object";
+            readonly required: readonly ["kind"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly kind: {
+                    readonly type: "string";
+                    readonly const: "slot";
+                };
+            };
+        };
+        readonly ParamDef: {
+            readonly type: "object";
+            readonly required: readonly ["type"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly type: {
+                    readonly type: "string";
+                    readonly enum: readonly ["string", "number", "boolean", "json"];
+                };
+                readonly required: {
+                    readonly type: "boolean";
+                };
+            };
+        };
+        readonly ComponentDef: {
+            readonly type: "object";
+            readonly required: readonly ["view"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly params: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly $ref: "#/$defs/ParamDef";
+                    };
+                };
+                readonly view: {
+                    readonly $ref: "#/$defs/ViewNode";
+                };
+            };
+        };
     };
 };
 
-export { type ActionDefinition, type ActionStep, BINARY_OPERATORS, type BinExpr, type BinaryOperator, type ConstelaAst, ConstelaError, type EachNode, type ElementNode, type ErrorCode, type EventHandler, type Expression, type FetchStep, HTTP_METHODS, type HttpMethod, type IfNode, type ListField, type LitExpr, type NotExpr, type NumberField, type Program, type SetStep, type StateExpr, type StateField, type StringField, type TextNode, UPDATE_OPERATIONS, type UpdateOperation, type UpdateStep, type ValidationFailure, type ValidationResult, type ValidationSuccess, type VarExpr, type ViewNode, astSchema, createDuplicateActionError, createSchemaError, createUndefinedActionError, createUndefinedStateError, createUndefinedVarError, createUnsupportedVersionError, isActionStep, isBinExpr, isConstelaError, isEachNode, isElementNode, isEventHandler, isExpression, isFetchStep, isIfNode, isListField, isLitExpr, isNotExpr, isNumberField, isSetStep, isStateExpr, isStateField, isStringField, isTextNode, isUpdateStep, isVarExpr, isViewNode, validateAst };
+export { type ActionDefinition, type ActionStep, BINARY_OPERATORS, type BinExpr, type BinaryOperator, type BooleanField, type ComponentDef, type ComponentNode, type CondExpr, type ConstelaAst, ConstelaError, type EachNode, type ElementNode, type ErrorCode, type EventHandler, type Expression, type FetchStep, type GetExpr, HTTP_METHODS, type HttpMethod, type IfNode, type ListField, type LitExpr, type NotExpr, type NumberField, type ObjectField, PARAM_TYPES, type ParamDef, type ParamExpr, type ParamType, type Program, type SetStep, type SlotNode, type StateExpr, type StateField, type StringField, type TextNode, UPDATE_OPERATIONS, type UpdateOperation, type UpdateStep, type ValidationFailure, type ValidationResult, type ValidationSuccess, type VarExpr, type ViewNode, astSchema, createComponentCycleError, createComponentNotFoundError, createComponentPropMissingError, createComponentPropTypeError, createCondElseRequiredError, createDuplicateActionError, createOperationInvalidForTypeError, createOperationMissingFieldError, createOperationUnknownError, createSchemaError, createUndefinedActionError, createUndefinedParamError, createUndefinedStateError, createUndefinedVarError, createUnsupportedVersionError, isActionStep, isBinExpr, isBooleanField, isComponentNode, isCondExpr, isConstelaError, isEachNode, isElementNode, isEventHandler, isExpression, isFetchStep, isGetExpr, isIfNode, isListField, isLitExpr, isNotExpr, isNumberField, isObjectField, isParamExpr, isSetStep, isSlotNode, isStateExpr, isStateField, isStringField, isTextNode, isUpdateStep, isVarExpr, isViewNode, validateAst };

package/dist/index.js

@@ -18,9 +18,15 @@ var UPDATE_OPERATIONS = [
   "decrement",
   "push",
   "pop",
-  "remove"
+  "remove",
+  "toggle",
+  "merge",
+  "replaceAt",
+  "insertAt",
+  "splice"
 ];
 var HTTP_METHODS = ["GET", "POST", "PUT", "DELETE"];
+var PARAM_TYPES = ["string", "number", "boolean", "json"];
 
 // src/types/guards.ts
 function isObject(value) {
@@ -56,8 +62,30 @@ function isNotExpr(value) {
   if (!isObject(value["operand"])) return false;
   return true;
 }
+function isParamExpr(value) {
+  if (!isObject(value)) return false;
+  if (value["expr"] !== "param") return false;
+  if (typeof value["name"] !== "string") return false;
+  if ("path" in value && value["path"] !== void 0) {
+    if (typeof value["path"] !== "string") return false;
+  }
+  return true;
+}
+function isCondExpr(value) {
+  if (!isObject(value)) return false;
+  if (value["expr"] !== "cond") return false;
+  if (!isObject(value["if"]) || !isObject(value["then"]) || !isObject(value["else"])) return false;
+  return true;
+}
+function isGetExpr(value) {
+  if (!isObject(value)) return false;
+  if (value["expr"] !== "get") return false;
+  if (!isObject(value["base"])) return false;
+  if (typeof value["path"] !== "string") return false;
+  return true;
+}
 function isExpression(value) {
-  return isLitExpr(value) || isStateExpr(value) || isVarExpr(value) || isBinExpr(value) || isNotExpr(value);
+  return isLitExpr(value) || isStateExpr(value) || isVarExpr(value) || isBinExpr(value) || isNotExpr(value) || isParamExpr(value) || isCondExpr(value) || isGetExpr(value);
 }
 function isElementNode(value) {
   if (!isObject(value)) return false;
@@ -84,8 +112,24 @@ function isEachNode(value) {
   if (!isObject(value["body"])) return false;
   return true;
 }
+function isComponentNode(value) {
+  if (!isObject(value)) return false;
+  if (value["kind"] !== "component") return false;
+  if (typeof value["name"] !== "string") return false;
+  if ("props" in value && value["props"] !== void 0) {
+    if (!isObject(value["props"])) return false;
+  }
+  if ("children" in value && value["children"] !== void 0) {
+    if (!Array.isArray(value["children"])) return false;
+  }
+  return true;
+}
+function isSlotNode(value) {
+  if (!isObject(value)) return false;
+  return value["kind"] === "slot";
+}
 function isViewNode(value) {
-  return isElementNode(value) || isTextNode(value) || isIfNode(value) || isEachNode(value);
+  return isElementNode(value) || isTextNode(value) || isIfNode(value) || isEachNode(value) || isComponentNode(value) || isSlotNode(value);
 }
 function isSetStep(value) {
   if (!isObject(value)) return false;
@@ -132,8 +176,18 @@ function isListField(value) {
   if (value["type"] !== "list") return false;
   return Array.isArray(value["initial"]);
 }
+function isBooleanField(value) {
+  if (!isObject(value)) return false;
+  if (value["type"] !== "boolean") return false;
+  return typeof value["initial"] === "boolean";
+}
+function isObjectField(value) {
+  if (!isObject(value)) return false;
+  if (value["type"] !== "object") return false;
+  return typeof value["initial"] === "object" && value["initial"] !== null;
+}
 function isStateField(value) {
-  return isNumberField(value) || isStringField(value) || isListField(value);
+  return isNumberField(value) || isStringField(value) || isListField(value) || isBooleanField(value) || isObjectField(value);
 }
 function isEventHandler(value) {
   if (!isObject(value)) return false;
@@ -205,6 +259,69 @@ function createUnsupportedVersionError(version) {
     "/version"
   );
 }
+function createComponentNotFoundError(name, path) {
+  return new ConstelaError(
+    "COMPONENT_NOT_FOUND",
+    `Component '${name}' is not defined in components`,
+    path
+  );
+}
+function createComponentPropMissingError(componentName, propName, path) {
+  return new ConstelaError(
+    "COMPONENT_PROP_MISSING",
+    `Component '${componentName}' requires prop '${propName}'`,
+    path
+  );
+}
+function createComponentCycleError(cycle, path) {
+  return new ConstelaError(
+    "COMPONENT_CYCLE",
+    `Circular component reference detected: ${cycle.join(" -> ")}`,
+    path
+  );
+}
+function createComponentPropTypeError(componentName, propName, expected, actual, path) {
+  return new ConstelaError(
+    "COMPONENT_PROP_TYPE",
+    `Component '${componentName}' prop '${propName}' expects ${expected}, got ${actual}`,
+    path
+  );
+}
+function createUndefinedParamError(paramName, path) {
+  return new ConstelaError(
+    "PARAM_UNDEFINED",
+    `Undefined param reference: '${paramName}' is not defined in component params`,
+    path
+  );
+}
+function createOperationInvalidForTypeError(operation, stateType, path) {
+  return new ConstelaError(
+    "OPERATION_INVALID_FOR_TYPE",
+    `Operation '${operation}' is not valid for state type '${stateType}'`,
+    path
+  );
+}
+function createOperationMissingFieldError(operation, field, path) {
+  return new ConstelaError(
+    "OPERATION_MISSING_FIELD",
+    `Operation '${operation}' requires field '${field}'`,
+    path
+  );
+}
+function createOperationUnknownError(operation, path) {
+  return new ConstelaError(
+    "OPERATION_UNKNOWN",
+    `Unknown operation: '${operation}'`,
+    path
+  );
+}
+function createCondElseRequiredError(path) {
+  return new ConstelaError(
+    "EXPR_COND_ELSE_REQUIRED",
+    `Cond expression requires 'else' field`,
+    path
+  );
+}
 
 // src/schema/validator.ts
 import Ajv from "ajv";
@@ -237,6 +354,10 @@ var astSchema = {
     },
     view: {
       $ref: "#/$defs/ViewNode"
+    },
+    components: {
+      type: "object",
+      additionalProperties: { $ref: "#/$defs/ComponentDef" }
     }
   },
   $defs: {
@@ -247,7 +368,10 @@ var astSchema = {
         { $ref: "#/$defs/StateExpr" },
         { $ref: "#/$defs/VarExpr" },
         { $ref: "#/$defs/BinExpr" },
-        { $ref: "#/$defs/NotExpr" }
+        { $ref: "#/$defs/NotExpr" },
+        { $ref: "#/$defs/ParamExpr" },
+        { $ref: "#/$defs/CondExpr" },
+        { $ref: "#/$defs/GetExpr" }
       ]
     },
     LitExpr: {
@@ -309,12 +433,45 @@ var astSchema = {
         operand: { $ref: "#/$defs/Expression" }
       }
     },
+    ParamExpr: {
+      type: "object",
+      required: ["expr", "name"],
+      additionalProperties: false,
+      properties: {
+        expr: { type: "string", const: "param" },
+        name: { type: "string" },
+        path: { type: "string" }
+      }
+    },
+    CondExpr: {
+      type: "object",
+      required: ["expr", "if", "then", "else"],
+      additionalProperties: false,
+      properties: {
+        expr: { type: "string", const: "cond" },
+        if: { $ref: "#/$defs/Expression" },
+        then: { $ref: "#/$defs/Expression" },
+        else: { $ref: "#/$defs/Expression" }
+      }
+    },
+    GetExpr: {
+      type: "object",
+      required: ["expr", "base", "path"],
+      additionalProperties: false,
+      properties: {
+        expr: { type: "string", const: "get" },
+        base: { $ref: "#/$defs/Expression" },
+        path: { type: "string" }
+      }
+    },
     // ==================== State Fields ====================
     StateField: {
       oneOf: [
         { $ref: "#/$defs/NumberField" },
         { $ref: "#/$defs/StringField" },
-        { $ref: "#/$defs/ListField" }
+        { $ref: "#/$defs/ListField" },
+        { $ref: "#/$defs/BooleanField" },
+        { $ref: "#/$defs/ObjectField" }
       ]
     },
     NumberField: {
@@ -344,6 +501,24 @@ var astSchema = {
         initial: { type: "array" }
       }
     },
+    BooleanField: {
+      type: "object",
+      required: ["type", "initial"],
+      additionalProperties: false,
+      properties: {
+        type: { type: "string", const: "boolean" },
+        initial: { type: "boolean" }
+      }
+    },
+    ObjectField: {
+      type: "object",
+      required: ["type", "initial"],
+      additionalProperties: false,
+      properties: {
+        type: { type: "string", const: "object" },
+        initial: { type: "object" }
+      }
+    },
     // ==================== Action Steps ====================
     ActionStep: {
       oneOf: [
@@ -371,9 +546,11 @@ var astSchema = {
         target: { type: "string" },
         operation: {
           type: "string",
-          enum: ["increment", "decrement", "push", "pop", "remove"]
+          enum: ["increment", "decrement", "push", "pop", "remove", "toggle", "merge", "replaceAt", "insertAt", "splice"]
         },
-        value: { $ref: "#/$defs/Expression" }
+        value: { $ref: "#/$defs/Expression" },
+        index: { $ref: "#/$defs/Expression" },
+        deleteCount: { $ref: "#/$defs/Expression" }
       }
     },
     FetchStep: {
@@ -429,7 +606,9 @@ var astSchema = {
         { $ref: "#/$defs/ElementNode" },
         { $ref: "#/$defs/TextNode" },
         { $ref: "#/$defs/IfNode" },
-        { $ref: "#/$defs/EachNode" }
+        { $ref: "#/$defs/EachNode" },
+        { $ref: "#/$defs/ComponentNode" },
+        { $ref: "#/$defs/SlotNode" }
       ]
     },
     ElementNode: {
@@ -486,6 +665,56 @@ var astSchema = {
         key: { $ref: "#/$defs/Expression" },
         body: { $ref: "#/$defs/ViewNode" }
       }
+    },
+    ComponentNode: {
+      type: "object",
+      required: ["kind", "name"],
+      additionalProperties: false,
+      properties: {
+        kind: { type: "string", const: "component" },
+        name: { type: "string" },
+        props: {
+          type: "object",
+          additionalProperties: { $ref: "#/$defs/Expression" }
+        },
+        children: {
+          type: "array",
+          items: { $ref: "#/$defs/ViewNode" }
+        }
+      }
+    },
+    SlotNode: {
+      type: "object",
+      required: ["kind"],
+      additionalProperties: false,
+      properties: {
+        kind: { type: "string", const: "slot" }
+      }
+    },
+    // ==================== Component Definition ====================
+    ParamDef: {
+      type: "object",
+      required: ["type"],
+      additionalProperties: false,
+      properties: {
+        type: {
+          type: "string",
+          enum: ["string", "number", "boolean", "json"]
+        },
+        required: { type: "boolean" }
+      }
+    },
+    ComponentDef: {
+      type: "object",
+      required: ["view"],
+      additionalProperties: false,
+      properties: {
+        params: {
+          type: "object",
+          additionalProperties: { $ref: "#/$defs/ParamDef" }
+        },
+        view: { $ref: "#/$defs/ViewNode" }
+      }
     }
   }
 };
@@ -500,10 +729,11 @@ var validate = ajv.compile(astSchema);
 function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var VALID_VIEW_KINDS = ["element", "text", "if", "each"];
-var VALID_EXPR_TYPES = ["lit", "state", "var", "bin", "not"];
+var VALID_VIEW_KINDS = ["element", "text", "if", "each", "component", "slot"];
+var VALID_EXPR_TYPES = ["lit", "state", "var", "bin", "not", "param"];
+var VALID_PARAM_TYPES = ["string", "number", "boolean", "json"];
 var VALID_ACTION_TYPES = ["set", "update", "fetch"];
-var VALID_STATE_TYPES = ["number", "string", "list"];
+var VALID_STATE_TYPES = ["number", "string", "list", "boolean", "object"];
 var VALID_BIN_OPS = BINARY_OPERATORS;
 var VALID_UPDATE_OPS = UPDATE_OPERATIONS;
 var VALID_HTTP_METHODS = HTTP_METHODS;
@@ -516,7 +746,7 @@ function validateViewNode(node, path) {
     return { path: path + "/kind", message: "kind is required" };
   }
   if (!VALID_VIEW_KINDS.includes(kind)) {
-    return { path: path + "/kind", message: "must be one of: element, text, if, each" };
+    return { path: path + "/kind", message: "must be one of: element, text, if, each, component, slot" };
   }
   switch (kind) {
     case "element":
@@ -579,6 +809,25 @@ function validateViewNode(node, path) {
         if (bodyError) return bodyError;
       }
       break;
+    case "component":
+      if (typeof node["name"] !== "string") {
+        return { path: path + "/name", message: "name is required" };
+      }
+      if (node["props"] !== void 0 && isObject2(node["props"])) {
+        for (const [propName, propValue] of Object.entries(node["props"])) {
+          const error = validateExpression(propValue, path + "/props/" + propName);
+          if (error) return error;
+        }
+      }
+      if (Array.isArray(node["children"])) {
+        for (let i = 0; i < node["children"].length; i++) {
+          const error = validateViewNode(node["children"][i], path + "/children/" + i);
+          if (error) return error;
+        }
+      }
+      break;
+    case "slot":
+      break;
   }
   return null;
 }
@@ -591,7 +840,7 @@ function validateExpression(expr, path) {
     return { path: path + "/expr", message: "expr is required" };
   }
   if (!VALID_EXPR_TYPES.includes(exprType)) {
-    return { path: path + "/expr", message: "must be one of: lit, state, var, bin, not" };
+    return { path: path + "/expr", message: "must be one of: lit, state, var, bin, not, param" };
   }
   switch (exprType) {
     case "lit":
@@ -630,6 +879,14 @@ function validateExpression(expr, path) {
         return { path: path + "/operand", message: "operand is required" };
       }
       return validateExpression(expr["operand"], path + "/operand");
+    case "param":
+      if (typeof expr["name"] !== "string") {
+        return { path: path + "/name", message: "name is required" };
+      }
+      if ("path" in expr && typeof expr["path"] !== "string") {
+        return { path: path + "/path", message: "path must be a string" };
+      }
+      break;
   }
   return null;
 }
@@ -718,7 +975,50 @@ function validateStateField(field, path) {
         return { path: path + "/initial", message: "must be an array" };
       }
       break;
+    case "boolean":
+      if (typeof field["initial"] !== "boolean") {
+        return { path: path + "/initial", message: "must be a boolean" };
+      }
+      break;
+    case "object":
+      if (!isObject2(field["initial"])) {
+        return { path: path + "/initial", message: "must be an object" };
+      }
+      break;
+  }
+  return null;
+}
+function validateParamDef(param, path) {
+  if (!isObject2(param)) {
+    return { path, message: "must be an object" };
+  }
+  const paramType = param["type"];
+  if (typeof paramType !== "string") {
+    return { path: path + "/type", message: "type is required" };
+  }
+  if (!VALID_PARAM_TYPES.includes(paramType)) {
+    return { path: path + "/type", message: "must be one of: string, number, boolean, json" };
+  }
+  if ("required" in param && typeof param["required"] !== "boolean") {
+    return { path: path + "/required", message: "required must be a boolean" };
+  }
+  return null;
+}
+function validateComponentDef(def, path) {
+  if (!isObject2(def)) {
+    return { path, message: "must be an object" };
+  }
+  if (!("view" in def)) {
+    return { path: path + "/view", message: "view is required" };
+  }
+  if ("params" in def && isObject2(def["params"])) {
+    for (const [paramName, paramDef] of Object.entries(def["params"])) {
+      const error = validateParamDef(paramDef, path + "/params/" + paramName);
+      if (error) return error;
+    }
   }
+  const viewError = validateViewNode(def["view"], path + "/view");
+  if (viewError) return viewError;
   return null;
 }
 function customValidateAst(input) {
@@ -743,6 +1043,12 @@ function customValidateAst(input) {
     const error = validateViewNode(input["view"], "/view");
     if (error) return error;
   }
+  if ("components" in input && isObject2(input["components"])) {
+    for (const [name, def] of Object.entries(input["components"])) {
+      const error = validateComponentDef(def, "/components/" + name);
+      if (error) return error;
+    }
+  }
   return null;
 }
 function findTopLevelRequiredError(errors) {
@@ -943,28 +1249,45 @@ export {
   BINARY_OPERATORS,
   ConstelaError,
   HTTP_METHODS,
+  PARAM_TYPES,
   UPDATE_OPERATIONS,
   astSchema,
+  createComponentCycleError,
+  createComponentNotFoundError,
+  createComponentPropMissingError,
+  createComponentPropTypeError,
+  createCondElseRequiredError,
   createDuplicateActionError,
+  createOperationInvalidForTypeError,
+  createOperationMissingFieldError,
+  createOperationUnknownError,
   createSchemaError,
   createUndefinedActionError,
+  createUndefinedParamError,
   createUndefinedStateError,
   createUndefinedVarError,
   createUnsupportedVersionError,
   isActionStep,
   isBinExpr,
+  isBooleanField,
+  isComponentNode,
+  isCondExpr,
   isConstelaError,
   isEachNode,
   isElementNode,
   isEventHandler,
   isExpression,
   isFetchStep,
+  isGetExpr,
   isIfNode,
   isListField,
   isLitExpr,
   isNotExpr,
   isNumberField,
+  isObjectField,
+  isParamExpr,
   isSetStep,
+  isSlotNode,
   isStateExpr,
   isStateField,
   isStringField,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constela/core",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Core types, schema, and validator for Constela UI framework",
   "type": "module",
   "main": "./dist/index.js",