tachyon-dom 0.1.0

package/dist/compiler/types.d.ts

@@ -0,0 +1,185 @@
+export type CompilerError = {
+    message: string;
+    offset: number;
+    endOffset?: number;
+};
+export type TemplateWhitespacePolicy = "preserve" | "condense";
+export type CompileTemplateOptions = {
+    whitespace?: TemplateWhitespacePolicy;
+};
+export type Attribute = {
+    name: string;
+    value: string | true;
+    start?: number;
+    end?: number;
+    nameStart?: number;
+    nameEnd?: number;
+    valueStart?: number;
+    valueEnd?: number;
+};
+export type ElementNode = {
+    type: "element";
+    start?: number;
+    end?: number;
+    openEnd?: number;
+    tagName: string;
+    attrs: Attribute[];
+    children: TemplateNode[];
+};
+export type TextNode = {
+    type: "text";
+    value: string;
+    start?: number;
+    end?: number;
+};
+export type TemplateNode = ElementNode | TextNode;
+export type TextBinding = {
+    kind: "text";
+    path: number[];
+    expression: string;
+};
+export type ClassBinding = {
+    kind: "class";
+    path: number[];
+    className: string;
+    expression: string;
+};
+export type EventBinding = {
+    kind: "event";
+    path: number[];
+    eventName: string;
+    handler: string;
+};
+export type AttributeBinding = {
+    kind: "attr";
+    path: number[];
+    name: string;
+    expression: string;
+};
+export type StyleBinding = {
+    kind: "style";
+    path: number[];
+    name: string;
+    expression: string;
+};
+export type RefBinding = {
+    kind: "ref";
+    path: number[];
+    expression: string;
+};
+export type ModelBinding = {
+    kind: "model";
+    path: number[];
+    property: "value" | "checked";
+    expression: string;
+};
+export type ListBinding = {
+    kind: "list";
+    path: number[];
+    each: string;
+    itemName: string;
+    key: string;
+    templateHtml: string;
+    bindings: ClientBinding[];
+};
+export type ConditionalBinding = {
+    kind: "if";
+    path: number[];
+    test: string;
+    templateHtml: string;
+    bindings: ClientBinding[];
+};
+export type ClientBinding = TextBinding | ClassBinding | EventBinding | AttributeBinding | StyleBinding | RefBinding | ModelBinding | ListBinding | ConditionalBinding;
+export type StoreDefinition = {
+    name: string;
+    initial: string;
+};
+export type HydrationBoundary = {
+    path: number[];
+    id: string;
+    idKind?: "expression" | "static";
+    strategy?: "load" | "idle" | "visible" | "media" | "interaction";
+    media?: string;
+    interaction?: string;
+    rootMargin?: string;
+};
+export type ComponentProp = {
+    name: string;
+    expression: string;
+};
+export type ComponentBoundary = {
+    path: number[];
+    name: string;
+    props: ComponentProp[];
+    stores: StoreDefinition[];
+};
+export type TemplateDirective = {
+    kind: "for";
+    path: number[];
+    each: string;
+    key: string;
+    itemName: string;
+} | {
+    kind: "if";
+    path: number[];
+    test: string;
+} | {
+    kind: "store";
+    path: number[];
+    stores: StoreDefinition[];
+} | {
+    kind: "event";
+    path: number[];
+    eventName: string;
+    handler: string;
+} | {
+    kind: "component";
+    path: number[];
+    name: string;
+    props: ComponentProp[];
+    stores: StoreDefinition[];
+} | {
+    kind: "await";
+    path: number[];
+    value: string;
+    thenName: string;
+    fallback?: string;
+    error?: string;
+    reorder?: "preserve" | "resolve";
+} | {
+    kind: "hydrate";
+    path: number[];
+    id: string;
+    idKind?: "expression" | "static";
+    strategy?: "load" | "idle" | "visible" | "media" | "interaction";
+    media?: string;
+    interaction?: string;
+    rootMargin?: string;
+};
+export type TemplateIr = {
+    kind: "template";
+    root: ElementNode;
+    directives: TemplateDirective[];
+};
+export type CompiledTemplate = {
+    source: string;
+    ir: TemplateIr;
+    root: ElementNode;
+    client: {
+        templateHtml: string;
+        bindings: ClientBinding[];
+        stores: StoreDefinition[];
+        hydrationBoundaries: HydrationBoundary[];
+        components: ComponentBoundary[];
+    };
+};
+export type LoweringContext = {
+    bindings: ClientBinding[];
+    stores: StoreDefinition[];
+    hydrationBoundaries: HydrationBoundary[];
+    components: ComponentBoundary[];
+};
+export type GenerateClientModuleOptions = {
+    reactive?: boolean;
+    defaultScopeName?: string;
+};

