npm - @zenithbuild/core - Versions diffs - 0.1.0 - Mend

@zenithbuild/core 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (101) hide show

package/.eslintignore +15 -0
package/.gitattributes +2 -0
package/.github/ISSUE_TEMPLATE/compiler-errors-for-invalid-state-declarations.md +25 -0
package/.github/ISSUE_TEMPLATE/new_ticket.yaml +34 -0
package/.github/pull_request_template.md +15 -0
package/.github/workflows/discord-changelog.yml +141 -0
package/.github/workflows/discord-notify.yml +242 -0
package/.github/workflows/discord-version.yml +195 -0
package/.prettierignore +13 -0
package/.prettierrc +21 -0
package/.zen.d.ts +15 -0
package/LICENSE +21 -0
package/README.md +55 -0
package/app/components/Button.zen +46 -0
package/app/components/Link.zen +11 -0
package/app/favicon.ico +0 -0
package/app/layouts/Main.zen +59 -0
package/app/pages/about.zen +23 -0
package/app/pages/blog/[id].zen +53 -0
package/app/pages/blog/index.zen +32 -0
package/app/pages/dynamic-dx.zen +712 -0
package/app/pages/dynamic-primitives.zen +453 -0
package/app/pages/index.zen +154 -0
package/app/pages/navigation-demo.zen +229 -0
package/app/pages/posts/[...slug].zen +61 -0
package/app/pages/primitives-demo.zen +273 -0
package/assets/logos/0E3B5DDD-605C-4839-BB2E-DFCA8ADC9604.PNG +0 -0
package/assets/logos/760971E5-79A1-44F9-90B9-925DF30F4278.PNG +0 -0
package/assets/logos/8A06ED80-9ED2-4689-BCBD-13B2E95EE8E4.JPG +0 -0
package/assets/logos/C691FF58-ED13-4E8D-B6A3-02E835849340.PNG +0 -0
package/assets/logos/C691FF58-ED13-4E8D-B6A3-02E835849340.svg +601 -0
package/assets/logos/README.md +54 -0
package/assets/logos/zen.icns +0 -0
package/bun.lock +39 -0
package/compiler/README.md +380 -0
package/compiler/errors/compilerError.ts +24 -0
package/compiler/finalize/finalizeOutput.ts +163 -0
package/compiler/finalize/generateFinalBundle.ts +82 -0
package/compiler/index.ts +44 -0
package/compiler/ir/types.ts +83 -0
package/compiler/legacy/binding.ts +254 -0
package/compiler/legacy/bindings.ts +338 -0
package/compiler/legacy/component-process.ts +1208 -0
package/compiler/legacy/component.ts +301 -0
package/compiler/legacy/event.ts +50 -0
package/compiler/legacy/expression.ts +1149 -0
package/compiler/legacy/mutation.ts +280 -0
package/compiler/legacy/parse.ts +299 -0
package/compiler/legacy/split.ts +608 -0
package/compiler/legacy/types.ts +32 -0
package/compiler/output/types.ts +34 -0
package/compiler/parse/detectMapExpressions.ts +102 -0
package/compiler/parse/parseScript.ts +22 -0
package/compiler/parse/parseTemplate.ts +425 -0
package/compiler/parse/parseZenFile.ts +66 -0
package/compiler/parse/trackLoopContext.ts +82 -0
package/compiler/runtime/dataExposure.ts +291 -0
package/compiler/runtime/generateDOM.ts +144 -0
package/compiler/runtime/generateHydrationBundle.ts +383 -0
package/compiler/runtime/hydration.ts +309 -0
package/compiler/runtime/navigation.ts +432 -0
package/compiler/runtime/thinRuntime.ts +160 -0
package/compiler/runtime/transformIR.ts +256 -0
package/compiler/runtime/wrapExpression.ts +84 -0
package/compiler/runtime/wrapExpressionWithLoop.ts +77 -0
package/compiler/spa-build.ts +1000 -0
package/compiler/test/validate-test.ts +104 -0
package/compiler/transform/generateBindings.ts +47 -0
package/compiler/transform/generateHTML.ts +28 -0
package/compiler/transform/transformNode.ts +126 -0
package/compiler/transform/transformTemplate.ts +38 -0
package/compiler/validate/validateExpressions.ts +168 -0
package/core/index.ts +135 -0
package/core/lifecycle/index.ts +49 -0
package/core/lifecycle/zen-mount.ts +182 -0
package/core/lifecycle/zen-unmount.ts +88 -0
package/core/reactivity/index.ts +54 -0
package/core/reactivity/tracking.ts +167 -0
package/core/reactivity/zen-batch.ts +57 -0
package/core/reactivity/zen-effect.ts +139 -0
package/core/reactivity/zen-memo.ts +146 -0
package/core/reactivity/zen-ref.ts +52 -0
package/core/reactivity/zen-signal.ts +121 -0
package/core/reactivity/zen-state.ts +180 -0
package/core/reactivity/zen-untrack.ts +44 -0
package/docs/COMMENTS.md +111 -0
package/docs/COMMITS.md +36 -0
package/docs/CONTRIBUTING.md +116 -0
package/docs/STYLEGUIDE.md +62 -0
package/package.json +44 -0
package/router/index.ts +76 -0
package/router/manifest.ts +314 -0
package/router/navigation/ZenLink.zen +231 -0
package/router/navigation/index.ts +78 -0
package/router/navigation/zen-link.ts +584 -0
package/router/runtime.ts +458 -0
package/router/types.ts +168 -0
package/runtime/build.ts +17 -0
package/runtime/serve.ts +93 -0
package/scripts/webhook-proxy.ts +213 -0
package/tsconfig.json +28 -0

