@tiaforge-ui/sinter 0.0.0-stage → 0.2.0

package/dist/lsp/workspace.d.ts

@@ -0,0 +1,56 @@
+import type { CheckUnit } from '../compiler/check-unit.js';
+import { type Diagnostic } from '../compiler/index.js';
+import { type Project, type ProjectOptions } from '../project.js';
+export interface ProjectState {
+    root: string;
+    options: ProjectOptions;
+    project: Project;
+    /** HTML entries from the Vite config */
+    entries: Set<string>;
+    /** every page compiled so far (entries, plus open HTML files no page includes) */
+    pages: Set<string>;
+    /** per page: the files it includes */
+    includes: Map<string, string[]>;
+    /** per page: its last compile's diagnostics */
+    diagnostics: Map<string, Diagnostic[]>;
+    /** per page: its last compile's check unit */
+    units: Map<string, CheckUnit>;
+    /** TypeScript's diagnostics, per page (or per check run); they lag behind compiles */
+    types: Map<string, Diagnostic[]>;
+    /** files whose change reloads the project: Vite config, helpers, types, specs */
+    inputs: Set<string>;
+}
+export interface WorkspaceHooks {
+    /** the diagnostics of `file` changed (an empty list clears them) */
+    publish(file: string, diagnostics: Diagnostic[]): void;
+    /** pages were compiled; their check units are in `state.units` */
+    compiled?(state: ProjectState, pages: string[]): void;
+}
+export declare class Workspace {
+    private hooks;
+    /** open buffers by absolute path */
+    readonly docs: Map<string, string>;
+    readonly projects: Map<string, Promise<ProjectState>>;
+    /** files that currently have diagnostics published */
+    private published;
+    constructor(hooks: WorkspaceHooks);
+    /** The project a file belongs to: the nearest folder with a Vite config, else with a package.json. */
+    rootOf(file: string): string;
+    projectFor(file: string): Promise<ProjectState>;
+    private load;
+    open(file: string, text: string): Promise<void>;
+    change(file: string, text: string): Promise<void>;
+    close(file: string): Promise<void>;
+    /** A file changed on disk (saved, or changed by another program). */
+    fileChanged(file: string): Promise<void>;
+    /** a non-HTML file: reload projects that read it */
+    private otherChanged;
+    private htmlChanged;
+    /** the text of a file: the open buffer, else the disk */
+    read(file: string): string;
+    private compilePages;
+    /** Sets TypeScript's diagnostics under `key` (a page) and publishes. Ignored for a replaced project state. */
+    setTypes(state: ProjectState, key: string, list: Diagnostic[]): Promise<void>;
+    /** Publishes every file's diagnostics, merged across the pages that include it. */
+    private publishAll;
+}

package/dist/lsp/workspace.js