package/dist/compiler/types.js

@@ -0,0 +1 @@
+export {};

package/dist/compiler/utils.d.ts

@@ -0,0 +1,40 @@
+import type { Attribute, ElementNode, HydrationBoundary, TemplateNode } from "./types.js";
+export { escapeHtml } from "../html-escape.js";
+export declare const expressionPattern: RegExp;
+export declare const identifierNamePattern: RegExp;
+export declare const identifierPattern: RegExp;
+export type TextExpressionSegment = {
+    kind: "text";
+    value: string;
+    start: number;
+    end: number;
+} | {
+    kind: "expression";
+    value: string;
+    start: number;
+    end: number;
+};
+export declare const textExpressionSegments: (value: string) => TextExpressionSegment[];
+export declare const readExpressionAttribute: (value: string | true) => string | undefined;
+export declare const attrExpression: (node: ElementNode, name: string) => string | undefined;
+export declare const attrString: (node: ElementNode, name: string) => string | undefined;
+export declare const isHydrationAttribute: (name: string) => boolean;
+export declare const isKnownHydrationAttribute: (name: string) => boolean;
+export declare const automaticHydrationId: (path: readonly number[]) => string;
+export declare const hydrationBoundaryFor: (node: ElementNode, path: readonly number[]) => HydrationBoundary | undefined;
+export declare const childPathEntries: (children: readonly TemplateNode[], basePath: readonly number[]) => Array<{
+    child: TemplateNode;
+    path: number[];
+}>;
+export declare const isForNode: (node: TemplateNode) => node is ElementNode;
+export declare const isStoreNode: (node: TemplateNode) => node is ElementNode;
+export declare const itemNameFromKey: (key: string) => string;
+export declare const renderableChildren: (node: ElementNode) => TemplateNode[];
+export declare const escapeMarker: (value: unknown) => string;
+export declare const readPath: (scope: Record<string, unknown>, expression: string) => unknown;
+export declare const serializeStaticAttr: (attr: Attribute) => string;
+export declare const voidElementNames: Set<string>;
+export declare const isVoidElement: (node: ElementNode) => boolean;
+export declare const expressionToScopeAccess: (expression: string, locals?: ReadonlySet<string>, scopeName?: string) => string;
+export declare const jsString: (value: string) => string;
+export declare const jsOptionalPropertyAccess: (objectExpression: string, propertyName: string) => string;

package/dist/compiler/utils.js

