@ternkit/tern 0.0.0-stage → 0.4.0

package/dist/runtime/types.d.ts

@@ -0,0 +1,101 @@
+import type { Component } from 'svelte';
+/** A lazily imported Svelte component module. */
+export type ComponentLoader = () => Promise<{
+    default: Component<any>;
+}>;
+export interface LayoutEntry {
+    dir: string;
+    component: ComponentLoader | null;
+    hasLoad: boolean;
+}
+export interface ErrorEntry {
+    /** How many of the route's layouts wrap this error page. */
+    layouts: number;
+    component: ComponentLoader;
+}
+export interface RouteEntry {
+    layouts: number[];
+    page: ComponentLoader;
+    hasLoad: boolean;
+    errors: ErrorEntry[];
+}
+/** The client manifest generated by `tern gen` in .tern/generated/manifest.js. */
+export interface ClientManifest {
+    layouts: LayoutEntry[];
+    routes: Record<string, RouteEntry>;
+    fallback: {
+        layouts: number[];
+        errors: ErrorEntry[];
+    };
+}
+/** What the server sends for a page, inline or from __data.json. */
+export interface Payload {
+    type: 'data' | 'error' | 'redirect' | 'success' | 'failure';
+    route?: string;
+    params?: Record<string, string>;
+    status: number;
+    nodes?: (Record<string, unknown> | null)[];
+    failed?: number;
+    error?: {
+        message: string;
+    };
+    location?: string;
+    data?: unknown;
+    form?: unknown;
+    hasForm?: boolean;
+    /** What each node's load read, so the client knows when to rerun it. */
+    uses?: (NodeUses | null)[];
+    /** Nodes the server skipped because the client already has their data. */
+    reused?: number[];
+}
+export interface NodeUses {
+    url?: boolean;
+    params?: string[];
+    deps?: string[];
+    parent?: boolean;
+}
+/** The result of submitting a form action with `use:enhance`. */
+export type ActionResult<Success = Record<string, unknown>, Failure = Record<string, unknown>> = {
+    type: 'success';
+    status: number;
+    data?: Success;
+} | {
+    type: 'failure';
+    status: number;
+    data?: Failure;
+} | {
+    type: 'redirect';
+    status: number;
+    location: string;
+} | {
+    type: 'error';
+    status: number;
+    error: {
+        message: string;
+    };
+};
+export interface NavigationTarget {
+    url: URL;
+    params: Record<string, string> | null;
+    route: {
+        id: string | null;
+    };
+}
+export type NavigationType = 'enter' | 'link' | 'goto' | 'popstate' | 'form' | 'leave';
+export interface Navigation {
+    from: NavigationTarget | null;
+    to: NavigationTarget | null;
+    type: NavigationType;
+}
+export interface GotoOptions {
+    /** Replace the current history entry instead of adding one. */
+    replaceState?: boolean;
+    /** Keep the scroll position instead of scrolling to the top. */
+    noScroll?: boolean;
+    /** Keep focus on the currently focused element. */
+    keepFocus?: boolean;
+    /** Rerun every load, even for the current URL. */
+    invalidateAll?: boolean;
+    /** State to store in the history entry, available as page.state. */
+    state?: Record<string, unknown>;
+}

package/dist/runtime/types.js

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

package/dist/server/index.d.ts

@@ -0,0 +1,35 @@
+import type { Component } from 'svelte';
+/** The server manifest generated by `tern gen` in .tern/generated/server.js. */
+export interface ServerManifest {
+    layouts: {
+        component: Component<any> | null;
+    }[];
+    routes: Record<string, {
+        layouts: number[];
+        page: Component<any>;
+        errors: {
+            layouts: number;
+            component: Component<any>;
+        }[];
+    }>;
+    fallback: {
+        layouts: number[];
+        errors: {
+            layouts: number;
+            component: Component<any>;
+        }[];
+    };
+}
+/** The result of a server render, as JSON for the Go side. */
+export interface RenderResult {
+    head?: string;
+    body?: string;
+    /** True when the payload is not something the server renders. */
+    skip?: boolean;
+}
+/**
+ * Creates the function the Go server calls to render a page. It takes the
+ * same payload the client receives, so the server and the client render
+ * exactly the same tree and hydration matches.
+ */
+export declare function createRenderer(manifest: ServerManifest): (payload: string, href: string) => string;