package/compiler/finalize/generateFinalBundle.ts ADDED Viewed

@@ -0,0 +1,82 @@
+/**
+ * Generate Final Bundle
+ *
+ * Phase 8/9/10: Generate final browser-ready bundle
+ *
+ * Combines:
+ * - Compiled HTML
+ * - Runtime JS
+ * - Expression functions
+ * - Event bindings
+ * - Style injection
+ */
+import type { FinalizedOutput } from './finalizeOutput'
+import type { RuntimeCode } from '../runtime/transformIR'
+/**
+ * Generate final bundle code
+ *
+ * This is the complete JavaScript bundle that will execute in the browser.
+ * All expressions are pre-compiled - no template parsing at runtime.
+ */
+export function generateFinalBundle(finalized: FinalizedOutput): string {
+  return `// Zenith Compiled Bundle (Phase 8/9/10)
+// Generated at compile time - no .zen parsing in browser
+// All expressions are pre-compiled - deterministic output
+${finalized.js}
+// Bundle complete - ready for browser execution
+`
+}
+/**
+ * Generate HTML with inline script
+ */
+export function generateHTMLWithScript(
+  html: string,
+  jsBundle: string,
+  styles: string[]
+): string {
+  // Inject styles as <style> tags
+  const styleTags = styles.map(style => `<style>${escapeHTML(style)}</style>`).join('\n')
+  // Inject JS bundle as inline script
+  const scriptTag = `<script>${jsBundle}</script>`
+  // Find </head> or <body> to inject styles
+  // Find </body> to inject script
+  let result = html
+  if (styleTags) {
+    if (result.includes('</head>')) {
+      result = result.replace('</head>', `${styleTags}\n</head>`)
+    } else if (result.includes('<body')) {
+      result = result.replace('<body', `${styleTags}\n<body`)
+    }
+  }
+  if (scriptTag) {
+    if (result.includes('</body>')) {
+      result = result.replace('</body>', `${scriptTag}\n</body>`)
+    } else {
+      result += scriptTag
+    }
+  }
+  return result
+}
+/**
+ * Escape HTML for safe embedding
+ */
+function escapeHTML(str: string): string {
+  return str
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#039;')
+}

package/compiler/index.ts ADDED Viewed