@@ -0,0 +1,185 @@
+import { evaluateExpression, expressionToJs } from "./expression.js";
+import { escapeHtml } from "../html-escape.js";
+export { escapeHtml } from "../html-escape.js";
+export const expressionPattern = /\{([^{}]+)\}/g;
+export const identifierNamePattern = /^[A-Za-z_$][\w$]*$/;
+export const identifierPattern = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/;
+const findExpressionEnd = (value, start) => {
+    let depth = 0;
+    let quote;
+    let escaped = false;
+    for (let index = start; index < value.length; index++) {
+        const char = value[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (quote) {
+            if (char === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (quote === "`" && char === "$" && value[index + 1] === "{") {
+                depth++;
+                index++;
+                continue;
+            }
+            if (quote === "`" && char === "}" && depth > 0) {
+                depth--;
+                continue;
+            }
+            if (char === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === `"` || char === "'" || char === "`") {
+            quote = char;
+            continue;
+        }
+        if (char === "{") {
+            depth++;
+            continue;
+        }
+        if (char === "}") {
+            if (depth === 0) {
+                return index;
+            }
+            depth--;
+        }
+    }
+    return -1;
+};
+export const textExpressionSegments = (value) => {
+    const segments = [];
+    let cursor = 0;
+    while (cursor < value.length) {
+        const start = value.indexOf("{", cursor);
+        if (start < 0) {
+            segments.push({ kind: "text", value: value.slice(cursor), start: cursor, end: value.length });
+            break;
+        }
+        if (start > cursor) {
+            segments.push({ kind: "text", value: value.slice(cursor, start), start: cursor, end: start });
+        }
+        const end = findExpressionEnd(value, start + 1);
+        if (end < 0) {
+            segments.push({ kind: "text", value: value.slice(start), start, end: value.length });
+            break;
+        }
+        segments.push({ kind: "expression", value: value.slice(start + 1, end).trim(), start, end: end + 1 });
+        cursor = end + 1;
+    }
+    return segments;
+};
+export const readExpressionAttribute = (value) => {
+    if (value === true) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+        return undefined;
+    }
+    return trimmed.slice(1, -1).trim();
+};
+export const attrExpression = (node, name) => {
+    const attr = node.attrs.find((candidate) => candidate.name === name);
+    return attr ? readExpressionAttribute(attr.value) : undefined;
+};
+export const attrString = (node, name) => {
+    const attr = node.attrs.find((candidate) => candidate.name === name);
+    return typeof attr?.value === "string" ? attr.value : undefined;
+};
+export const isHydrationAttribute = (name) => name === "hydrate" || name.startsWith("hydrate:");
+const hydrationStrategies = new Set(["load", "idle", "visible", "media", "interaction"]);
+export const isKnownHydrationAttribute = (name) => name === "hydrate" ||
+    name === "hydrate:id" ||
+    (name.startsWith("hydrate:") && hydrationStrategies.has(name.slice("hydrate:".length)));
+export const automaticHydrationId = (path) => `td-h-${path.length === 0 ? "root" : path.join("-")}`;
+export const hydrationBoundaryFor = (node, path) => {
+    const explicitId = attrExpression(node, "hydrate:id");
+    const strategyAttr = node.attrs.find((attr) => attr.name.startsWith("hydrate:") && attr.name !== "hydrate:id" && hydrationStrategies.has(attr.name.slice(8)));
+    const hasAutoHydrate = node.attrs.some((attr) => attr.name === "hydrate" || (attr.name.startsWith("hydrate:") && attr.name !== "hydrate:id"));
+    if (!explicitId && !hasAutoHydrate) {
+        return undefined;
+    }
+    const boundary = explicitId
+        ? { path: [...path], id: explicitId }
+        : { path: [...path], id: automaticHydrationId(path), idKind: "static" };
+    if (!strategyAttr) {
+        return boundary;
+    }
+    const strategy = strategyAttr.name.slice(8);
+    boundary.strategy = strategy;
+    if (strategy === "visible") {
+        const rootMargin = typeof strategyAttr.value === "string" ? strategyAttr.value : undefined;
+        if (rootMargin) {
+            boundary.rootMargin = rootMargin;
+        }
+    }
+    if (strategy === "interaction") {
+        const interaction = typeof strategyAttr.value === "string" ? strategyAttr.value : undefined;
+        if (interaction) {
+            boundary.interaction = interaction;
+        }
+    }
+    if (strategy === "media") {
+        const media = typeof strategyAttr.value === "string" ? strategyAttr.value : undefined;
+        if (media) {
+            boundary.media = media;
+        }
+    }
+    return boundary;
+};
+export const childPathEntries = (children, basePath) => {
+    let domIndex = 0;
+    return children.map((child) => {
+        const path = child.type === "element" && (child.tagName === "store" || child.tagName === "for")
+            ? [...basePath]
+            : [...basePath, domIndex++];
+        return { child, path };
+    });
+};
+export const isForNode = (node) => node.type === "element" && node.tagName === "for";
+export const isStoreNode = (node) => node.type === "element" && node.tagName === "store";
+export const itemNameFromKey = (key) => {
+    const [itemName] = key.split(".");
+    return itemName && identifierPattern.test(itemName) ? itemName : "item";
+};
+export const renderableChildren = (node) => node.children.filter((child) => child.type !== "text" || child.value.length > 0);
+export const escapeMarker = (value) => String(value ?? "")
+    .replaceAll("--", "- -")
+    .replaceAll(">", "&gt;");
+export const readPath = (scope, expression) => {
+    return evaluateExpression(expression, scope);
+};
+export const serializeStaticAttr = (attr) => {
+    if (attr.value === true) {
+        return ` ${attr.name}`;
+    }
+    return ` ${attr.name}="${escapeHtml(attr.value)}"`;
+};
+export const voidElementNames = new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr",
+]);
+export const isVoidElement = (node) => voidElementNames.has(node.tagName);
+export const expressionToScopeAccess = (expression, locals = new Set(), scopeName = "scope") => {
+    return expressionToJs(expression, locals, scopeName);
+};
+export const jsString = (value) => JSON.stringify(value);
+export const jsOptionalPropertyAccess = (objectExpression, propertyName) => identifierNamePattern.test(propertyName)
+    ? `${objectExpression}?.${propertyName}`
+    : `${objectExpression}?.[${jsString(propertyName)}]`;

