@sigmx/astro 0.1.0 → 0.2.0

package/dist/client.js

@@ -1,6 +1,3 @@
-// Convenience re-exports for app-local entrypoints:
-//   import { createSigmx, all, plugins } from '@sigmx/astro/client'
-//   createSigmx({ plugins: [plugins.text, plugins.on] })
 export * from 'sigmx';
 export * as plugins from 'sigmx/plugins';
 export { all } from 'sigmx/presets/all';

package/dist/index.js

@@ -1,4 +1,4 @@
-import { sigmxAuto, sigmxPrecompile } from 'sigmx/vite';
+import { sigmxAuto, sigmxPrecompile, } from 'sigmx/vite';
 const AUTO = 'virtual:sigmx-plugins';
 const EXPRESSIONS = 'virtual:sigmx-expressions';
 /** Source of the injected client module. Exported for tests and custom entrypoints. */
@@ -12,7 +12,9 @@ export const bootScript = (o = {}) => {
     const expose = o.expose === false ? '' : `\nwindow[${JSON.stringify(o.expose ?? 'sigmx')}] = app;`;
     if (!o.precompile)
         return `import { createSigmx } from 'sigmx';\n${imports}\nconst app = createSigmx({ plugins, ...${options} });${expose}\n`;
-    const fallback = typeof o.precompile === 'object' && o.precompile.fallback === false ? 'undefined' : 'runtimeExpressions(functionCompiler)';
+    const fallback = typeof o.precompile === 'object' && o.precompile.fallback === false
+        ? 'undefined'
+        : 'runtimeExpressions(functionCompiler)';
     return (`import { createRuntime, precompiled, runtimeExpressions, functionCompiler } from 'sigmx';\nimport { table } from '${EXPRESSIONS}';\n${imports}\n` +
         `const app = createRuntime({ plugins, expressions: precompiled(table, ${fallback}), ...${options} });${expose}\n`);
 };
