meno-core 1.0.0

package/lib/shared/paths/index.ts

@@ -0,0 +1,48 @@
+/**
+ * Path Utilities
+ * Unified path handling system
+ * 
+ * This module provides a single source of truth for path operations.
+ * All path-related functionality is consolidated here.
+ */
+
+// Export types
+export type { Path } from './Path';
+
+// Export constants
+export {
+  ROOT_STRING,
+  ROOT_0_STRING,
+  CHILDREN_SEPARATOR,
+} from './Path';
+
+// Export validators
+export {
+  validatePath,
+  isRootPath,
+  InvalidPathError,
+  PathConversionError,
+} from './PathValidator';
+
+// Export converters
+export {
+  normalizePathInput,
+  pathToString,
+  stringToPath,
+  pathToLegacyString,
+  domPathStringToTreePath,
+  treePathToDomPathString,
+} from './PathConverter';
+
+// Export utilities
+export {
+  getParentPath,
+  getChildPath,
+  isAncestorPath,
+  getPathDepth,
+  buildParentPaths,
+  pathsEqual,
+  convertPagePathToComponentPath,
+  convertComponentPathToPagePath,
+} from './PathUtils';
+

package/lib/shared/propResolver.test.ts

@@ -0,0 +1,639 @@
+import { test, expect, describe, beforeEach } from "bun:test";
+import { 
+  resolveComponentProps,
+  resolvePropsFromDefinition 
+} from "./propResolver";
+import type { StructuredComponentDefinition, ComponentNode } from "./types";
+
+describe("Prop Resolver - resolveComponentProps", () => {
+  describe("Default values", () => {
+    test("should apply default value when prop not provided", () => {
+      const propDefs = {
+        variant: {
+          type: "select",
+          default: "primary"
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.variant).toBe("primary");
+    });
+
+    test("should override default with passed prop", () => {
+      const propDefs = {
+        variant: {
+          type: "select",
+          default: "primary"
+        }
+      };
+      const passedProps = { variant: "secondary" };
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.variant).toBe("secondary");
+    });
+
+    test("should handle undefined passed prop value (should use default)", () => {
+      const propDefs = {
+        variant: {
+          type: "select",
+          default: "primary"
+        }
+      };
+      const passedProps = { variant: undefined };
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.variant).toBe("primary");
+    });
+
+    test("should apply multiple defaults", () => {
+      const propDefs = {
+        variant: {
+          type: "select",
+          default: "primary"
+        },
+        size: {
+          type: "select",
+          default: "medium"
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.variant).toBe("primary");
+      expect(result.size).toBe("medium");
+    });
+
+    test("should handle null default value", () => {
+      const propDefs = {
+        optional: {
+          type: "select",
+          default: null
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.optional).toBeNull();
+    });
+  });
+
+  describe("Prop types", () => {
+    test("should handle select type with default", () => {
+      const propDefs = {
+        variant: {
+          type: "select",
+          options: ["primary", "secondary"],
+          default: "primary"
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.variant).toBe("primary");
+    });
+
+    test("should handle boolean type with default true", () => {
+      const propDefs = {
+        disabled: {
+          type: "boolean",
+          default: true
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.disabled).toBe(true);
+    });
+
+    test("should handle boolean type with default false", () => {
+      const propDefs = {
+        disabled: {
+          type: "boolean",
+          default: false
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.disabled).toBe(false);
+    });
+
+    test("should handle slot type with default", () => {
+      const propDefs = {
+        children: {
+          type: "slot",
+          default: "Click me"
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.children).toBe("Click me");
+    });
+
+    test("should handle props without defaults", () => {
+      const propDefs = {
+        customProp: {
+          type: "string"
+          // No default
+        }
+      };
+      const passedProps = { customProp: "value" };
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.customProp).toBe("value");
+    });
+
+    test("should return undefined for props without defaults when not passed", () => {
+      const propDefs = {
+        customProp: {
+          type: "string"
+          // No default
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.customProp).toBeUndefined();
+    });
+  });
+
+  describe("Children handling", () => {
+    test("should use passed children when provided", () => {
+      const propDefs = {
+        children: {
+          type: "slot",
+          default: "Default text"
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = ["Custom text"];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.children).toEqual(["Custom text"]);
+    });
+
+    test("should use default children when no children provided", () => {
+      const propDefs = {
+        children: {
+          type: "slot",
+          default: "Default text"
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.children).toBe("Default text");
+    });
+
+    test("should use default children when children array is empty", () => {
+      const propDefs = {
+        children: {
+          type: "slot",
+          default: "Click me"
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.children).toBe("Click me");
+    });
+
+    test("should handle empty children array when no default", () => {
+      const propDefs = {
+        children: {
+          type: "slot"
+          // No default
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.children).toBeUndefined();
+    });
+
+    test("should handle children with multiple elements", () => {
+      const propDefs = {
+        children: {
+          type: "slot",
+          default: "Default"
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = [
+        { type: "span", children: ["First"] },
+        { type: "span", children: ["Second"] }
+      ];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(Array.isArray(result.children)).toBe(true);
+      expect((result.children as ComponentNode[]).length).toBe(2);
+    });
+
+    test("should handle string children", () => {
+      const propDefs = {
+        children: {
+          type: "slot",
+          default: "Default"
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = "String child";
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      // String children are not arrays, so default is used
+      // (Implementation only uses passed children if Array.isArray(children) && children.length > 0)
+      expect(result.children).toBe("Default");
+    });
+
+    test("should handle null children", () => {
+      const propDefs = {
+        children: {
+          type: "slot",
+          default: "Default"
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = null;
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      // null is not an array with length > 0, so should use default
+      expect(result.children).toBe("Default");
+    });
+  });
+
+  describe("Mixed scenarios", () => {
+    test("should resolve Button component props (from Button.json example)", () => {
+      const propDefs = {
+        variant: {
+          type: "select",
+          options: ["primary", "secondary"],
+          default: "primary"
+        },
+        children: {
+          type: "slot",
+          default: "Click me"
+        },
+        size: {
+          type: "select",
+          default: "medium",
+          options: ["medium", "large"]
+        }
+      };
+      const passedProps = { variant: "secondary" };
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.variant).toBe("secondary"); // Overridden
+      expect(result.children).toBe("Click me"); // Default used
+      expect(result.size).toBe("medium"); // Default used
+    });
+
+    test("should resolve Button component with all props provided", () => {
+      const propDefs = {
+        variant: {
+          type: "select",
+          default: "primary"
+        },
+        children: {
+          type: "slot",
+          default: "Click me"
+        },
+        size: {
+          type: "select",
+          default: "medium"
+        }
+      };
+      const passedProps = { variant: "secondary", size: "large" };
+      const children: ComponentNode['children'] = ["Custom Button"];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.variant).toBe("secondary");
+      expect(result.children).toEqual(["Custom Button"]);
+      expect(result.size).toBe("large");
+    });
+
+    test("should handle props with different types mixed", () => {
+      const propDefs = {
+        title: {
+          type: "string",
+          default: "Default Title"
+        },
+        count: {
+          type: "number",
+          default: 0
+        },
+        isActive: {
+          type: "boolean",
+          default: false
+        }
+      };
+      const passedProps = { count: 10 };
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.title).toBe("Default Title");
+      expect(result.count).toBe(10);
+      expect(result.isActive).toBe(false);
+    });
+  });
+
+  describe("Edge cases", () => {
+    test("should handle empty propDefs object", () => {
+      const propDefs = {};
+      const passedProps = {};
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(Object.keys(result).length).toBe(0);
+    });
+
+    test("should handle propDefs with invalid structure", () => {
+      const propDefs = {
+        invalid: null as any,
+        valid: {
+          type: "string",
+          default: "value"
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      // Should skip invalid propDefs and only process valid ones
+      expect(result.valid).toBe("value");
+      expect(result.invalid).toBeUndefined();
+    });
+
+    test("should handle propDefs without 'default' key", () => {
+      const propDefs = {
+        noDefault: {
+          type: "string"
+          // No 'default' key
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.noDefault).toBeUndefined();
+    });
+
+    test("should preserve passed props that are not in propDefs", () => {
+      const propDefs = {
+        variant: {
+          type: "select",
+          default: "primary"
+        }
+      };
+      const passedProps = {
+        variant: "secondary",
+        extraProp: "extra value"
+      };
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolveComponentProps({
+        propDefs,
+        passedProps,
+        children
+      });
+      
+      expect(result.variant).toBe("secondary");
+      // Extra props are now preserved for backward compatibility (with validation)
+      expect(result.extraProp).toBe("extra value");
+    });
+  });
+});
+
+describe("Prop Resolver - resolvePropsFromDefinition", () => {
+  describe("Basic usage", () => {
+    test("should resolve props from structured component definition", () => {
+      const componentDef: StructuredComponentDefinition = {
+        interface: {
+          variant: {
+            type: "select",
+            default: "primary"
+          }
+        }
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolvePropsFromDefinition(componentDef, passedProps, children);
+      
+      expect(result.variant).toBe("primary");
+    });
+
+    test("should handle missing interface", () => {
+      const componentDef: StructuredComponentDefinition = {
+        // No interface
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolvePropsFromDefinition(componentDef, passedProps, children);
+      
+      expect(Object.keys(result).length).toBe(0);
+    });
+
+    test("should handle empty interface", () => {
+      const componentDef: StructuredComponentDefinition = {
+        interface: {}
+      };
+      const passedProps = {};
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolvePropsFromDefinition(componentDef, passedProps, children);
+      
+      expect(Object.keys(result).length).toBe(0);
+    });
+
+    test("should use passed props and children", () => {
+      const componentDef: StructuredComponentDefinition = {
+        interface: {
+          variant: {
+            type: "select",
+            default: "primary"
+          },
+          children: {
+            type: "slot",
+            default: "Default"
+          }
+        }
+      };
+      const passedProps = { variant: "secondary" };
+      const children: ComponentNode['children'] = ["Custom"];
+      
+      const result = resolvePropsFromDefinition(componentDef, passedProps, children);
+      
+      expect(result.variant).toBe("secondary");
+      expect(result.children).toEqual(["Custom"]);
+    });
+  });
+
+  describe("Integration with Button.json structure", () => {
+    test("should resolve Button component props correctly", () => {
+      const componentDef: StructuredComponentDefinition = {
+        interface: {
+          variant: {
+            type: "select",
+            options: ["primary", "secondary"],
+            default: "primary"
+          },
+          children: {
+            type: "slot",
+            default: "Click me"
+          },
+          size: {
+            type: "select",
+            default: "medium",
+            options: ["medium", "large"]
+          }
+        }
+      };
+      const passedProps = { variant: "secondary" };
+      const children: ComponentNode['children'] = [];
+      
+      const result = resolvePropsFromDefinition(componentDef, passedProps, children);
+      
+      expect(result.variant).toBe("secondary");
+      expect(result.children).toBe("Click me");
+      expect(result.size).toBe("medium");
+    });
+  });
+});