package/dist/compiler/whitespace.d.ts

@@ -0,0 +1,2 @@
+import type { ElementNode, TemplateWhitespacePolicy } from "./types.js";
+export declare const applyTemplateWhitespace: (root: ElementNode, policy: TemplateWhitespacePolicy) => ElementNode;

package/dist/compiler/whitespace.js

@@ -0,0 +1,66 @@
+import { textExpressionSegments } from "./utils.js";
+const protectedTextElements = new Set([
+    "iframe",
+    "listing",
+    "noembed",
+    "noframes",
+    "plaintext",
+    "pre",
+    "script",
+    "style",
+    "textarea",
+    "title",
+    "xmp",
+]);
+const asciiWhitespaceOnly = /^[\t\n\f\r ]+$/;
+const internalFormattingLine = /[\t\f\r ]*(?:\r\n?|\n)[\t\n\f\r ]*/g;
+const condenseStaticTextValue = (value) => {
+    if (!value.includes("\n") && !value.includes("\r"))
+        return value;
+    if (asciiWhitespaceOnly.test(value))
+        return " ";
+    return value.replace(internalFormattingLine, " ");
+};
+const condenseTextValue = (value) => textExpressionSegments(value)
+    .map((segment) => segment.kind === "text" ? condenseStaticTextValue(segment.value) : value.slice(segment.start, segment.end))
+    .join("");
+const childForeignContent = (parent, tagName) => {
+    if (parent === "svg" && tagName === "foreignobject")
+        return "html";
+    if (parent === "html" && tagName === "svg")
+        return "svg";
+    if (parent === "html" && tagName === "math")
+        return "math";
+    return parent;
+};
+const staticXmlSpace = (node) => {
+    const attribute = node.attrs.find((candidate) => candidate.name === "xml:space");
+    return attribute?.value === "preserve" || attribute?.value === "default" ? attribute.value : undefined;
+};
+const transformNode = (node, context) => {
+    if (node.type === "text") {
+        const text = { ...node };
+        if (!context.protectedHtmlText && context.xmlSpace !== "preserve")
+            text.value = condenseTextValue(text.value);
+        return text;
+    }
+    const tagName = node.tagName.toLowerCase();
+    const foreignContent = childForeignContent(context.foreignContent, tagName);
+    const entersForeignContent = context.foreignContent === "html" && foreignContent !== "html";
+    const xmlSpace = foreignContent === "html"
+        ? "default"
+        : (staticXmlSpace(node) ?? (entersForeignContent ? "default" : context.xmlSpace));
+    const nextContext = {
+        protectedHtmlText: context.protectedHtmlText || protectedTextElements.has(tagName),
+        foreignContent,
+        xmlSpace,
+    };
+    return {
+        ...node,
+        attrs: node.attrs.map((attribute) => ({ ...attribute })),
+        children: node.children.map((child) => transformNode(child, nextContext)),
+    };
+};
+export const applyTemplateWhitespace = (root, policy) => policy === "condense"
+    ? transformNode(root, { protectedHtmlText: false, foreignContent: "html", xmlSpace: "default" })
+    : root;