package/dist/server/index.js

@@ -0,0 +1,40 @@
+import { render } from 'svelte/server';
+import DefaultError from '../runtime/DefaultError.svelte';
+import Passthrough from '../runtime/Passthrough.svelte';
+import Root from '../runtime/Root.svelte';
+import { revive } from '../runtime/deferred.js';
+import { plan } from '../runtime/select.js';
+import { applyPayloadToPage } from '../runtime/state.svelte.js';
+/**
+ * Creates the function the Go server calls to render a page. It takes the
+ * same payload the client receives, so the server and the client render
+ * exactly the same tree and hydration matches.
+ */
+export function createRenderer(manifest) {
+    const layout = (i) => manifest.layouts[i]?.component ?? Passthrough;
+    return (payloadJSON, href) => {
+        const p = JSON.parse(payloadJSON);
+        // Deferred values are still loading: render their pending state.
+        p.nodes = revive(p.nodes, () => new Promise(() => { }));
+        const what = plan(manifest, p);
+        let components;
+        switch (what.kind) {
+            case 'not-a-page':
+                return JSON.stringify({ skip: true });
+            case 'page':
+                components = [...what.layouts.map(layout), manifest.routes[what.route].page];
+                break;
+            case 'error': {
+                const errors = what.route ? manifest.routes[what.route].errors : manifest.fallback.errors;
+                components = [...what.layouts.map(layout), errors[what.errorIndex].component];
+                break;
+            }
+            case 'default-error':
+                components = [DefaultError];
+        }
+        applyPayloadToPage(p, new URL(href), {}, what.data);
+        const form = p.hasForm ? (p.form ?? null) : null;
+        const out = render(Root, { props: { components, data: what.data, form } });
+        return JSON.stringify({ head: out.head, body: out.body });
+    };
+}

package/dist/server/intl.d.ts

@@ -0,0 +1,100 @@
+type Opts = Record<string, unknown>;
+declare class NumberFormat {
+    #private;
+    constructor(_locale?: unknown, options?: Opts);
+    format(value: number | bigint): string;
+    formatToParts(value: number): {
+        type: string;
+        value: string;
+    }[];
+    resolvedOptions(): {
+        locale: string;
+        numberingSystem: string;
+    };
+    static supportedLocalesOf(): string[];
+}
+declare class DateTimeFormat {
+    #private;
+    constructor(_locale?: unknown, options?: Opts);
+    format(value?: Date | number): string;
+    formatToParts(value?: Date | number): {
+        type: string;
+        value: string;
+    }[];
+    formatRange(a: Date | number, b: Date | number): string;
+    resolvedOptions(): {
+        locale: string;
+        calendar: string;
+        numberingSystem: string;
+        timeZone: string;
+    };
+    static supportedLocalesOf(): string[];
+}
+declare class PluralRules {
+    select(n: number): "one" | "other";
+    resolvedOptions(): {
+        locale: string;
+        pluralCategories: string[];
+    };
+    static supportedLocalesOf(): string[];
+}
+declare class Collator {
+    #private;
+    constructor(_locale?: unknown, options?: Opts);
+    compare: (a: string, b: string) => number;
+    resolvedOptions(): {
+        locale: string;
+        usage: string;
+        sensitivity: string;
+    };
+    static supportedLocalesOf(): string[];
+}
+declare class RelativeTimeFormat {
+    format(value: number, unit: string): string;
+    static supportedLocalesOf(): string[];
+}
+declare class ListFormat {
+    #private;
+    constructor(_locale?: unknown, options?: Opts);
+    format(list: Iterable<string>): string;
+    static supportedLocalesOf(): string[];
+}
+declare class Locale {
+    baseName: string;
+    language: string;
+    region?: string;
+    constructor(tag?: string);
+    get weekInfo(): {
+        firstDay: number;
+        weekend: number[];
+        minimalDays: number;
+    };
+    getWeekInfo(): {
+        firstDay: number;
+        weekend: number[];
+        minimalDays: number;
+    };
+    maximize(): this;
+    minimize(): this;
+    toString(): string;
+}
+declare class Segmenter {
+    segment(input: string): {
+        segment: string;
+        index: number;
+        input: string;
+    }[];
+}
+export declare const IntlShim: {
+    NumberFormat: typeof NumberFormat;
+    DateTimeFormat: typeof DateTimeFormat;
+    PluralRules: typeof PluralRules;
+    Collator: typeof Collator;
+    RelativeTimeFormat: typeof RelativeTimeFormat;
+    ListFormat: typeof ListFormat;
+    Locale: typeof Locale;
+    Segmenter: typeof Segmenter;
+    getCanonicalLocales: (l?: string | string[]) => string[];
+    supportedValuesOf: () => never[];
+};
+export {};

