@heshammesalam/heshjs 0.2.0 → 0.3.0

package/src/parser/index.ts

@@ -4,7 +4,15 @@ export interface Expression extends Location { source: string }
 export interface State extends Location { kind: 'state' | 'const'; name: string; value: Expression }
 export interface Element extends Location { kind: 'element'; name: string; value?: Expression; handler?: Expression; async: boolean; children: Element[] }
 export interface View extends Location { name: string; exported: boolean; default: boolean; body: (State | Element)[] }
-export interface Module { source: string; filename: string; imports: Expression[]; views: View[] }
+export interface ContractEntry extends Location { name: string; value?: string }
+export interface Contract extends Location {
+  kind: 'domain' | 'presentation' | 'destination' | 'application';
+  name: string;
+  fields: Record<string, ContractEntry>;
+  blocks: Record<string, ContractEntry[]>;
+}
+export interface Module { source: string; filename: string; imports: Expression[]; views: View[]; contracts?: Contract[] }
+export interface ParsedModule extends Module { contracts: Contract[] }
 export class HeshError extends Error {
   readonly line: number;
   readonly column: number;
@@ -61,7 +69,7 @@ export function tokenize(source: string, filename = 'component.hesh'): Token[] {
   return tokens;
 }
 
-export function parse(source: string, filename = 'component.hesh'): Module {
+export function parse(source: string, filename = 'component.hesh'): ParsedModule {
   const tokens = tokenize(source, filename);
   let at = 0;
   const peek = () => tokens[at]?.text;
@@ -119,8 +127,51 @@ export function parse(source: string, filename = 'component.hesh'): Module {
     else take(';');
     return { kind: 'element', name: name.text, start: name.start, end: tokens[at - 1]!.end, value, handler, async, children };
   };
-  const module: Module = { source, filename, imports: [], views: [] };
+  const contract = (): Contract => {
+    const kind = take(); const name = identifier(); take('{');
+    const result: Contract = { kind: kind.text as Contract['kind'], name: name.text, start: kind.start, end: 0, fields: Object.create(null), blocks: Object.create(null) };
+    const schemas: Record<Contract['kind'], Record<string, string>> = {
+      domain: { implementation: 'string', owns: 'list', exposes: 'list', consumes: 'list', access: 'map' },
+      presentation: { html: 'string', logic: 'string', styles: 'string', bindings: 'list', actions: 'list' },
+      destination: { url: 'string', input: 'map', presentation: 'identifier', access: 'string' },
+      application: { domains: 'list', destinations: 'list' }
+    };
+    const path = (): ContractEntry => {
+      const first = identifier(); let name = first.text;
+      while (peek() === '.') { take(); name += '.' + identifier().text; }
+      for (const part of name.split('.')) if (['__proto__', 'prototype', 'constructor'].includes(part)) fail('Unsafe contract identifier', first.start);
+      return { name, start: first.start, end: tokens[at - 1]!.end };
+    };
+    const string = () => {
+      const token = take();
+      if (token.kind !== ts.SyntaxKind.StringLiteral) fail('Expected quoted string', token.start);
+      const parsed = ts.createSourceFile('literal.js', token.text, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+      return ((parsed.statements[0] as ts.ExpressionStatement).expression as ts.StringLiteral).text;
+    };
+    while (peek() && peek() !== '}') {
+      const key = take(); const type = Object.hasOwn(schemas[result.kind], key.text) ? schemas[result.kind][key.text] : undefined;
+      if (!type) fail(`Unknown ${result.kind} field ${key.text}`, key.start);
+      if (result.fields[key.text] || result.blocks[key.text]) fail(`Duplicate field ${key.text}`, key.start);
+      if (type === 'string' || type === 'identifier') {
+        take(':'); const value = type === 'string' ? string() : identifier().text; const end = take(';').end;
+        result.fields[key.text] = { name: key.text, value, start: key.start, end };
+      } else {
+        take('{'); const entries: ContractEntry[] = []; const seen = new Set<string>();
+        while (peek() && peek() !== '}') {
+          const entry = path();
+          if (seen.has(entry.name)) fail(`Duplicate entry ${entry.name}`, entry.start); seen.add(entry.name);
+          if (type === 'map') { take(':'); entry.value = key.text === 'input' ? identifier().text : string(); }
+          entry.end = take(';').end; entries.push(entry);
+        }
+        take('}'); result.blocks[key.text] = entries;
+      }
+    }
+    result.end = take('}').end;
+    return result;
+  };
+  const module: ParsedModule = { source, filename, imports: [], views: [], contracts: [] };
   while (tokens[at]) {
+    if (['domain', 'presentation', 'destination', 'application'].includes(peek() ?? '')) { module.contracts.push(contract()); continue; }
     if (peek() === 'import') {
       if (module.views.length) fail('Imports must precede views');
       const start = take().start;
@@ -144,6 +195,6 @@ export function parse(source: string, filename = 'component.hesh'): Module {
     const end = take('}').end;
     module.views.push({ name, body, start, end, exported, default: isDefault });
   }
-  if (!module.views.length) fail('Expected at least one view');
+  if (!module.views.length && !module.contracts.length) fail('Expected at least one view or architecture declaration');
   return module;
 }

package/src/presentation/index.ts

@@ -0,0 +1,31 @@
+import { effect } from '../reactivity/index.js';
+import { nativeElement as element, text, attribute, listen } from '../dom/index.js';
+export { element, text, attribute, listen };
+export interface PresentationState { bindings: Record<string, unknown>; actions: Record<string, (event: Event) => unknown> }
+export function readBinding(bindings: Record<string, unknown>, path: string): unknown {
+  const unwrap = (value: unknown): unknown => {
+    if (typeof value === 'function') return value();
+    if (value && typeof (value as { get?: unknown }).get === 'function') return (value as { get(): unknown }).get();
+    return value;
+  };
+  let value: unknown = bindings;
+  for (const part of path.split('.')) {
+    if (['__proto__', 'constructor', 'prototype'].includes(part)) throw new Error('Unsafe binding path');
+    value = (unwrap(value) as Record<string, unknown> | null)?.[part];
+  }
+  return unwrap(value);
+}
+export function bindValue(node: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement, bindings: Record<string, unknown>, name: string): void {
+  const state = bindings[name] as { get?(): unknown; set?(value: unknown): void };
+  if (typeof state?.get !== 'function' || typeof state.set !== 'function') throw new Error(`h-value ${name} requires a writable signal`);
+  effect(() => { const value = String(state.get!() ?? ''); if (node.value !== value) node.value = value; });
+  listen(node, 'input', () => state.set!(node.value));
+}
+export function bindAction(node: HTMLElement, state: PresentationState, name: string): void {
+  const handler = state.actions[name];
+  if (typeof handler !== 'function') throw new Error(`Missing presentation action ${name}`);
+  listen(node, node.tagName === 'FORM' ? 'submit' : 'click', event => {
+    if (node.tagName === 'FORM') event.preventDefault();
+    return handler.call(state.actions, event);
+  });
+}

package/src/vite/index.ts

@@ -1,17 +1,39 @@
 import type { Plugin } from 'vite';
 import { compile } from '../compiler/index.js';
-export function hesh(): Plugin {
+import { createArchitectureCompiler, writeProject, formatDiagnostic, type ProjectOptions } from '../architecture/index.js';
+import { resolve } from 'node:path';
+export function hesh(options: { architecture?: ProjectOptions } = {}): Plugin {
   let production = false;
+  const architecture = createArchitectureCompiler();
+  let project: ProjectOptions | undefined;
+  let watched: string[] = [];
+  let warn: ((message: string) => void) | undefined;
+  const check = () => {
+    if (!project) return;
+    const result = architecture.check(project);
+    if (result.diagnostics.some(item => item.severity === 'error')) throw new Error(result.diagnostics.map(formatDiagnostic).join('\n'));
+    for (const item of result.diagnostics) if (item.severity === 'warning') warn?.(formatDiagnostic(item));
+    writeProject(result); watched = result.files;
+  };
   return {
     name: 'heshjs', enforce: 'pre',
     config() { return { appType: 'spa' }; },
-    configResolved(config) { production = config.command === 'build'; },
+    configResolved(config) {
+      production = config.command === 'build';
+      warn = message => config.logger.warn(message);
+      if (options.architecture) { project = { ...options.architecture, root: resolve(config.root, options.architecture.root) }; check(); }
+    },
+    buildStart() { for (const file of watched) this.addWatchFile(file); },
     transform(source, id) {
+      if (project && /(?:^|\/)server(?:\/|$)|\.server\.[cm]?[jt]s$/.test(id.replace(/\\/g, '/'))) throw new Error(`HESH-SEC-001 Server-only module cannot enter the browser bundle: ${id}`);
       if (!id.endsWith('.hesh')) return;
       const result = compile(source, { filename: id, development: !production });
       return { code: result.code, map: null };
     },
     handleHotUpdate(context) {
+      if (project && (watched.includes(context.file.replace(/\\/g, '/').toLowerCase()) || watched.includes(context.file.replace(/\\/g, '/')))) {
+        check(); context.server.ws.send({ type: 'full-reload' }); return [];
+      }
       if (context.file.endsWith('.hesh')) { context.server.ws.send({ type: 'full-reload' }); return []; }
     }
   };