@@ -0,0 +1,228 @@
+// What the language server knows: the projects under the editor's folders, their
+// pages and partials, open buffers, and the diagnostics of each file. Independent of
+// LSP itself, so tests drive it directly.
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { compile } from '../compiler/index.js';
+import { project, viteProject } from '../project.js';
+const VITE_CONFIGS = ['vite.config.ts', 'vite.config.js', 'vite.config.mts', 'vite.config.mjs', 'vite.config.cts', 'vite.config.cjs'];
+export class Workspace {
+    hooks;
+    /** open buffers by absolute path */
+    docs = new Map();
+    projects = new Map();
+    /** files that currently have diagnostics published */
+    published = new Set();
+    constructor(hooks) {
+        this.hooks = hooks;
+    }
+    /** The project a file belongs to: the nearest folder with a Vite config, else with a package.json. */
+    rootOf(file) {
+        let pkg = null;
+        for (let dir = dirname(file);; dir = dirname(dir)) {
+            if (VITE_CONFIGS.some((c) => existsSync(join(dir, c))))
+                return dir;
+            if (!pkg && existsSync(join(dir, 'package.json')))
+                pkg = dir;
+            if (dirname(dir) === dir)
+                return pkg ?? dirname(file);
+        }
+    }
+    projectFor(file) {
+        const root = this.rootOf(file);
+        let p = this.projects.get(root);
+        if (!p) {
+            p = this.load(root);
+            this.projects.set(root, p);
+        }
+        return p;
+    }
+    async load(root) {
+        let pages = [];
+        let options = {};
+        try {
+            ({ pages, options } = await viteProject(root));
+        }
+        catch (e) {
+            process.stderr.write(`sinter lsp: reading the Vite config in ${root} failed: ${e.message}\n`);
+        }
+        const p = project(root, options);
+        const inputs = new Set(VITE_CONFIGS.map((c) => join(root, c)));
+        for (const f of [p.helpersFile, p.actionsFile, p.types, ...p.openapi.map((s) => s.file)])
+            if (f)
+                inputs.add(f);
+        for (const spec of options.openapi == null ? [] : [].concat(options.openapi))
+            inputs.add(resolve(root, spec));
+        for (const ext of ['.js', '.ts']) {
+            inputs.add(join(root, 'src/sinter.helpers' + ext));
+            inputs.add(join(root, 'src/sinter.actions' + ext));
+            inputs.add(join(root, 'src/sinter.types' + ext));
+        }
+        inputs.add(join(root, 'src/sinter.types.d.ts'));
+        for (const m of Object.values(p.helpers.namespaces))
+            if (m.module.startsWith('/'))
+                inputs.add(join(root, m.module));
+        const state = {
+            root, options, project: p, entries: new Set(pages), pages: new Set(pages),
+            includes: new Map(), diagnostics: new Map(), units: new Map(), types: new Map(), inputs,
+        };
+        for (const [file] of this.docs)
+            if (file.endsWith('.html') && this.rootOf(file) === root)
+                state.pages.add(file);
+        this.compilePages(state, [...state.pages]);
+        return state;
+    }
+    async open(file, text) {
+        this.docs.set(file, text);
+        if (file.endsWith('.html'))
+            await this.htmlChanged(file);
+        else
+            await this.otherChanged(file);
+    }
+    async change(file, text) {
+        this.docs.set(file, text);
+        if (file.endsWith('.html'))
+            await this.htmlChanged(file);
+    }
+    async close(file) {
+        this.docs.delete(file);
+        if (!file.endsWith('.html'))
+            return;
+        const state = await this.projectFor(file);
+        // a page that is neither an entry nor open is forgotten; its diagnostics go with it
+        if (!state.entries.has(file) && state.pages.has(file)) {
+            state.pages.delete(file);
+            state.includes.delete(file);
+            state.diagnostics.delete(file);
+            state.units.delete(file);
+            state.types.delete(file);
+            this.publishAll(state);
+            return;
+        }
+        await this.htmlChanged(file);
+    }
+    /** A file changed on disk (saved, or changed by another program). */
+    async fileChanged(file) {
+        if (file.endsWith('.html')) {
+            if (!this.docs.has(file))
+                await this.htmlChanged(file);
+            return;
+        }
+        await this.otherChanged(file);
+    }
+    /** a non-HTML file: reload projects that read it */
+    async otherChanged(file) {
+        for (const [root, p] of this.projects) {
+            const state = await p;
+            if (!state.inputs.has(file))
+                continue;
+            const next = this.load(root);
+            this.projects.set(root, next);
+            const fresh = await next;
+            // pages the old state knew but the new one doesn't lose their diagnostics
+            for (const page of state.pages)
+                if (!fresh.pages.has(page))
+                    state.diagnostics.delete(page);
+            this.publishAll(fresh);
+        }
+    }
+    async htmlChanged(file) {
+        const state = await this.projectFor(file);
+        const includers = [...state.includes].filter(([, files]) => files.includes(file)).map(([page]) => page);
+        const pages = new Set(includers);
+        if (state.pages.has(file) || !includers.length) {
+            if (this.docs.has(file) || existsSync(file)) {
+                state.pages.add(file);
+                pages.add(file);
+            }
+        }
+        this.compilePages(state, [...pages]);
+    }
+    /** the text of a file: the open buffer, else the disk */
+    read(file) {
+        return this.docs.get(file) ?? readFileSync(file, 'utf8');
+    }
+    compilePages(state, pages) {
+        const p = state.project;
+        const readFile = (path) => {
+            const disk = p.readFile(path); // refuses files outside the root
+            return this.docs.get(resolve(path)) ?? disk;
+        };
+        for (const page of pages) {
+            let html;
+            try {
+                html = this.read(page);
+            }
+            catch {
+                continue;
+            }
+            // a page that is now included by another one is a partial, not a page
+            if (!state.entries.has(page) && [...state.includes].some(([other, files]) => other !== page && files.includes(page))) {
+                state.pages.delete(page);
+                state.diagnostics.delete(page);
+                state.includes.delete(page);
+                state.units.delete(page);
+                state.types.delete(page);
+                continue;
+            }
+            try {
+                const out = compile(html, {
+                    file: page, root: state.root, dev: false, helpers: p.helpers, actions: p.actions, config: p.config, readFile, check: true, openapi: p.openapi,
+                });
+                state.includes.set(page, out.files.map((f) => resolve(f)).filter((f) => f !== page));
+                state.diagnostics.set(page, out.diagnostics);
+                if (out.check)
+                    state.units.set(page, out.check);
+            }
+            catch (e) {
+                state.diagnostics.set(page, [{ severity: 'error', code: 'SN401', message: `sinter could not compile this page: ${e.message}`, file: page, line: 1, col: 1 }]);
+            }
+        }
+        this.publishAll(state);
+        this.hooks.compiled?.(state, pages.filter((x) => state.pages.has(x)));
+    }
+    /** Sets TypeScript's diagnostics under `key` (a page) and publishes. Ignored for a replaced project state. */
+    async setTypes(state, key, list) {
+        if ((await this.projects.get(state.root)) !== state)
+            return;
+        state.types.set(key, list);
+        this.publishAll(state);
+    }
+    /** Publishes every file's diagnostics, merged across the pages that include it. */
+    publishAll(state) {
+        const byFile = new Map();
+        const seen = new Set();
+        const add = (d) => {
+            const key = `${d.file}\0${d.line}\0${d.col}\0${d.code}\0${d.message}`;
+            if (seen.has(key))
+                return;
+            seen.add(key);
+            const list = byFile.get(d.file) ?? [];
+            list.push(d);
+            byFile.set(d.file, list);
+        };
+        for (const d of state.project.diagnostics)
+            add(d);
+        for (const page of state.pages)
+            for (const d of state.diagnostics.get(page) ?? [])
+                add(d);
+        for (const list of state.types.values())
+            for (const d of list)
+                add(d);
+        // files of this project that had diagnostics and now have none
+        for (const file of this.published) {
+            if (byFile.has(file) || this.rootOf(file) !== state.root)
+                continue;
+            this.published.delete(file);
+            this.hooks.publish(file, []);
+        }
+        for (const [file, list] of byFile) {
+            this.published.add(file);
+            this.hooks.publish(file, list);
+        }
+        // open files without problems get an empty list, so editors show them as checked
+        for (const file of this.docs.keys())
+            if (!byFile.has(file) && this.rootOf(file) === state.root)
+                this.hooks.publish(file, []);
+    }
+}