package/dist/server/intl.js

@@ -0,0 +1,222 @@
+// A small Intl for the server renderer. The embedded engine (QuickJS) has
+// no Intl, and many libraries create formatters when they load. This shim
+// formats like en-US, which is good enough for server-rendered HTML: the
+// browser hydrates with the user's real Intl and locale.
+const MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+const DAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+function group(int) {
+    return int.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+class NumberFormat {
+    #o;
+    constructor(_locale, options = {}) {
+        this.#o = options;
+    }
+    format(value) {
+        let n = Number(value);
+        const o = this.#o;
+        if (!Number.isFinite(n))
+            return Number.isNaN(n) ? 'NaN' : n > 0 ? '∞' : '-∞';
+        let suffix = '';
+        if (o.style === 'percent') {
+            n *= 100;
+            suffix = '%';
+        }
+        if (o.notation === 'compact') {
+            const abs = Math.abs(n);
+            for (const [limit, s] of [[1e12, 'T'], [1e9, 'B'], [1e6, 'M'], [1e3, 'K']]) {
+                if (abs >= limit) {
+                    n /= limit;
+                    suffix = s + suffix;
+                    break;
+                }
+            }
+        }
+        const isCurrency = o.style === 'currency';
+        const max = o.maximumFractionDigits ?? (isCurrency ? 2 : o.notation === 'compact' ? 1 : 3);
+        const min = o.minimumFractionDigits ?? (isCurrency ? 2 : 0);
+        let s = Math.abs(n).toFixed(Math.max(min, Math.min(max, 20)));
+        if (s.includes('.')) {
+            let [int, frac = ''] = s.split('.');
+            while (frac.length > min && frac.endsWith('0'))
+                frac = frac.slice(0, -1);
+            s = frac ? `${int}.${frac}` : int;
+        }
+        const [int, frac] = s.split('.');
+        s = (o.useGrouping === false ? int : group(int)) + (frac ? `.${frac}` : '');
+        if (isCurrency) {
+            const code = String(o.currency ?? 'USD').toUpperCase();
+            s = (code === 'USD' ? '$' : code === 'EUR' ? '€' : code === 'GBP' ? '£' : `${code} `) + s;
+        }
+        return (n < 0 ? '-' : '') + s + suffix;
+    }
+    formatToParts(value) {
+        return [{ type: 'literal', value: this.format(value) }];
+    }
+    resolvedOptions() {
+        return { locale: 'en-US', numberingSystem: 'latn', ...this.#o };
+    }
+    static supportedLocalesOf() {
+        return ['en-US'];
+    }
+}
+class DateTimeFormat {
+    #o;
+    constructor(_locale, options = {}) {
+        this.#o = options;
+    }
+    format(value) {
+        const d = value === undefined ? new Date() : new Date(value);
+        if (Number.isNaN(d.getTime()))
+            return 'Invalid Date';
+        const o = this.#o;
+        const utc = o.timeZone === 'UTC';
+        const get = {
+            y: utc ? d.getUTCFullYear() : d.getFullYear(),
+            m: utc ? d.getUTCMonth() : d.getMonth(),
+            d: utc ? d.getUTCDate() : d.getDate(),
+            w: utc ? d.getUTCDay() : d.getDay(),
+            h: utc ? d.getUTCHours() : d.getHours(),
+            min: utc ? d.getUTCMinutes() : d.getMinutes()
+        };
+        const hasDate = o.year || o.month || o.day || o.weekday || o.dateStyle;
+        const hasTime = o.hour || o.minute || o.timeStyle;
+        const parts = [];
+        if (hasDate || !hasTime) {
+            const month = o.month ?? (o.dateStyle ? 'short' : 'numeric');
+            if (o.weekday)
+                parts.push((o.weekday === 'long' ? DAYS[get.w] : DAYS[get.w].slice(0, 3)) + ',');
+            if (month === 'numeric' || month === '2-digit') {
+                parts.push(`${get.m + 1}/${get.d}/${get.y}`);
+            }
+            else {
+                const name = month === 'long' ? MONTHS[get.m] : MONTHS[get.m].slice(0, 3);
+                const day = o.day !== undefined || o.dateStyle ? ` ${get.d}` : '';
+                const year = o.year !== undefined || o.dateStyle ? `, ${get.y}` : '';
+                parts.push(name + day + (day ? year : year.replace(', ', ' ')));
+            }
+        }
+        if (hasTime) {
+            const h12 = o.hour12 !== false;
+            const hour = h12 ? get.h % 12 || 12 : get.h;
+            const mm = String(get.min).padStart(2, '0');
+            parts.push(`${hour}:${mm}${h12 ? (get.h < 12 ? ' AM' : ' PM') : ''}`);
+        }
+        return parts.join(' ');
+    }
+    formatToParts(value) {
+        return [{ type: 'literal', value: this.format(value) }];
+    }
+    formatRange(a, b) {
+        return `${this.format(a)} – ${this.format(b)}`;
+    }
+    resolvedOptions() {
+        return { locale: 'en-US', calendar: 'gregory', numberingSystem: 'latn', timeZone: 'UTC', ...this.#o };
+    }
+    static supportedLocalesOf() {
+        return ['en-US'];
+    }
+}
+class PluralRules {
+    select(n) {
+        return n === 1 ? 'one' : 'other';
+    }
+    resolvedOptions() {
+        return { locale: 'en-US', pluralCategories: ['one', 'other'] };
+    }
+    static supportedLocalesOf() {
+        return ['en-US'];
+    }
+}
+class Collator {
+    #numeric;
+    constructor(_locale, options = {}) {
+        this.#numeric = options.numeric === true;
+    }
+    compare = (a, b) => {
+        if (this.#numeric) {
+            const na = Number(a);
+            const nb = Number(b);
+            if (!Number.isNaN(na) && !Number.isNaN(nb))
+                return na - nb;
+        }
+        const x = String(a).toLowerCase();
+        const y = String(b).toLowerCase();
+        return x < y ? -1 : x > y ? 1 : 0;
+    };
+    resolvedOptions() {
+        return { locale: 'en-US', usage: 'sort', sensitivity: 'variant' };
+    }
+    static supportedLocalesOf() {
+        return ['en-US'];
+    }
+}
+class RelativeTimeFormat {
+    format(value, unit) {
+        const u = unit.replace(/s$/, '');
+        const n = Math.abs(value);
+        const label = `${n} ${u}${n === 1 ? '' : 's'}`;
+        return value < 0 ? `${label} ago` : `in ${label}`;
+    }
+    static supportedLocalesOf() {
+        return ['en-US'];
+    }
+}
+class ListFormat {
+    #type;
+    constructor(_locale, options = {}) {
+        this.#type = options.type === 'disjunction' ? 'or' : 'and';
+    }
+    format(list) {
+        const items = [...list];
+        if (items.length < 3)
+            return items.join(` ${this.#type} `);
+        return `${items.slice(0, -1).join(', ')}, ${this.#type} ${items[items.length - 1]}`;
+    }
+    static supportedLocalesOf() {
+        return ['en-US'];
+    }
+}
+class Locale {
+    baseName;
+    language;
+    region;
+    constructor(tag = 'en-US') {
+        this.baseName = String(tag);
+        const [language, region] = this.baseName.split(/[-_]/);
+        this.language = language || 'en';
+        this.region = region;
+    }
+    get weekInfo() {
+        return this.getWeekInfo();
+    }
+    getWeekInfo() {
+        return { firstDay: 7, weekend: [6, 7], minimalDays: 1 };
+    }
+    maximize() {
+        return this;
+    }
+    minimize() {
+        return this;
+    }
+    toString() {
+        return this.baseName;
+    }
+}
+class Segmenter {
+    segment(input) {
+        return [...input].map((segment, index) => ({ segment, index, input }));
+    }
+}
+export const IntlShim = {
+    NumberFormat,
+    DateTimeFormat,
+    PluralRules,
+    Collator,
+    RelativeTimeFormat,
+    ListFormat,
+    Locale,
+    Segmenter,
+    getCanonicalLocales: (l) => (l === undefined ? [] : Array.isArray(l) ? l : [l]),
+    supportedValuesOf: () => []
+};

package/dist/server/polyfills.d.ts

@@ -0,0 +1,2 @@
+import 'core-js/actual/url';
+import 'core-js/actual/url-search-params';

package/dist/server/polyfills.js

@@ -0,0 +1,47 @@
+// Web APIs the server-side renderer needs. Tern renders in an embedded
+// JavaScript engine (QuickJS) that only implements the language itself.
+// Each polyfill is skipped where the API already exists, such as in Node
+// during development.
+import 'core-js/actual/url';
+import 'core-js/actual/url-search-params';
+import { IntlShim } from './intl.js';
+const g = globalThis;
+// Some libraries read process.env.SOMETHING at runtime. Give them an empty
+// environment instead of a ReferenceError.
+if (typeof g.process === 'undefined') {
+    g.process = { env: { NODE_ENV: 'production' }, browser: false, version: '', versions: {} };
+}
+if (typeof g.Intl === 'undefined') {
+    g.Intl = IntlShim;
+}
+if (typeof g.queueMicrotask !== 'function') {
+    g.queueMicrotask = (fn) => void Promise.resolve().then(fn);
+}
+if (typeof g.console === 'undefined') {
+    const format = (args) => args
+        .map((a) => {
+        if (typeof a === 'string')
+            return a;
+        if (a instanceof Error)
+            return a.stack ?? a.message;
+        try {
+            return JSON.stringify(a);
+        }
+        catch {
+            return String(a);
+        }
+    })
+        .join(' ');
+    const log = (level) => (...args) => {
+        if (typeof __tern_log === 'function')
+            __tern_log(level, format(args));
+    };
+    g.console = {
+        log: log('info'),
+        info: log('info'),
+        debug: log('debug'),
+        warn: log('warn'),
+        error: log('error'),
+        trace: log('debug')
+    };
+}

package/dist/vite/index.d.ts

@@ -0,0 +1,23 @@
+import { type Options as SvelteOptions } from '@sveltejs/vite-plugin-svelte';
+import type { Plugin } from 'vite';
+export interface TernOptions {
+    /** Options passed to @sveltejs/vite-plugin-svelte. */
+    svelte?: Partial<SvelteOptions>;
+}
+/**
+ * The Vite plugin for Tern apps. It includes the Svelte plugin, so it is
+ * the only plugin a Tern app needs:
+ *
+ * ```js
+ * // vite.config.js
+ * import { tern } from '@ternkit/tern/vite';
+ * import { defineConfig } from 'vite';
+ *
+ * export default defineConfig({ plugins: [tern()] });
+ * ```
+ *
+ * `vite build` builds the client; `vite build --ssr` builds the server
+ * renderer that `tern build` embeds in the Go binary.
+ */
+export declare function tern(options?: TernOptions): Plugin[];
+export default tern;