package/dist/compiler.d.ts

@@ -0,0 +1 @@
+export * from "./compiler/index.js";

package/dist/compiler.js

@@ -0,0 +1 @@
+export * from "./compiler/index.js";

package/dist/constant-time.d.ts

@@ -0,0 +1 @@
+export declare const timingSafeEqual: (left: unknown, right: string) => Promise<boolean>;

package/dist/constant-time.js

@@ -0,0 +1,26 @@
+const encoder = new TextEncoder();
+const xorEqual = (left, right) => {
+    let diff = left.length ^ right.length;
+    const length = Math.max(left.length, right.length);
+    for (let index = 0; index < length; index++) {
+        diff |= (left[index] ?? 0) ^ (right[index] ?? 0);
+    }
+    return diff === 0;
+};
+const digest = async (value) => {
+    if (!globalThis.crypto?.subtle) {
+        return undefined;
+    }
+    return new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", encoder.encode(value)));
+};
+export const timingSafeEqual = async (left, right) => {
+    if (typeof left !== "string") {
+        return false;
+    }
+    const leftDigest = await digest(left);
+    const rightDigest = await digest(right);
+    if (leftDigest && rightDigest) {
+        return xorEqual(leftDigest, rightDigest);
+    }
+    return xorEqual(encoder.encode(left), encoder.encode(right));
+};

package/dist/cookies.d.ts

@@ -0,0 +1,44 @@
+export type CookieOptions = {
+    path?: string;
+    domain?: string;
+    maxAge?: number;
+    expires?: Date;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: "Strict" | "Lax" | "None";
+};
+export type Session<Data extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    data: Data;
+};
+export type MemorySessionStorageOptions = {
+    cookieName?: string;
+    cookie?: CookieOptions;
+    id?: () => string;
+};
+export type CookieSessionStorageOptions = {
+    secret: string;
+    verificationSecrets?: readonly string[];
+    maxAgeMs?: number;
+    now?: () => number;
+    cookieName?: string;
+    cookie?: CookieOptions;
+    id?: () => string;
+};
+export declare const signCookieValue: (value: string, secret: string) => string;
+export declare const verifySignedCookieValue: (signedValue: string | undefined, secret: string) => string | undefined;
+export declare const parseCookies: (header: string | null | undefined) => Record<string, string>;
+export declare const serializeCookie: (name: string, value: string, options?: CookieOptions) => string;
+export declare const createMemorySessionStorage: <Data extends Record<string, unknown> = Record<string, unknown>>(options?: MemorySessionStorageOptions) => {
+    createSession: (data: Data) => Promise<Session<Data>>;
+    getSession: (cookieHeader: string | null | undefined) => Promise<Session<Data>>;
+    commitSession: (session: Session<Data>) => Promise<string>;
+    regenerateSession: (session: Session<Data>) => Promise<Session<Data>>;
+    destroySession: (session: Session<Data>) => Promise<string>;
+};
+export declare const createCookieSessionStorage: <Data extends Record<string, unknown> = Record<string, unknown>>(options: CookieSessionStorageOptions) => {
+    createSession: (data: Data) => Promise<Session<Data>>;
+    getSession: (cookieHeader: string | null | undefined) => Promise<Session<Data>>;
+    commitSession: (session: Session<Data>) => Promise<string>;
+    destroySession: (_session: Session<Data>) => Promise<string>;
+};