package/dist/optimistic.d.ts

@@ -0,0 +1,3 @@
+import type { Feature } from './runtime/app.js';
+declare const optimistic: Feature;
+export default optimistic;

package/dist/optimistic.js

@@ -0,0 +1,15 @@
+const optimistic = {
+    name: 'optimistic',
+    install(app) {
+        app.ext.optimistic = {
+            begin(fn, scope) {
+                return app.record(() => {
+                    const s = Object.create(scope);
+                    s.$f = app.storeFns(null);
+                    app.fns[fn](s);
+                });
+            },
+        };
+    },
+};
+export default optimistic;

package/dist/paginate.d.ts

@@ -0,0 +1,3 @@
+import type { Feature } from './runtime/app.js';
+declare const paginate: Feature;
+export default paginate;

package/dist/paginate.js

@@ -0,0 +1,198 @@
+class PagerImpl {
+    loader;
+    move;
+    cfg;
+    constructor(loader) {
+        this.loader = loader;
+        this.cfg = loader.def.paginate;
+        this.move = this.first();
+        const m = loader.res.meta;
+        if (this.cfg.mode === 'offset' || this.cfg.offsetParam)
+            m.page = 1;
+        Object.assign(m, { pages: null, from: null, to: null, hasPrev: false, hasNext: false });
+    }
+    base(dir, size = this.cfg.size) {
+        const p = { [this.cfg.sizeParam]: String(size) };
+        if (dir)
+            p[this.cfg.directionParam] = this.cfg.directionValues?.[dir] ?? dir;
+        return p;
+    }
+    first() {
+        if (this.cfg.mode === 'offset')
+            return { dir: 'page', page: 1, params: { [this.cfg.pageParam]: '1', ...this.base(null) }, from: null, to: null };
+        return { dir: 'first', page: 1, params: this.base('first'), from: null, to: null };
+    }
+    reset() {
+        this.move = this.first();
+    }
+    current() {
+        if (this.cfg.mode === 'append' && this.move.dir !== 'first') {
+            // refetch reloads everything loaded so far in one request
+            const n = Math.max(this.cfg.size, this.loader.res.all().length);
+            return { dir: 'all', page: 1, params: this.base('first', n), from: null, to: null };
+        }
+        return this.move;
+    }
+    params(move) {
+        return move.params;
+    }
+    appends(move) {
+        return this.cfg.mode === 'append' && move.dir === 'next';
+    }
+    go(target) {
+        const meta = this.loader.res.meta;
+        const items = this.loader.res.all();
+        const cursor = (item) => {
+            if (this.cfg.cursor == null || item === undefined)
+                return {};
+            const scope = Object.create(this.loader.app.page);
+            scope.$p = item;
+            const c = this.loader.app.fns[this.cfg.cursor](scope);
+            const out = {};
+            // like a URL template's query parameters: null and undefined fields are left out
+            for (const [k, v] of Object.entries(c ?? {}))
+                if (v != null)
+                    out[k] = String(v);
+            return out;
+        };
+        let move;
+        const from = meta.from ?? null, to = meta.to ?? null;
+        if (this.cfg.mode === 'offset') {
+            const page = meta.page ?? 1;
+            let n;
+            if (typeof target === 'number')
+                n = target;
+            else if (target === 'first')
+                n = 1;
+            else if (target === 'prev')
+                n = page - 1;
+            else if (target === 'next')
+                n = page + 1;
+            else if (target === 'last') {
+                if (meta.pages == null) {
+                    this.loader.app.warn(`page('${this.loader.def.name}', 'last') needs a known total`);
+                    return;
+                }
+                n = meta.pages;
+            }
+            else
+                return;
+            n = Math.max(1, Math.floor(n));
+            move = { dir: 'page', page: n, params: { [this.cfg.pageParam]: String(n), ...this.base(null) }, from, to };
+        }
+        else {
+            if (typeof target === 'number') {
+                if (!this.cfg.offsetParam) {
+                    this.loader.app.warn('keyset pagination cannot jump to a page number; add offset-param or use paginate="offset"');
+                    return;
+                }
+                // the server skips (n - 1) pages; prev/next continue by cursor from there
+                let n = Math.max(1, Math.floor(target));
+                if (meta.pages != null)
+                    n = Math.min(n, meta.pages);
+                move = { dir: 'page', page: n, params: { [this.cfg.offsetParam]: String((n - 1) * this.cfg.size), ...this.base('first') }, from, to };
+                void this.loader.load(move);
+                return;
+            }
+            if (this.cfg.mode === 'append' && target !== 'next')
+                return;
+            const dir = target;
+            const c = dir === 'next' ? cursor(items[items.length - 1]) : dir === 'prev' ? cursor(items[0]) : {};
+            move = { dir, page: 1, params: { ...c, ...this.base(dir) }, from, to };
+        }
+        void this.loader.load(move);
+    }
+    received(items, total, mv) {
+        const move = mv;
+        if (move.dir !== 'all')
+            this.move = move;
+        const meta = this.loader.res.meta;
+        const n = items.length;
+        const size = this.cfg.size;
+        const full = n >= size;
+        const pages = total != null ? Math.max(1, Math.ceil(total / size)) : null;
+        let from = null, to = null, hasPrev = false, hasNext = false;
+        switch (move.dir) {
+            case 'page':
+                from = n ? (move.page - 1) * size + 1 : 0;
+                to = n ? from + n - 1 : 0;
+                hasPrev = move.page > 1;
+                hasNext = pages != null ? move.page < pages : full;
+                meta.page = move.page;
+                break;
+            case 'first':
+                from = n ? 1 : 0;
+                to = n;
+                hasPrev = false;
+                hasNext = full;
+                break;
+            case 'all':
+                from = n ? 1 : 0;
+                to = n;
+                hasPrev = false;
+                hasNext = meta.hasNext ?? full;
+                break;
+            case 'next':
+                if (this.cfg.mode === 'append') {
+                    const all = this.loader.res.all().length;
+                    from = all ? 1 : 0;
+                    to = all;
+                    hasPrev = false;
+                    hasNext = full;
+                    break;
+                }
+                from = move.to != null ? move.to + 1 : null;
+                to = from != null ? from + n - 1 : null;
+                hasPrev = true;
+                hasNext = full;
+                break;
+            case 'prev':
+                hasNext = true;
+                if (!full) {
+                    from = n ? 1 : 0;
+                    to = n;
+                    hasPrev = false;
+                    break;
+                }
+                to = move.from != null ? move.from - 1 : null;
+                from = to != null ? to - n + 1 : null;
+                hasPrev = from == null || from > 1;
+                break;
+            case 'last':
+                hasNext = false;
+                if (total != null) {
+                    to = total;
+                    from = total - n + 1;
+                    hasPrev = from > 1;
+                }
+                else
+                    hasPrev = full;
+                break;
+        }
+        // keyset with jumps: the page that holds the last item shown (after `last`, the last page)
+        if (this.cfg.offsetParam && move.dir !== 'page')
+            meta.page = to != null ? Math.max(1, Math.ceil(to / size)) : null;
+        Object.assign(meta, { pages, from, to, hasPrev, hasNext });
+        this.loader.res.onDirty('meta');
+    }
+}
+const paginate = {
+    name: 'paginate',
+    install(app) {
+        const pagers = new Map();
+        app.ext.paginate = {
+            pager(loader) {
+                const p = new PagerImpl(loader);
+                pagers.set(loader.def.name, p);
+                return p;
+            },
+            page(name, target) {
+                const p = pagers.get(name);
+                if (!p)
+                    throw new Error(`sinter: resource \`${name}\` is not paginated`);
+                p.go(target);
+            },
+        };
+    },
+};
+export default paginate;