@@ -0,0 +1,44 @@
+/**
+ * Zenith Compiler
+ *
+ * Phase 1: Parse & Extract
+ * Phase 2: Transform IR → Static HTML + Runtime Bindings
+ * Phase 8/9/10: Finalize Output with Validation
+ *
+ * This compiler observes .zen files, extracts their structure,
+ * transforms them into static HTML with explicit bindings,
+ * and validates/finalizes output for browser execution.
+ */
+import { parseZenFile } from './parse/parseZenFile'
+import { transformTemplate } from './transform/transformTemplate'
+import { finalizeOutputOrThrow } from './finalize/finalizeOutput'
+import type { ZenIR } from './ir/types'
+import type { CompiledTemplate } from './output/types'
+import type { FinalizedOutput } from './finalize/finalizeOutput'
+/**
+ * Compile a .zen file into IR and CompiledTemplate
+ *
+ * Phase 1: Parses and extracts structure
+ * Phase 2: Transforms IR into static HTML with bindings
+ * Phase 8/9/10: Validates and finalizes output
+ */
+export function compileZen(filePath: string): {
+  ir: ZenIR
+  compiled: CompiledTemplate
+  finalized?: FinalizedOutput
+} {
+  const ir = parseZenFile(filePath)
+  const compiled = transformTemplate(ir)
+  // Phase 8/9/10: Finalize output with validation
+  // This ensures build fails on invalid expressions
+  try {
+    const finalized = finalizeOutputOrThrow(ir, compiled)
+    return { ir, compiled, finalized }
+  } catch (error: any) {
+    // Re-throw with context
+    throw new Error(`Failed to finalize output for ${filePath}:\n${error.message}`)
+  }
+}

package/compiler/ir/types.ts ADDED Viewed

@@ -0,0 +1,83 @@
+/**
+ * Zenith Intermediate Representation (IR)
+ *
+ * Phase 1: Parse & Extract
+ * This IR represents the parsed structure of a .zen file
+ * without any runtime execution or transformation.
+ */
+export type ZenIR = {
+  filePath: string
+  template: TemplateIR
+  script: ScriptIR | null
+  styles: StyleIR[]
+}
+export type TemplateIR = {
+  raw: string
+  nodes: TemplateNode[]
+  expressions: ExpressionIR[]
+}
+export type TemplateNode =
+  | ElementNode
+  | TextNode
+  | ExpressionNode
+export type ElementNode = {
+  type: 'element'
+  tag: string
+  attributes: AttributeIR[]
+  children: TemplateNode[]
+  location: SourceLocation
+  loopContext?: LoopContext  // Phase 7: Inherited loop context from parent map expressions
+}
+export type TextNode = {
+  type: 'text'
+  value: string
+  location: SourceLocation
+}
+export type ExpressionNode = {
+  type: 'expression'
+  expression: string
+  location: SourceLocation
+  loopContext?: LoopContext  // Phase 7: Loop context for expressions inside map iterations
+}
+export type AttributeIR = {
+  name: string
+  value: string | ExpressionIR
+  location: SourceLocation
+  loopContext?: LoopContext  // Phase 7: Loop context for expressions inside map iterations
+}
+/**
+ * Loop context for expressions inside map iterations
+ * Phase 7: Tracks loop variables (e.g., todo, index) for expressions inside .map() calls
+ */
+export type LoopContext = {
+  variables: string[]  // e.g., ['todo', 'index'] for todoItems.map((todo, index) => ...)
+  mapSource?: string   // The array being mapped, e.g., 'todoItems'
+}
+export type ExpressionIR = {
+  id: string
+  code: string
+  location: SourceLocation
+}
+export type ScriptIR = {
+  raw: string
+}
+export type StyleIR = {
+  raw: string
+}
+export type SourceLocation = {
+  line: number
+  column: number
+}

package/compiler/legacy/binding.ts ADDED Viewed

