tachyon-dom 0.1.0

package/dist/language-server.js

@@ -0,0 +1,79 @@
+import { createConnection, DiagnosticSeverity, ProposedFeatures, TextDocumentSyncKind, TextDocuments, } from "vscode-languageserver/node";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { diagnoseTachyonSfc } from "./diagnostics.js";
+const source = "tachyon-dom";
+export const diagnosticsForTachyonDocument = (text) => {
+    const result = diagnoseTachyonSfc(text);
+    if (result.ok) {
+        return [];
+    }
+    const diagnostic = result.error;
+    const line = Math.max(0, diagnostic.line - 1);
+    const character = Math.max(0, diagnostic.column - 1);
+    const endLine = Math.max(line, diagnostic.endLine - 1);
+    const endCharacter = Math.max(0, diagnostic.endColumn - 1);
+    return [
+        {
+            message: diagnostic.message,
+            range: {
+                start: { line, character },
+                end: { line: endLine, character: endCharacter },
+            },
+            severity: DiagnosticSeverity.Error,
+            source,
+        },
+    ];
+};
+export const createDiagnosticsScheduler = (sendDiagnostics, delayMs = 80) => {
+    const pending = new Map();
+    const clear = (uri) => {
+        const timer = pending.get(uri);
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            pending.delete(uri);
+        }
+    };
+    return {
+        schedule: (document) => {
+            clear(document.uri);
+            pending.set(document.uri, setTimeout(() => {
+                pending.delete(document.uri);
+                sendDiagnostics({
+                    uri: document.uri,
+                    diagnostics: diagnosticsForTachyonDocument(document.getText()),
+                });
+            }, delayMs));
+        },
+        clear,
+        dispose: () => {
+            for (const timer of pending.values()) {
+                clearTimeout(timer);
+            }
+            pending.clear();
+        },
+    };
+};
+export const startLanguageServer = (connection = createConnection(ProposedFeatures.all)) => {
+    const documents = new TextDocuments(TextDocument);
+    const diagnostics = createDiagnosticsScheduler((payload) => connection.sendDiagnostics(payload));
+    connection.onInitialize(() => ({
+        capabilities: {
+            textDocumentSync: TextDocumentSyncKind.Incremental,
+        },
+    }));
+    documents.onDidOpen((event) => {
+        connection.sendDiagnostics({
+            uri: event.document.uri,
+            diagnostics: diagnosticsForTachyonDocument(event.document.getText()),
+        });
+    });
+    documents.onDidChangeContent((event) => {
+        diagnostics.schedule(event.document);
+    });
+    documents.onDidClose((event) => {
+        diagnostics.clear(event.document.uri);
+        connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
+    });
+    documents.listen(connection);
+    connection.listen();
+};

package/dist/package-integrity.d.ts

@@ -0,0 +1,9 @@
+import { type Result } from "./result.js";
+export type PackageArtifactCheckOptions = {
+    packageDir: string;
+    checkPack?: boolean;
+};
+export type PackageArtifactCheck = {
+    checkedFiles: string[];
+};
+export declare const verifyPackageArtifacts: (options: PackageArtifactCheckOptions) => Promise<Result<PackageArtifactCheck, string>>;

package/dist/package-integrity.js