package/dist/persist.d.ts

@@ -0,0 +1,3 @@
+import type { Feature } from './runtime/app.js';
+declare const persist: Feature;
+export default persist;

package/dist/persist.js

@@ -0,0 +1,55 @@
+const PREFIX = 'sn:';
+const persist = {
+    name: 'persist',
+    install(app) {
+        const read = (key) => {
+            try {
+                const v = app.env.storage()?.getItem(PREFIX + key);
+                return v == null ? undefined : JSON.parse(v);
+            }
+            catch {
+                return undefined;
+            }
+        };
+        const write = (key, value) => {
+            try {
+                app.env.storage()?.setItem(PREFIX + key, JSON.stringify(value));
+            }
+            catch { /* ignored */ }
+        };
+        app.ext.persist = {
+            model(rb, set) {
+                const key = rb.b.p;
+                const v = read(key);
+                if (v !== undefined)
+                    set(v);
+                const paths = (rb.b.w ?? []).map((w) => w.split('.').map((s) => (s[0] === '{' ? '*' : s)));
+                app.afterFlush.push((dirty) => {
+                    if (!dirty.some((d) => paths.some((p) => overlaps(p, d))))
+                        return;
+                    try {
+                        write(key, app.fns[rb.b.f](rb.s));
+                    }
+                    catch { /* unreadable: skip */ }
+                });
+            },
+            state(key, obj) {
+                const v = read(key);
+                if (!v || typeof v !== 'object')
+                    return;
+                for (const k of Object.keys(obj))
+                    if (Object.hasOwn(v, k))
+                        obj[k] = v[k];
+            },
+            saveState: write,
+        };
+    },
+};
+function overlaps(a, b) {
+    const n = Math.min(a.length, b.length);
+    for (let i = 0; i < n; i++)
+        if (a[i] !== b[i] && a[i] !== '*' && b[i] !== '*')
+            return false;
+    return true;
+}
+export default persist;