@@ -0,0 +1,254 @@
+// compiler/binding.ts
+// Phase 2: Reactive text bindings runtime generator
+// Generates code to update DOM when state values change
+// Extended to support component instance-scoped state
+import type { StateBinding } from "./types"
+// Extract instance ID and base state name from instance-scoped state name
+// e.g., "__zen_comp_0_clicks" -> { instanceId: "comp-0", baseState: "clicks" }
+function parseInstanceState(stateName: string): { instanceId: string; baseState: string } | null {
+  const match = stateName.match(/^__zen_comp_(\d+)_(.+)$/);
+  if (match) {
+    const instanceNum = match[1];
+    const baseState = match[2];
+    return { instanceId: `comp-${instanceNum}`, baseState };
+  }
+  return null;
+}
+export function generateBindingRuntime(
+  stateBindings: StateBinding[],
+  stateDeclarations: Map<string, string>
+): string {
+  if (stateBindings.length === 0 && stateDeclarations.size === 0) {
+    return "";
+  }
+  const stateNames = Array.from(stateDeclarations.keys());
+  // Separate global state and instance-scoped state
+  const globalStates = new Set<string>();
+  const instanceStates = new Map<string, Map<string, string[]>>(); // instanceId -> baseState -> fullStateNames
+  for (const stateName of stateNames) {
+    const instanceInfo = parseInstanceState(stateName);
+    if (instanceInfo) {
+      if (!instanceStates.has(instanceInfo.instanceId)) {
+        instanceStates.set(instanceInfo.instanceId, new Map());
+      }
+      const instanceMap = instanceStates.get(instanceInfo.instanceId)!;
+      if (!instanceMap.has(instanceInfo.baseState)) {
+        instanceMap.set(instanceInfo.baseState, []);
+      }
+      instanceMap.get(instanceInfo.baseState)!.push(stateName);
+    } else {
+      globalStates.add(stateName);
+    }
+  }
+  // Generate binding update map - collect all nodes for each state
+  // Order is preserved: bindings are processed in the order they appear in stateBindings array
+  // (which matches DOM traversal order from compilation)
+  const bindingMapEntries: string[] = [];
+  const bindingMap = new Map<string, string[]>();
+  // Iterate over stateBindings array to preserve compile-time order
+  // Maps preserve insertion order, so this maintains deterministic ordering
+  for (const stateBinding of stateBindings) {
+    if (!bindingMap.has(stateBinding.stateName)) {
+      bindingMap.set(stateBinding.stateName, []);
+    }
+    const selectors = bindingMap.get(stateBinding.stateName)!;
+    // Push bindings in the order they appear in stateBinding.bindings array
+    // This preserves the DOM traversal order from compilation
+    for (const binding of stateBinding.bindings) {
+      const bindId = `bind-${binding.nodeIndex}`;
+      // Check if this is an instance-scoped binding
+      const instanceInfo = parseInstanceState(stateBinding.stateName);
+      if (instanceInfo) {
+        // Scope selector to component instance root
+        selectors.push(`[data-zen-instance="${instanceInfo.instanceId}"] span[data-zen-bind="${stateBinding.stateName}"][data-zen-bind-id="${bindId}"]`);
+      } else {
+        // Global binding
+        selectors.push(`span[data-zen-bind="${stateBinding.stateName}"][data-zen-bind-id="${bindId}"]`);
+      }
+    }
+  }
+  // Generate update functions for each binding
+  // Each function captures a DOM node reference directly
+  // Map.entries() preserves insertion order, maintaining compile-time binding order
+  for (const [stateName, selectors] of bindingMap.entries()) {
+    if (selectors.length > 0) {
+      // Generate an array of update functions, each capturing a node reference
+      const updateFunctions = selectors.map((selector, index) => {
+        const escapedSelector = selector.replace(/"/g, '\\"');
+        // Create a function that captures the node and updates it
+        // We'll query the node once during init, then the function captures it
+        return `(function() {
+        const node = document.querySelector("${escapedSelector}");
+        return function(value) {
+          if (node) node.textContent = String(value);
+        };
+      })()`;
+      }).join(",\n      ");
+      bindingMapEntries.push(
+        `    "${stateName}": [\n      ${updateFunctions}\n    ]`
+      );
+    }
+  }
+  const bindingMapCode = bindingMapEntries.length > 0
+    ? `__zen_bindings = {\n${bindingMapEntries.join(",\n")}\n  };`
+    : `__zen_bindings = {};`;
+  // Generate global state initialization code
+  const globalStateInitCode = Array.from(globalStates).map(name => {
+    const initialValue = stateDeclarations.get(name) || "undefined";
+    return `
+  // Initialize global state: ${name}
+  (function() {
+    let __zen_${name} = ${initialValue};
+    Object.defineProperty(window, "${name}", {
+      get: function() { return __zen_${name}; },
+      set: function(value) {
+        __zen_${name} = value;
+        // Immediately trigger synchronous updates - no batching, no async
+        __zen_update_bindings("${name}", value);
+        // Also trigger dynamic expression updates
+        if (window.__zen_trigger_expression_updates) {
+          window.__zen_trigger_expression_updates("${name}");
+        }
+      },
+      enumerable: true,
+      configurable: true
+    });
+  })();`;
+  }).join("");
+  // Generate instance state initialization code
+  const instanceStateInitCode: string[] = [];
+  for (const [instanceId, baseStateMap] of instanceStates.entries()) {
+    const safeInstanceId = instanceId.replace(/-/g, '_');
+    for (const [baseState, fullStateNames] of baseStateMap.entries()) {
+      // For each instance, create a state proxy scoped to that instance
+      // Only process the first fullStateName (they should all have the same instance)
+      const fullStateName = fullStateNames[0];
+      const initialValue = stateDeclarations.get(fullStateName) || "undefined";
+      instanceStateInitCode.push(`
+  // Initialize instance-scoped state: ${fullStateName} (${instanceId}.${baseState})
+  (function() {
+    const instanceRoot = document.querySelector('[data-zen-instance="${instanceId}"]');
+    if (!instanceRoot) {
+      console.warn('[Zenith] Component instance "${instanceId}" not found in DOM');
+      return;
+    }
+    let __zen_${safeInstanceId}_${baseState} = ${initialValue};
+    // Create instance-scoped state proxy
+    const instanceState = new Proxy({}, {
+      get(target, prop) {
+        if (prop === '${baseState}') {
+          return __zen_${safeInstanceId}_${baseState};
+        }
+        return undefined;
+      },
+      set(target, prop, value) {
+        if (prop === '${baseState}') {
+          __zen_${safeInstanceId}_${baseState} = value;
+          // Trigger updates only for bindings within this instance
+          __zen_update_bindings("${fullStateName}", value);
+          return true;
+        }
+        return false;
+      }
+    });
+    // Store instance state on window for component access
+    if (!window.__zen_instances) {
+      window.__zen_instances = {};
+    }
+    if (!window.__zen_instances["${instanceId}"]) {
+      window.__zen_instances["${instanceId}"] = instanceState;
+    } else {
+      window.__zen_instances["${instanceId}"].${baseState} = __zen_${safeInstanceId}_${baseState};
+    }
+      // Create global property accessor for instance-scoped state
+    Object.defineProperty(window, "${fullStateName}", {
+      get: function() { return __zen_${safeInstanceId}_${baseState}; },
+      set: function(value) {
+        __zen_${safeInstanceId}_${baseState} = value;
+        // Update instance state object
+        if (window.__zen_instances && window.__zen_instances["${instanceId}"]) {
+          window.__zen_instances["${instanceId}"].${baseState} = value;
+        }
+        __zen_update_bindings("${fullStateName}", value);
+        // Also trigger attribute binding updates for this instance
+        if (window.__zen_update_attribute_bindings) {
+          window.__zen_update_attribute_bindings("${instanceId}");
+        }
+        // Also trigger dynamic expression updates
+        if (window.__zen_trigger_expression_updates) {
+          window.__zen_trigger_expression_updates("${fullStateName}");
+        }
+      },
+      enumerable: true,
+      configurable: true
+    });
+  })();`);
+    }
+  }
+  // Generate initialization call (after DOM is ready)
+  const initBindingsCode = stateNames.map(name => {
+    return `    __zen_update_bindings("${name}", ${name});`;
+  }).join("\n");
+  return `
+// Phase 2: Reactive text bindings runtime (with component instance support)
+(function() {
+  let __zen_bindings = {};
+  // Update function for a specific state
+  // Calls all registered update functions for the given state property
+  // Executes synchronously, immediately, in compile-order (array order)
+  // No batching, no async scheduling, no reordering
+  function __zen_update_bindings(stateName, value) {
+    const updaters = __zen_bindings[stateName];
+    if (updaters) {
+      // Execute update functions in deterministic order (compile-time order)
+      // forEach executes synchronously, preserving array order
+      updaters.forEach(updateFn => {
+        if (typeof updateFn === 'function') {
+          updateFn(value);
+        }
+      });
+    }
+  }
+${globalStateInitCode}
+${instanceStateInitCode.join('')}
+  // Initialize binding map and bindings after DOM is ready
+  function __zen_init_bindings() {
+${bindingMapCode.split('\n').map(line => '    ' + line).join('\n')}
+${initBindingsCode.split('\n').map(line => '    ' + line).join('\n')}
+  }
+  // Initialize bindings when DOM is ready (scripts are deferred, so DOM should be ready)
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', __zen_init_bindings);
+  } else {
+    __zen_init_bindings();
+  }
+})();
+`;
+}