@@ -28,7 +30,13 @@ export default function sigmx(options = {}) {
                     plugins.push(sigmxAuto({ ...options.auto, root, prefixes }));
                 if (options.precompile) {
                     const po = typeof options.precompile === 'object' ? options.precompile : {};
-                    plugins.push(sigmxPrecompile({ include: po.include, extensions: po.extensions, custom: po.custom ?? options.auto?.custom, root, prefixes }));
+                    plugins.push(sigmxPrecompile({
+                        include: po.include,
+                        extensions: po.extensions,
+                        custom: po.custom ?? options.auto?.custom,
+                        root,
+                        prefixes,
+                    }));
                 }
                 if (plugins.length)
                     updateConfig({ vite: { plugins } });

package/dist/server.d.ts

@@ -1,106 +1 @@
-/** Query-string key that carries signals on GET/DELETE requests. */
-export declare const SIGNALS_KEY = "sigmx";
-export declare const EVENT_PATCH_ELEMENTS = "sigmx-patch-elements";
-export declare const EVENT_PATCH_SIGNALS = "sigmx-patch-signals";
-export declare const SSE_HEADERS: {
-    readonly 'content-type': "text/event-stream";
-    readonly 'cache-control': "no-cache";
-    readonly connection: "keep-alive";
-};
-export type PatchMode = 'outer' | 'inner' | 'replace' | 'prepend' | 'append' | 'before' | 'after' | 'remove';
-export interface ServerEvent {
-    event: string;
-    /** Data lines, each `key value`. */
-    lines: string[];
-    id?: string;
-    retry?: number;
-}
-export interface EventOptions {
-    id?: string;
-    retry?: number;
-}
-export interface PatchElementsOptions extends EventOptions {
-    selector?: string;
-    mode?: PatchMode;
-    useViewTransition?: boolean;
-}
-export interface PatchSignalsOptions extends EventOptions {
-    onlyIfMissing?: boolean;
-}
-export interface ExecuteScriptOptions extends EventOptions {
-    /** Remove the script element after it runs (default true). */
-    autoRemove?: boolean;
-    attributes?: Record<string, string>;
-}
-/** Patch HTML into the page. Without a selector, top-level elements are morphed by id. */
-export declare const patchElements: (html: string, o?: PatchElementsOptions) => ServerEvent;
-export declare const removeElements: (selector: string, o?: EventOptions) => ServerEvent;
-/** Merge signals (JSON merge-patch: null removes). Accepts an object or pre-serialised JSON. */
-export declare const patchSignals: (signals: Record<string, unknown> | string, o?: PatchSignalsOptions) => ServerEvent;
-/** Remove signals by dotted path. */
-export declare const removeSignals: (paths: string[], o?: EventOptions) => ServerEvent;
-/** Run JavaScript in the page by appending a script element to the body. */
-export declare const executeScript: (script: string, o?: ExecuteScriptOptions) => ServerEvent;
-/** Serialise one event in `text/event-stream` format. */
-export declare const formatEvent: (e: ServerEvent) => string;
-/** A streaming event-source response you write to over time. */
-export declare class SigmxStream {
-    readonly response: Response;
-    private controller;
-    private readonly encoder;
-    private open;
-    constructor(init?: ResponseInit);
-    get closed(): boolean;
-    send(event: ServerEvent): this;
-    patchElements(html: string, o?: PatchElementsOptions): this;
-    removeElements(selector: string, o?: EventOptions): this;
-    patchSignals(signals: Record<string, unknown> | string, o?: PatchSignalsOptions): this;
-    removeSignals(paths: string[], o?: EventOptions): this;
-    executeScript(script: string, o?: ExecuteScriptOptions): this;
-    close(): void;
-}
-/** A complete event-source response from a fixed list of events. */
-export declare const sse: (...events: ServerEvent[]) => Response;
-/** Stream events while `fn` runs; the response closes when it resolves. */
-export declare const sseStream: (fn: (stream: SigmxStream) => Promise<void> | void, init?: ResponseInit) => Response;
-/** A plain HTML response; the client morphs it by id, or honours the selector and mode headers. */
-export declare const html: (body: string, o?: PatchElementsOptions & {
-    status?: number;
-}) => Response;
-/** A plain JSON response; the client merges it as signals. */
-export declare const json: (signals: Record<string, unknown>, o?: PatchSignalsOptions & {
-    status?: number;
-}) => Response;
-/** Minimal Standard Schema (standardschema.dev) so any compliant validator works without a dependency. */
-export interface StandardSchema<Output = unknown> {
-    readonly '~standard': {
-        readonly validate: (value: unknown) => SchemaResult<Output> | Promise<SchemaResult<Output>>;
-    };
-}
-export type SchemaIssue = {
-    readonly message: string;
-    readonly path?: ReadonlyArray<PropertyKey | {
-        readonly key: PropertyKey;
-    }>;
-};
-export type SchemaResult<T> = {
-    readonly value: T;
-    readonly issues?: undefined;
-} | {
-    readonly issues: ReadonlyArray<SchemaIssue>;
-};
-export declare class SignalsError extends Error {
-    readonly issues: ReadonlyArray<SchemaIssue>;
-    readonly status: number;
-    constructor(message: string, issues?: ReadonlyArray<SchemaIssue>, status?: number);
-    /** A ready-made error response for endpoints that want to bail out. */
-    response(): Response;
-}
-/**
- * Read the signals a sigmx request carries: the `sigmx` query parameter on GET/DELETE, a JSON
- * body otherwise, or form fields for `contentType: 'form'` requests. Validates with `schema` if given.
- */
-export declare function readSignals(request: Request): Promise<Record<string, any>>;
-export declare function readSignals<T>(request: Request, schema: StandardSchema<T>): Promise<T>;
-/** True when the request was made by the sigmx client (has the `Sigmx-Request` header). */
-export declare const isSigmxRequest: (request: Request) => boolean;
+export * from 'sigmx/server';

package/dist/server.js

@@ -1,181 +1,3 @@
-// Server helpers for answering sigmx requests from Astro endpoints (or any Fetch-API runtime).
-/** Query-string key that carries signals on GET/DELETE requests. */
-export const SIGNALS_KEY = 'sigmx';
-export const EVENT_PATCH_ELEMENTS = 'sigmx-patch-elements';
-export const EVENT_PATCH_SIGNALS = 'sigmx-patch-signals';
-export const SSE_HEADERS = {
-    'content-type': 'text/event-stream',
-    'cache-control': 'no-cache',
-    connection: 'keep-alive',
-};
-// ---- event builders -------------------------------------------------------
-/** Patch HTML into the page. Without a selector, top-level elements are morphed by id. */
-export const patchElements = (html, o = {}) => {
-    const lines = [];
-    if (o.selector)
-        lines.push(`selector ${o.selector}`);
-    if (o.mode && o.mode !== 'outer')
-        lines.push(`mode ${o.mode}`);
-    if (o.useViewTransition)
-        lines.push('useViewTransition true');
-    for (const l of html.trim().split('\n'))
-        lines.push(`elements ${l}`);
-    return { event: EVENT_PATCH_ELEMENTS, lines, id: o.id, retry: o.retry };
-};
-export const removeElements = (selector, o = {}) => ({
-    event: EVENT_PATCH_ELEMENTS,
-    lines: [`selector ${selector}`, 'mode remove'],
-    ...o,
-});
-/** Merge signals (JSON merge-patch: null removes). Accepts an object or pre-serialised JSON. */
-export const patchSignals = (signals, o = {}) => ({
-    event: EVENT_PATCH_SIGNALS,
-    lines: [...(o.onlyIfMissing ? ['onlyIfMissing true'] : []), `signals ${typeof signals === 'string' ? signals : JSON.stringify(signals)}`],
-    id: o.id,
-    retry: o.retry,
-});
-/** Remove signals by dotted path. */
-export const removeSignals = (paths, o = {}) => {
-    const patch = {};
-    for (const p of paths) {
-        const keys = p.split('.');
-        const last = keys.pop();
-        let cur = patch;
-        for (const k of keys)
-            cur = cur[k] ??= {};
-        cur[last] = null;
-    }
-    return patchSignals(patch, o);
-};
-/** Run JavaScript in the page by appending a script element to the body. */
-export const executeScript = (script, o = {}) => {
-    const attrs = { ...(o.autoRemove ?? true ? { 'data-init': 'el.remove()' } : {}), ...o.attributes };
-    const attrText = Object.entries(attrs)
-        .map(([k, v]) => ` ${k}="${v.replace(/"/g, '"')}"`)
-        .join('');
-    return patchElements(`<script${attrText}>${script}</script>`, { selector: 'body', mode: 'append', id: o.id, retry: o.retry });
-};
-/** Serialise one event in `text/event-stream` format. */
-export const formatEvent = (e) => [e.id !== undefined && `id: ${e.id}`, e.retry !== undefined && `retry: ${e.retry}`, `event: ${e.event}`, ...e.lines.map((l) => `data: ${l}`)]
-    .filter(Boolean)
-    .join('\n') + '\n\n';
-// ---- responses ------------------------------------------------------------
-/** A streaming event-source response you write to over time. */
-export class SigmxStream {
-    response;
-    controller;
-    encoder = new TextEncoder();
-    open = true;
-    constructor(init = {}) {
-        const body = new ReadableStream({
-            start: (c) => {
-                this.controller = c;
-            },
-            cancel: () => {
-                this.open = false;
-            },
-        });
-        this.response = new Response(body, { ...init, headers: { ...SSE_HEADERS, ...init.headers } });
-    }
-    get closed() {
-        return !this.open;
-    }
-    send(event) {
-        if (this.open)
-            this.controller.enqueue(this.encoder.encode(formatEvent(event)));
-        return this;
-    }
-    patchElements(html, o) {
-        return this.send(patchElements(html, o));
-    }
-    removeElements(selector, o) {
-        return this.send(removeElements(selector, o));
-    }
-    patchSignals(signals, o) {
-        return this.send(patchSignals(signals, o));
-    }
-    removeSignals(paths, o) {
-        return this.send(removeSignals(paths, o));
-    }
-    executeScript(script, o) {
-        return this.send(executeScript(script, o));
-    }
-    close() {
-        if (this.open) {
-            this.open = false;
-            this.controller.close();
-        }
-    }
-}
-/** A complete event-source response from a fixed list of events. */
-export const sse = (...events) => new Response(events.map(formatEvent).join(''), { headers: SSE_HEADERS });
-/** Stream events while `fn` runs; the response closes when it resolves. */
-export const sseStream = (fn, init) => {
-    const stream = new SigmxStream(init);
-    Promise.resolve()
-        .then(() => fn(stream))
-        .catch((e) => console.error('sigmx sseStream:', e))
-        .finally(() => stream.close());
-    return stream.response;
-};
-/** A plain HTML response; the client morphs it by id, or honours the selector and mode headers. */
-export const html = (body, o = {}) => new Response(body, {
-    status: o.status ?? 200,
-    headers: {
-        'content-type': 'text/html; charset=utf-8',
-        ...(o.selector ? { 'sigmx-selector': o.selector } : {}),
-        ...(o.mode ? { 'sigmx-mode': o.mode } : {}),
-        ...(o.useViewTransition ? { 'sigmx-use-view-transition': 'true' } : {}),
-    },
-});
-/** A plain JSON response; the client merges it as signals. */
-export const json = (signals, o = {}) => new Response(JSON.stringify(signals), {
-    status: o.status ?? 200,
-    headers: { 'content-type': 'application/json', ...(o.onlyIfMissing ? { 'sigmx-only-if-missing': 'true' } : {}) },
-});
-export class SignalsError extends Error {
-    issues;
-    status;
-    constructor(message, issues = [], status = 422) {
-        super(message);
-        this.issues = issues;
-        this.status = status;
-        this.name = 'SignalsError';
-    }
-    /** A ready-made error response for endpoints that want to bail out. */
-    response() {
-        return Response.json({ error: this.message, issues: this.issues }, { status: this.status });
-    }
-}
-export async function readSignals(request, schema) {
-    let raw;
-    const method = request.method.toUpperCase();
-    const type = request.headers.get('content-type') ?? '';
-    try {
-        if (method === 'GET' || method === 'DELETE') {
-            const q = new URL(request.url).searchParams.get(SIGNALS_KEY);
-            raw = q ? JSON.parse(q) : {};
-        }
-        else if (type.includes('application/json')) {
-            const text = await request.text();
-            raw = text ? JSON.parse(text) : {};
-        }
-        else if (type.includes('form')) {
-            raw = Object.fromEntries((await request.formData()).entries());
-        }
-        else {
-            raw = {};
-        }
-    }
-    catch (e) {
-        throw new SignalsError(`could not parse signals: ${e.message}`, [], 400);
-    }
-    if (!schema)
-        return raw;
-    const result = await schema['~standard'].validate(raw);
-    if (result.issues)
-        throw new SignalsError(`invalid signals: ${result.issues.map((i) => i.message).join('; ')}`, result.issues);
-    return result.value;
-}
-/** True when the request was made by the sigmx client (has the `Sigmx-Request` header). */
-export const isSigmxRequest = (request) => request.headers.get('sigmx-request') === 'true';
+// The server helpers live in the core package so every runtime shares them; this entry keeps
+// `@sigmx/astro/server` working and documents that they are plain Fetch-API code.
+export * from 'sigmx/server';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigmx/astro",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Astro integration and server helpers for sigmx: inject the client, stream patches from endpoints, read signals from requests.",
   "keywords": [
     "astro",
@@ -61,6 +61,6 @@
   },
   "peerDependencies": {
     "astro": "^5.0.0 || ^6.0.0 || ^7.0.0",
-    "sigmx": "^0.1.0"
+    "sigmx": "^0.2.0"
   }
 }