@@ -0,0 +1,64 @@
+import { execFile } from "node:child_process";
+import { access, readFile } from "node:fs/promises";
+import { promisify } from "node:util";
+import { err, ok } from "./result.js";
+const execFileAsync = promisify(execFile);
+const isDistReference = (value) => value.startsWith("./dist/");
+const normalizePackagePath = (value) => value.replace(/^\.\//, "");
+const collectExportReferences = (value, label, references) => {
+    if (typeof value === "string") {
+        if (isDistReference(value)) {
+            references.push({ label, path: value });
+        }
+        return;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return;
+    }
+    for (const [key, nested] of Object.entries(value)) {
+        collectExportReferences(nested, `${label}.${key}`, references);
+    }
+};
+const collectArtifactReferences = (packageJson) => {
+    const references = [];
+    if (typeof packageJson.bin === "string") {
+        references.push({ label: "bin", path: packageJson.bin });
+    }
+    else if (packageJson.bin) {
+        for (const [name, value] of Object.entries(packageJson.bin)) {
+            references.push({ label: `bin.${name}`, path: value });
+        }
+    }
+    collectExportReferences(packageJson.exports, "exports", references);
+    return references.filter((reference) => isDistReference(reference.path));
+};
+const packedFilesFor = async (packageDir) => {
+    const { stdout } = await execFileAsync("npm", ["pack", "--dry-run", "--json"], { cwd: packageDir });
+    const [pack] = JSON.parse(stdout);
+    return new Set((pack?.files ?? []).flatMap((file) => (file.path ? [file.path] : [])));
+};
+export const verifyPackageArtifacts = async (options) => {
+    const packageJson = JSON.parse(await readFile(`${options.packageDir}/package.json`, "utf8"));
+    const references = collectArtifactReferences(packageJson);
+    const missing = [];
+    for (const reference of references) {
+        try {
+            await access(`${options.packageDir}/${normalizePackagePath(reference.path)}`);
+        }
+        catch {
+            missing.push(`${reference.label} -> ${reference.path}`);
+        }
+    }
+    if (options.checkPack !== false) {
+        const packedFiles = await packedFilesFor(options.packageDir);
+        for (const reference of references) {
+            if (!packedFiles.has(normalizePackagePath(reference.path))) {
+                missing.push(`${reference.label} -> ${reference.path} is not included in npm pack output`);
+            }
+        }
+    }
+    if (missing.length > 0) {
+        return err(`Package artifact verification failed:\n${missing.map((item) => `- ${item}`).join("\n")}`);
+    }
+    return ok({ checkedFiles: references.map((reference) => normalizePackagePath(reference.path)).sort() });
+};

package/dist/result.d.ts

@@ -0,0 +1,13 @@
+export type Ok<T> = {
+    readonly ok: true;
+    readonly value: T;
+};
+export type Err<E> = {
+    readonly ok: false;
+    readonly error: E;
+};
+export type Result<T, E> = Ok<T> | Err<E>;
+export declare const ok: <T>(value: T) => Ok<T>;
+export declare const err: <E>(error: E) => Err<E>;
+export declare const isOk: <T, E>(result: Result<T, E>) => result is Ok<T>;
+export declare const isErr: <T, E>(result: Result<T, E>) => result is Err<E>;

package/dist/result.js

@@ -0,0 +1,4 @@
+export const ok = (value) => ({ ok: true, value });
+export const err = (error) => ({ ok: false, error });
+export const isOk = (result) => result.ok;
+export const isErr = (result) => !result.ok;

package/dist/router-node.d.ts

@@ -0,0 +1,2 @@
+import { type FileRouteManifestEntry } from "./router.js";
+export declare const scanFileRoutes: (rootDir: string) => Promise<FileRouteManifestEntry[]>;

package/dist/router-node.js

@@ -0,0 +1,12 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import { createFileRouteManifest } from "./router.js";
+const collectFiles = async (directory) => {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+        const absolute = path.join(directory, entry.name);
+        return entry.isDirectory() ? await collectFiles(absolute) : [absolute];
+    }));
+    return files.flat();
+};
+export const scanFileRoutes = async (rootDir) => createFileRouteManifest(await collectFiles(rootDir), { rootDir });

package/dist/router.d.ts

