@hatchingpoint/point 0.0.12 → 0.0.14

package/src/semantic/desugar.ts

@@ -11,6 +11,7 @@ import type {
 	PointCoreTypeExpression,
 	PointCoreValueDeclaration,
 	PointSourceSpan,
+	PointSemanticViewControls,
 } from "../core/ast.ts";
 import type {
 	PointSemanticBinding,
@@ -35,6 +36,8 @@ import type {
 	PointSemanticTypeExpression,
 	PointSemanticUseDeclaration,
 	PointSemanticViewDeclaration,
+	PointSemanticViewStatement,
+	PointSemanticPageDeclaration,
 	PointSemanticWorkflowDeclaration,
 	PointSemanticWorkflowStatement,
 	PointSemanticActionDeclaration,
@@ -104,6 +107,7 @@ function buildCallableMap(
 			declaration.kind === "action" ||
 			declaration.kind === "policy" ||
 			declaration.kind === "view" ||
+			declaration.kind === "page" ||
 			declaration.kind === "route" ||
 			declaration.kind === "workflow" ||
 			declaration.kind === "command"
@@ -119,6 +123,7 @@ function defaultOutputName(declaration: PointSemanticDeclaration): string {
 	if (declaration.kind === "label") return "label";
 	if (declaration.kind === "policy") return "policy";
 	if (declaration.kind === "view") return "view";
+	if (declaration.kind === "page") return "page";
 	if (declaration.kind === "route") return "route";
 	if ("output" in declaration) return toIdentifier(declaration.output.name);
 	return "result";
@@ -152,6 +157,8 @@ function desugarDeclaration(
 			return [desugarPolicy(declaration, records, callables)];
 		case "view":
 			return [desugarView(declaration, records, callables)];
+		case "page":
+			return [desugarPage(declaration, records, callables)];
 		case "route":
 			return [desugarRoute(declaration, records, callables)];
 		case "workflow":
@@ -296,13 +303,85 @@ function desugarView(
 	const outputType: PointCoreTypeExpression = { kind: "typeRef", name: "Text", args: [] };
 	const { params, bindings } = collectBindings(declaration.inputs, declaration.output);
 	const ctx: DesugarContext = { records, callables, bindings, outputName: "page", outputType };
+	const renderStatements = declaration.body.filter(
+		(statement): statement is Extract<PointSemanticViewStatement, { kind: "render" | "whenRender" }> =>
+			statement.kind === "render" || statement.kind === "whenRender",
+	);
+	const metadata = semanticDeclarationMetadata(declaration);
+	const viewControls = buildViewControls(declaration, ctx);
+	if (viewControls) metadata.viewControls = viewControls;
 	return {
 		kind: "function",
 		name: semanticFunctionName(declaration.name, "view", "view"),
 		params,
 		returnType: outputType,
-		body: desugarViewBody(declaration.body, ctx),
-		semantic: semanticDeclarationMetadata(declaration),
+		body: desugarViewBody(renderStatements, ctx),
+		semantic: metadata,
+		span: declaration.span,
+	};
+}
+
+function buildViewControls(
+	declaration: PointSemanticViewDeclaration,
+	ctx: DesugarContext,
+): PointSemanticViewControls | undefined {
+	const bindStatements = declaration.body.filter(
+		(statement): statement is Extract<PointSemanticViewStatement, { kind: "bindCheckbox" }> => statement.kind === "bindCheckbox",
+	);
+	if (bindStatements.length === 0) return undefined;
+
+	const onChangeCall = declaration.body.find(
+		(statement): statement is Extract<PointSemanticViewStatement, { kind: "onChangeCall" }> => statement.kind === "onChangeCall",
+	);
+	const handlerInput = declaration.inputs.find((input) => input.type.name === "Handler" && input.type.args.length === 1);
+	const callbackLabel = onChangeCall?.callback ?? handlerInput?.label;
+	if (!callbackLabel) {
+		throw new Error(`View ${declaration.name} with bind checkbox requires input Handler T or on change call`);
+	}
+	const changeCallback = toIdentifier(callbackLabel);
+
+	return {
+		changeCallback,
+		checkboxes: bindStatements.map((statement) => {
+			const target = desugarExpression(statement.target, ctx);
+			if (target.kind !== "property") {
+				throw new Error(`bind checkbox target must be a record field access`);
+			}
+			if (target.target.kind !== "identifier") {
+				throw new Error(`bind checkbox target must start with an input record`);
+			}
+			return {
+				label: statement.label,
+				target,
+				recordParam: target.target.name,
+				fieldName: target.name,
+			};
+		}),
+	};
+}
+
+function desugarPage(
+	declaration: PointSemanticPageDeclaration,
+	records: Map<string, Map<string, string>>,
+	callables: Map<string, string>,
+): PointCoreFunctionDeclaration {
+	const outputType: PointCoreTypeExpression = { kind: "typeRef", name: "Text", args: [] };
+	const pageType: PointCoreTypeExpression = { kind: "typeRef", name: "Page", args: [] };
+	const { params, bindings } = collectBindings(declaration.inputs, { name: "page", type: pageType });
+	const ctx: DesugarContext = { records, callables, bindings, outputName: "page", outputType };
+	const metadata = semanticDeclarationMetadata(declaration);
+	metadata.pageLayout = {
+		title: desugarExpression(declaration.title, ctx),
+		description: declaration.description ? desugarExpression(declaration.description, ctx) : undefined,
+		main: desugarExpression(declaration.main, ctx),
+	};
+	return {
+		kind: "function",
+		name: semanticFunctionName(declaration.name, "page", "page"),
+		params,
+		returnType: outputType,
+		body: [{ kind: "return", value: metadata.pageLayout.main, span: declaration.span }],
+		semantic: metadata,
 		span: declaration.span,
 	};
 }
@@ -390,7 +469,7 @@ function desugarParameter(binding: PointSemanticBinding): PointCoreParameter {
 }
 
 function desugarType(type: PointSemanticTypeExpression): PointCoreTypeExpression {
-	if (type.name === "List" || type.name === "Maybe" || type.name === "Or") {
+	if (type.name === "List" || type.name === "Maybe" || type.name === "Or" || type.name === "Handler") {
 		return { kind: "typeRef", name: type.name, args: type.args.map(desugarType) };
 	}
 	const primitives = new Set(["Text", "Int", "Float", "Bool", "Void", "Error", "Page"]);

package/src/semantic/expressions.ts

@@ -32,6 +32,14 @@ export function parseSemanticTypeExpression(source: string): PointSemanticTypeEx
 	if (maybeMatch) {
 		return { kind: "typeRef", name: "Maybe", args: [parseSemanticTypeExpression(maybeMatch[1] ?? "")] };
 	}
+	const handlerMatch = trimmed.match(/^Handler\s+(.+)$/);
+	if (handlerMatch) {
+		return { kind: "typeRef", name: "Handler", args: [parseSemanticTypeExpression(handlerMatch[1] ?? "")] };
+	}
+	const handlerGenericMatch = trimmed.match(/^Handler<(.+)>$/);
+	if (handlerGenericMatch) {
+		return { kind: "typeRef", name: "Handler", args: [parseSemanticTypeExpression(handlerGenericMatch[1] ?? "")] };
+	}
 	return { kind: "typeRef", name: trimmed, args: [] };
 }
 

package/src/semantic/format.ts

@@ -83,6 +83,14 @@ function formatDeclaration(declaration: PointSemanticDeclaration): string[] {
 				...formatViewOutput(declaration.output),
 				...declaration.body.map((statement) => `  ${formatViewStatement(statement)}`),
 			];
+		case "page":
+			return [
+				`page ${declaration.name}`,
+				...formatInputs(declaration.inputs),
+				`  title ${formatExpression(declaration.title)}`,
+				...(declaration.description ? [`  description ${formatExpression(declaration.description)}`] : []),
+				`  main render ${formatExpression(declaration.main)}`,
+			];
 		case "route":
 			return [
 				`route ${declaration.name}`,
@@ -176,6 +184,8 @@ function formatPolicyStatement(statement: PointSemanticPolicyStatement): string
 
 function formatViewStatement(statement: PointSemanticViewStatement): string {
 	if (statement.kind === "whenRender") return `when ${formatExpression(statement.condition)} render ${formatExpression(statement.value)}`;
+	if (statement.kind === "bindCheckbox") return `bind checkbox "${statement.label}" to ${formatExpression(statement.target)}`;
+	if (statement.kind === "onChangeCall") return `on change call ${statement.callback}`;
 	return `render ${formatExpression(statement.value)}`;
 }
 

package/src/semantic/metadata.ts

@@ -30,6 +30,9 @@ export function semanticDeclarationMetadata(declaration: PointSemanticDeclaratio
 			effects: [],
 		};
 	}
+	if (declaration.kind === "page") {
+		return { kind: "page", name: declaration.name, outputName: "page", effects: [] };
+	}
 	if (declaration.kind === "route") {
 		return { kind: "route", name: declaration.name, outputName: declaration.output.name, effects: [] };
 	}

package/src/semantic/naming.ts

@@ -11,7 +11,7 @@ export function toIdentifier(label: string): string {
 export function semanticFunctionName(
 	label: string,
 	outputName: string,
-	kind: "calculation" | "rule" | "label" | "action" | "policy" | "view" | "route" | "workflow" | "command",
+	kind: "calculation" | "rule" | "label" | "action" | "policy" | "view" | "page" | "route" | "workflow" | "command",
 ): string {
 	const base = toIdentifier(label);
 	const suffix =
@@ -21,7 +21,9 @@ export function semanticFunctionName(
 				? "Policy"
 				: kind === "view"
 					? "View"
-					: kind === "route"
+					: kind === "page"
+						? "Page"
+						: kind === "route"
 						? "Route"
 						: kind === "workflow"
 							? "Workflow"

package/src/semantic/parse.ts

@@ -25,6 +25,7 @@ import type {
 	PointSemanticUseDeclaration,
 	PointSemanticViewDeclaration,
 	PointSemanticViewStatement,
+	PointSemanticPageDeclaration,
 	PointSemanticWorkflowDeclaration,
 	PointSemanticWorkflowStatement,
 	PointSemanticBinding,
@@ -129,6 +130,12 @@ export function parseSemanticSource(source: string): PointSemanticProgram {
 			index = parsed.next;
 			continue;
 		}
+		if (trimmed.startsWith("page ")) {
+			const parsed = parsePage(lines, index, source, records, callables);
+			declarations.push(parsed.declaration);
+			index = parsed.next;
+			continue;
+		}
 		if (trimmed.startsWith("route ")) {
 			const parsed = parseRoute(lines, index, source, records, callables);
 			declarations.push(parsed.declaration);
@@ -586,6 +593,24 @@ function parseView(
 			});
 			continue;
 		}
+		const bindCheckbox = line.match(/^bind checkbox "(.+)" to (.+)$/);
+		if (bindCheckbox) {
+			statements.push({
+				kind: "bindCheckbox",
+				label: bindCheckbox[1] ?? "",
+				target: parseLineExpression(bindCheckbox[2] ?? "", context, source, lineNumber),
+				span: lineSpan(source, lineNumber),
+			});
+			continue;
+		}
+		if (line.startsWith("on change call ")) {
+			statements.push({
+				kind: "onChangeCall",
+				callback: line.slice("on change call ".length).trim(),
+				span: lineSpan(source, lineNumber),
+			});
+			continue;
+		}
 		throw new Error(`Unknown view statement: ${line}`);
 	}
 
@@ -595,6 +620,57 @@ function parseView(
 	};
 }
 
+function parsePage(
+	lines: string[],
+	start: number,
+	source: string,
+	records: Map<string, Map<string, string>>,
+	callables: string[],
+): { declaration: PointSemanticPageDeclaration; next: number } {
+	const name = (lines[start] ?? "").trim().slice("page ".length).trim();
+	const body = collectSemanticBody(lines, start + 1);
+	const inputs: PointSemanticBinding[] = [];
+	const paramTypes = new Map<string, string>();
+	const bindings: string[] = [];
+	let title: PointSemanticPageDeclaration["title"] | undefined;
+	let description: PointSemanticPageDeclaration["description"];
+	let main: PointSemanticPageDeclaration["main"] | undefined;
+
+	for (let lineIndex = 0; lineIndex < body.lines.length; lineIndex += 1) {
+		const line = body.lines[lineIndex] ?? "";
+		const lineNumber = body.lineNumbers[lineIndex] ?? start + 2;
+		if (line.startsWith("input ")) {
+			const binding = parseInputBinding(line.slice("input ".length), source, lineNumber);
+			inputs.push(binding);
+			paramTypes.set(binding.label, typeLabel(binding.type));
+			bindings.push(binding.label);
+			continue;
+		}
+		const context = buildExpressionContext({ bindings, paramTypes, recordFields: records, callables });
+		if (line.startsWith("title ")) {
+			title = parseLineExpression(line.slice("title ".length), context, source, lineNumber);
+			continue;
+		}
+		if (line.startsWith("description ")) {
+			description = parseLineExpression(line.slice("description ".length), context, source, lineNumber);
+			continue;
+		}
+		if (line.startsWith("main render ")) {
+			main = parseLineExpression(line.slice("main render ".length), context, source, lineNumber);
+			continue;
+		}
+		throw new Error(`Unknown page statement: ${line}`);
+	}
+
+	if (!title) throw new Error(`Page ${name} requires a title`);
+	if (!main) throw new Error(`Page ${name} requires main render`);
+
+	return {
+		declaration: { kind: "page", name, inputs, title, description, main, span: lineSpan(source, start + 1) },
+		next: body.next,
+	};
+}
+
 function parseRoute(
 	lines: string[],
 	start: number,
@@ -893,7 +969,7 @@ function collectSemanticBody(lines: string[], start: number): SemanticBody {
 }
 
 function isSemanticTopLevel(line: string): boolean {
-	return /^(module|use|record|calculation|rule|label|external|action|policy|view|route|workflow|command)\s+/.test(line);
+	return /^(module|use|record|calculation|rule|label|external|action|policy|view|page|route|workflow|command)\s+/.test(line);
 }
 
 function isLoopBoundary(line: string): boolean {
@@ -914,7 +990,10 @@ function typeLabel(type: { kind: "typeRef"; name: string; args: unknown[] }): st
 	if (type.name === "Maybe" && type.args[0]) {
 		return `Maybe<${typeLabel(type.args[0] as { kind: "typeRef"; name: string; args: unknown[] })}>`;
 	}
-	const primitives = new Set(["Text", "Int", "Float", "Bool", "Void", "Maybe", "Or", "Error", "Page"]);
+	if (type.name === "Handler" && type.args[0]) {
+		return `Handler ${typeLabel(type.args[0] as { kind: "typeRef"; name: string; args: unknown[] })}`;
+	}
+	const primitives = new Set(["Text", "Int", "Float", "Bool", "Void", "Maybe", "Or", "Error", "Page", "Handler"]);
 	if (primitives.has(type.name)) return type.name;
 	return toPascalCase(type.name);
 }

package/src/std/env.ts

@@ -0,0 +1,4 @@
+export function envGet(name: string): string | null {
+	const value = process.env[name];
+	return value === undefined ? null : value;
+}

package/src/std/fs.ts

@@ -0,0 +1,19 @@
+import { readFileSync, writeFileSync } from "node:fs";
+
+type PointStdError = { message: string };
+
+export function readFile(path: string): string | PointStdError {
+	try {
+		return readFileSync(path, "utf8");
+	} catch (error) {
+		return { message: error instanceof Error ? error.message : String(error) };
+	}
+}
+
+export function writeFile(path: string, contents: string): void | PointStdError {
+	try {
+		writeFileSync(path, contents, "utf8");
+	} catch (error) {
+		return { message: error instanceof Error ? error.message : String(error) };
+	}
+}

package/src/std/http.ts

@@ -0,0 +1,30 @@
+type PointStdError = { message: string };
+
+async function readResponseText(response: Response): Promise<string | PointStdError> {
+	if (!response.ok) {
+		return { message: `HTTP ${response.status}: ${response.statusText}` };
+	}
+	return response.text();
+}
+
+export async function httpGet(url: string): Promise<string | PointStdError> {
+	try {
+		return await readResponseText(await fetch(url));
+	} catch (error) {
+		return { message: error instanceof Error ? error.message : String(error) };
+	}
+}
+
+export async function httpPost(url: string, body: string): Promise<string | PointStdError> {
+	try {
+		return await readResponseText(
+			await fetch(url, {
+				method: "POST",
+				headers: { "Content-Type": "text/plain; charset=utf-8" },
+				body,
+			}),
+		);
+	} catch (error) {
+		return { message: error instanceof Error ? error.message : String(error) };
+	}
+}

package/src/std/json.ts

@@ -0,0 +1,13 @@
+export type PointStdError = { message: string };
+
+export function jsonParse(value: string): string | PointStdError {
+	try {
+		return JSON.stringify(JSON.parse(value));
+	} catch (error) {
+		return { message: error instanceof Error ? error.message : String(error) };
+	}
+}
+
+export function jsonStringify(value: string): string {
+	return JSON.stringify(JSON.parse(value));
+}

package/src/std/text.ts

@@ -0,0 +1,15 @@
+export function textLength(value: string): number {
+	return value.length;
+}
+
+export function textContains(value: string, search: string): boolean {
+	return value.includes(search);
+}
+
+export function textSplit(value: string, separator: string): string[] {
+	return value.split(separator);
+}
+
+export function textTrim(value: string): string {
+	return value.trim();
+}

package/src/std/time.ts

@@ -0,0 +1,15 @@
+export function now(): string {
+	return new Date().toISOString();
+}
+
+export async function sleep(ms: number): Promise<void> {
+	await Bun.sleep(ms);
+}
+
+export function formatTime(value: string): string {
+	const date = new Date(value);
+	if (Number.isNaN(date.getTime())) {
+		return value;
+	}
+	return date.toUTCString();
+}