@constela/core 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -6,7 +6,7 @@
  */
 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];
@@ -62,7 +62,24 @@ interface ParamExpr {
     name: string;
     path?: string;
 }
-type Expression = LitExpr | StateExpr | VarExpr | BinExpr | NotExpr | ParamExpr;
+/**
+ * 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
  */
@@ -84,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
  */
@@ -95,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
@@ -240,6 +290,26 @@ 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
  */
@@ -300,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
  */
@@ -315,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' | 'COMPONENT_NOT_FOUND' | 'COMPONENT_PROP_MISSING' | 'COMPONENT_CYCLE' | 'COMPONENT_PROP_TYPE' | 'PARAM_UNDEFINED';
+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
  */
@@ -380,6 +458,22 @@ declare function createComponentPropTypeError(componentName: string, propName: s
  * 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
@@ -459,6 +553,10 @@ declare const astSchema: {
                 readonly $ref: "#/$defs/NotExpr";
             }, {
                 readonly $ref: "#/$defs/ParamExpr";
+            }, {
+                readonly $ref: "#/$defs/CondExpr";
+            }, {
+                readonly $ref: "#/$defs/GetExpr";
             }];
         };
         readonly LitExpr: {
@@ -568,6 +666,43 @@ declare const astSchema: {
                 };
             };
         };
+        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";
@@ -575,6 +710,10 @@ declare const astSchema: {
                 readonly $ref: "#/$defs/StringField";
             }, {
                 readonly $ref: "#/$defs/ListField";
+            }, {
+                readonly $ref: "#/$defs/BooleanField";
+            }, {
+                readonly $ref: "#/$defs/ObjectField";
             }];
         };
         readonly NumberField: {
@@ -619,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";
@@ -659,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: {
@@ -909,4 +1082,4 @@ declare const astSchema: {
     };
 };
 
-export { type ActionDefinition, type ActionStep, BINARY_OPERATORS, type BinExpr, type BinaryOperator, type ComponentDef, type ComponentNode, 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, 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, createDuplicateActionError, createSchemaError, createUndefinedActionError, createUndefinedParamError, createUndefinedStateError, createUndefinedVarError, createUnsupportedVersionError, isActionStep, isBinExpr, isComponentNode, isConstelaError, isEachNode, isElementNode, isEventHandler, isExpression, isFetchStep, isIfNode, isListField, isLitExpr, isNotExpr, isNumberField, isParamExpr, isSetStep, isSlotNode, 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,7 +18,12 @@ 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"];
@@ -66,8 +71,21 @@ function isParamExpr(value) {
   }
   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) || isParamExpr(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;
@@ -158,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;
@@ -266,6 +294,34 @@ function createUndefinedParamError(paramName, path) {
     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";
@@ -313,7 +369,9 @@ var astSchema = {
         { $ref: "#/$defs/VarExpr" },
         { $ref: "#/$defs/BinExpr" },
         { $ref: "#/$defs/NotExpr" },
-        { $ref: "#/$defs/ParamExpr" }
+        { $ref: "#/$defs/ParamExpr" },
+        { $ref: "#/$defs/CondExpr" },
+        { $ref: "#/$defs/GetExpr" }
       ]
     },
     LitExpr: {
@@ -385,12 +443,35 @@ var astSchema = {
         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: {
@@ -420,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: [
@@ -447,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: {
@@ -632,7 +733,7 @@ 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;
@@ -874,6 +975,16 @@ 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;
 }
@@ -1145,7 +1256,11 @@ export {
   createComponentNotFoundError,
   createComponentPropMissingError,
   createComponentPropTypeError,
+  createCondElseRequiredError,
   createDuplicateActionError,
+  createOperationInvalidForTypeError,
+  createOperationMissingFieldError,
+  createOperationUnknownError,
   createSchemaError,
   createUndefinedActionError,
   createUndefinedParamError,
@@ -1154,18 +1269,22 @@ export {
   createUnsupportedVersionError,
   isActionStep,
   isBinExpr,
+  isBooleanField,
   isComponentNode,
+  isCondExpr,
   isConstelaError,
   isEachNode,
   isElementNode,
   isEventHandler,
   isExpression,
   isFetchStep,
+  isGetExpr,
   isIfNode,
   isListField,
   isLitExpr,
   isNotExpr,
   isNumberField,
+  isObjectField,
   isParamExpr,
   isSetStep,
   isSlotNode,

package/package.json

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