@@ -0,0 +1,324 @@
+import { type Result } from "./result.js";
+import { type HtmlWhitespacePolicy } from "./html-whitespace.js";
+export type RouteParams = Record<string, string>;
+export type ParamsForPath<Path extends string> = Path extends `${string}:${infer Param}/${infer Rest}` ? {
+    [Key in Param | keyof ParamsForPath<`/${Rest}`>]: string;
+} : Path extends `${string}:${infer Param}` ? {
+    [Key in Param]: string;
+} : Path extends `${string}*${infer Param}/${infer Rest}` ? {
+    [Key in Param | keyof ParamsForPath<`/${Rest}`>]: string;
+} : Path extends `${string}*${infer Param}` ? {
+    [Key in Param]: string;
+} : {};
+export type RouteResource = {
+    rel: "stylesheet" | "modulepreload" | "preload" | "prefetch";
+    href: string;
+    as?: string;
+    type?: string;
+    crossorigin?: string;
+    fetchpriority?: "high" | "low" | "auto";
+};
+export type RouteHeadDescriptor = {
+    title?: string;
+    metas?: Array<Record<string, string>>;
+    links?: Array<Record<string, string>>;
+    scripts?: Array<Record<string, string>>;
+};
+export type TrustedHtml = {
+    __tachyonTrustedHtml: true;
+    value: string;
+};
+export type RouteContext<Data = unknown, ActionResult = unknown> = {
+    request: Request;
+    url: URL;
+    params: RouteParams;
+    route: RouteDefinition;
+    env: RouteEnvironment;
+    data: Data;
+    loaderData: Record<string, unknown>;
+    actionResult: ActionResult;
+    outlet: string;
+};
+export type RouteEnvironment = Record<string, string | undefined>;
+export type RouteCachePolicy = {
+    mode?: "public" | "private" | "no-store";
+    maxAge?: number;
+    sharedMaxAge?: number;
+    staleWhileRevalidate?: number;
+    staleIfError?: number;
+    immutable?: boolean;
+    tags?: readonly string[];
+};
+export type RouteDefinition<Data = unknown, ActionResult = unknown> = {
+    id?: string;
+    path: string;
+    loader?: (context: Omit<RouteContext<Data, ActionResult>, "data" | "outlet">) => Data | Promise<Data>;
+    action?: (context: Omit<RouteContext<Data, ActionResult>, "data" | "outlet">) => ActionResult | Promise<ActionResult>;
+    head?: (descriptor: RouteContext<Data, ActionResult>) => RouteHeadDescriptor | Promise<RouteHeadDescriptor> | RouteHeadDescriptor;
+    resources?: readonly RouteResource[] | ((context: RouteContext<Data, ActionResult>) => readonly RouteResource[]);
+    headers?: HeadersInit | ((context: RouteContext<Data, ActionResult>) => HeadersInit | Promise<HeadersInit>);
+    cache?: RouteCachePolicy | ((context: RouteContext<Data, ActionResult>) => RouteCachePolicy | Promise<RouteCachePolicy>);
+    fallback?: string;
+    error?: (context: {
+        request: Request;
+        url: URL;
+        error: unknown;
+    }) => string | Promise<string>;
+    notFound?: (context: {
+        request: Request;
+        url: URL;
+    }) => string | Promise<string>;
+    /**
+     * Streams the deepest matched route after loaders and authoritative metadata resolve.
+     * Every string is trusted raw HTML: adapters do not escape or sanitize chunks. Use
+     * trustedHtmlChunk(escapeToHtml(value)) for untrusted text and a vetted sanitizer
+     * followed by trustedHtmlChunk() for intentionally accepted markup.
+     */
+    stream?: (context: RouteContext<Data, ActionResult>) => AsyncIterable<string>;
+    render: (context: RouteContext<Data, ActionResult>) => string | Promise<string>;
+    children?: RouteDefinition[];
+};
+export type RouteManifestEntry = {
+    id: string;
+    path: string;
+    parentId?: string;
+};
+export type FileRouteManifestEntry = {
+    id: string;
+    path: string;
+    file: string;
+    kind: "template" | "module" | "layout";
+};
+export type MatchedRoute = {
+    route: RouteDefinition;
+    branch: Array<{
+        route: RouteDefinition;
+        path: string;
+        params: RouteParams;
+    }>;
+    params: RouteParams;
+    pathname: string;
+};
+export type RouteRenderResult = {
+    status: number;
+    html: string;
+    headHtml: string;
+    resourceHints: string;
+    stateScript: string;
+    loaderData: Record<string, unknown>;
+    actionResult: unknown;
+    match: MatchedRoute;
+    headers: Headers;
+    responseBody?: string;
+    responseChunks?: AsyncIterable<string>;
+};
+type RouteRenderOptionsBase = {
+    notFound?: (context: {
+        request: Request;
+        url: URL;
+    }) => string | Promise<string>;
+    error?: (context: {
+        request: Request;
+        url: URL;
+        error: unknown;
+    }) => string | Promise<string>;
+    allowedMethods?: readonly string[];
+    maxActionBodyBytes?: number;
+    cspNonce?: string;
+    csrf?: {
+        verify: (context: {
+            request: Request;
+            url: URL;
+            env: RouteEnvironment;
+        }) => boolean | Promise<boolean>;
+    };
+    middleware?: readonly RouteMiddleware[];
+    hooks?: RouteHooks;
+    env?: RouteEnvironment;
+};
+export type RouteRenderOptions = RouteRenderOptionsBase & {
+    /** Applied only after buffered rendering. Streaming chunks are always preserved. */
+    htmlWhitespace?: HtmlWhitespacePolicy;
+};
+export type RouteError = {
+    message: string;
+    status: number;
+};
+export type RouteModule<Data = unknown, ActionResult = unknown> = {
+    path?: string;
+    loader?: RouteDefinition<Data, ActionResult>["loader"];
+    action?: RouteDefinition<Data, ActionResult>["action"];
+    head?: RouteDefinition<Data, ActionResult>["head"];
+    resources?: RouteDefinition<Data, ActionResult>["resources"];
+    headers?: RouteDefinition<Data, ActionResult>["headers"];
+    cache?: RouteDefinition<Data, ActionResult>["cache"];
+    fallback?: string;
+    stream?: RouteDefinition<Data, ActionResult>["stream"];
+    template?: RouteDefinition<Data, ActionResult>["render"];
+    render?: RouteDefinition<Data, ActionResult>["render"];
+    ErrorBoundary?: (context: {
+        request: Request;
+        url: URL;
+        error: unknown;
+    }) => string | Promise<string>;
+    NotFound?: (context: {
+        request: Request;
+        url: URL;
+    }) => string | Promise<string>;
+    children?: RouteDefinition[];
+};
+export type RouteResponse = {
+    __tachyonRouteResponse: true;
+    status: number;
+    headers: Headers;
+    body: string;
+};
+export type RouteMiddlewareResult = Request | Response | RouteResponse | void;
+export type RouteMiddleware = (context: {
+    request: Request;
+    url: URL;
+    env: RouteEnvironment;
+}) => RouteMiddlewareResult | Promise<RouteMiddlewareResult>;
+export type RouteHooks = {
+    onRequest?: (context: {
+        request: Request;
+        url: URL;
+    }) => void | Promise<void>;
+    onMatch?: (context: {
+        request: Request;
+        url: URL;
+        match: MatchedRoute;
+    }) => void | Promise<void>;
+    onLoader?: (context: {
+        request: Request;
+        url: URL;
+        route: RouteDefinition;
+        data: unknown;
+    }) => void | Promise<void>;
+    onAction?: (context: {
+        request: Request;
+        url: URL;
+        route: RouteDefinition;
+        result: unknown;
+    }) => void | Promise<void>;
+    onRender?: (context: {
+        request: Request;
+        url: URL;
+        html: string;
+        match: MatchedRoute;
+    }) => void | Promise<void>;
+    onError?: (context: {
+        request: Request;
+        url: URL;
+        error: unknown;
+        match?: MatchedRoute;
+    }) => void | Promise<void>;
+};
+export type DeferredData<T extends Record<string, unknown> = Record<string, unknown>> = {
+    __tachyonDeferredData: true;
+    immediate: Partial<T>;
+    pending: Partial<{
+        [Key in keyof T]: Promise<Awaited<T[Key]>>;
+    }>;
+};
+export type RouteBuildManifest = {
+    buildId: string;
+    routes: RouteManifestEntry[];
+    assets: Record<string, string[]>;
+    types: string;
+};
+export type RoutePreloadEntry = {
+    href: string;
+    rel: "modulepreload" | "preload" | "prefetch";
+    as?: string;
+};
+export type UserGuardOptions<User> = {
+    redirectTo?: string;
+    forbidden?: (context: {
+        request: Request;
+        url: URL;
+    }) => RouteResponse | Response;
+    getRedirect?: (context: {
+        request: Request;
+        url: URL;
+    }) => string;
+    onUser?: (context: {
+        request: Request;
+        url: URL;
+        user: User;
+    }) => void | Promise<void>;
+};
+export declare const isDeferredData: (value: unknown) => value is DeferredData;
+export type RedirectOptions = ResponseInit & {
+    allowExternal?: boolean;
+    allowedOrigins?: readonly string[];
+};
+export declare const redirect: (location: string, init?: RedirectOptions) => RouteResponse;
+export declare const json: (data: unknown, init?: ResponseInit) => RouteResponse;
+export declare const unsafeHtml: (value: string) => TrustedHtml;
+export declare const escapeToHtml: (value: unknown) => TrustedHtml;
+/**
+ * Converts a factory-created TrustedHtml value into a raw progressive response chunk.
+ * Route stream chunks are inserted as HTML without adapter escaping. Escape untrusted
+ * text with escapeToHtml(), or sanitize intentional markup with a vetted sanitizer,
+ * before calling this helper.
+ */
+export declare const trustedHtmlChunk: (value: TrustedHtml) => string;
+export declare const html: (body: TrustedHtml, init?: ResponseInit) => RouteResponse;
+export declare const cacheControl: (policy: RouteCachePolicy) => Headers;
+export declare const withCacheHeaders: (response: Response, policy: RouteCachePolicy) => Response;
+export declare const defer: <T extends Record<string, unknown>>(values: T) => DeferredData<T>;
+export declare const resolveDeferredData: <T extends Record<string, unknown>>(data: DeferredData<T>) => Promise<T>;
+export declare const renderDeferredDataScript: <T extends Record<string, unknown>>(id: string, data: DeferredData<T>, options?: {
+    nonce?: string;
+}) => Promise<string>;
+export declare const createSecurityHeaders: (options?: {
+    nonce?: string;
+    csp?: boolean;
+    hsts?: boolean;
+    frameAncestors?: string;
+}) => Headers;
+export declare const applySecurityHeaders: (response: Response, headers: Headers) => Response;
+export declare const requireUser: <User>(getUser: (context: {
+    request: Request;
+    url: URL;
+}) => User | undefined | null | Promise<User | undefined | null>, options?: UserGuardOptions<User>) => RouteMiddleware;
+export declare const defineRouteModule: <Data = unknown, ActionResult = unknown>(module: RouteModule<Data, ActionResult>) => RouteModule<Data, ActionResult>;
+export declare const routeFromModule: <Data = unknown, ActionResult = unknown>(id: string, module: RouteModule<Data, ActionResult>) => RouteDefinition<Data, ActionResult>;
+export declare const createFileRouteManifest: (files: readonly string[], options: {
+    rootDir: string;
+}) => FileRouteManifestEntry[];
+export declare const createRouteManifest: (routes: readonly RouteDefinition[], parentPath?: string, parentId?: string) => RouteManifestEntry[];
+export declare const generateRouteTypes: (manifest: readonly Pick<RouteManifestEntry, "id" | "path">[]) => string;
+export declare const createRouteBuildManifest: (routes: readonly RouteDefinition[], options: {
+    buildId: string;
+    assets?: readonly {
+        routeId: string;
+        files: readonly string[];
+    }[];
+}) => RouteBuildManifest;
+export declare const hrefForRoute: (manifest: readonly Pick<RouteManifestEntry, "id" | "path">[], id: string, params?: RouteParams) => string;
+export declare const createHrefBuilder: <Manifest extends readonly Pick<RouteManifestEntry, "id" | "path">[]>(manifest: Manifest) => <Id extends Manifest[number]["id"]>(id: Id, params?: RouteParams) => string;
+export declare const createRoutePreloadPlan: (manifest: RouteBuildManifest, routeId: string) => RoutePreloadEntry[];
+export declare const matchRoute: (routes: readonly RouteDefinition[], input: string | URL) => Result<MatchedRoute, RouteError>;
+export declare const renderHead: (descriptor: RouteHeadDescriptor, options?: {
+    nonce?: string;
+}) => string;
+export declare const renderResourceHints: (resources: readonly RouteResource[]) => string;
+export declare const collectRouteResources: (branch: readonly {
+    route: RouteDefinition;
+    path: string;
+    params: RouteParams;
+}[], context?: Partial<RouteContext>) => RouteResource[];
+export declare const renderRoute: (routes: readonly RouteDefinition[], input: Request | URL | string, options?: RouteRenderOptions) => Promise<Result<RouteRenderResult, RouteError>>;
+export type RouteStreamResult = {
+    status: number;
+    chunks: AsyncIterable<string>;
+    headHtml: string;
+    resourceHints: string;
+    stateScript: string;
+    headers: Headers;
+    final: Promise<Pick<RouteRenderResult, "headHtml" | "resourceHints" | "stateScript" | "headers" | "status">>;
+};
+export declare const renderRouteStream: (routes: readonly RouteDefinition[], input: Request | URL | string, options?: RouteRenderOptions) => Promise<Result<RouteStreamResult, RouteError>>;
+export {};