package/dist/project.d.ts

@@ -0,0 +1,42 @@
+import { type Diagnostic, type HelperManifest } from './compiler/index.js';
+import type { OpenApiSpec } from './compiler/openapi.js';
+export interface ProjectOptions {
+    /** helpers module, relative to the root (default `src/sinter.helpers.js`, or `.ts`) */
+    helpers?: string;
+    /** actions module for `data-sn-call` and `<sn-resource call>` (default `src/sinter.actions.js`, or `.ts`) */
+    actions?: string;
+    /** app configuration module imported before mount (default `src/sinter.config.js`, or `.ts`) */
+    config?: string;
+    /** module whose exported types `type="…"` on `<sn-resource>` may name (default `src/sinter.types.ts`, `.d.ts` or `.js`) */
+    types?: string;
+    /** OpenAPI specs (JSON or YAML, inside the root) that resources without `type` are matched against */
+    openapi?: string | string[];
+}
+export interface Project {
+    root: string;
+    helpers: HelperManifest;
+    /** absolute path of the helpers module, or null */
+    helpersFile: string | null;
+    /** the actions module's functions and namespaces (same shape as helpers) */
+    actions: HelperManifest;
+    /** absolute path of the actions module, or null */
+    actionsFile: string | null;
+    /** root-relative URL of the config module (`/src/sinter.config.js`), or null */
+    config: string | null;
+    /** absolute path of the types module, or null */
+    types: string | null;
+    /** reads a file only if it resolves inside the root, symlinks included */
+    readFile: (path: string) => string;
+    openapi: OpenApiSpec[];
+    /** problems loading the specs (SN307) */
+    diagnostics: Diagnostic[];
+}
+export declare function project(root: string, options?: ProjectOptions): Project;
+/**
+ * The pages (HTML entries) and sinter plugin options from the root's Vite config. Without
+ * Vite or entries, `index.html` if it exists.
+ */
+export declare function viteProject(root: string): Promise<{
+    pages: string[];
+    options: ProjectOptions;
+}>;