@dimina-kit/devkit 0.1.2-dev.20260711140249 → 0.1.2-dev.20260716153350

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import type { CompileLogEntry } from './compile-worker.js';
 import type { CompileWorkerStandby, CompileWorkerStandbyOptions } from './compile-worker-standby.js';
 export { WATCH_IGNORE_DIRS } from './watch-ignore.js';
+export { isStyleOnlyChange, composeBuildCompleted } from './rebuild-dispatch.js';
 export { createRebuildScheduler } from './rebuild-scheduler.js';
 export type { RebuildScheduler } from './rebuild-scheduler.js';
 export { filterDmccLogLine } from './compile-log.js';
@@ -47,13 +48,26 @@ export interface OpenProjectOptions {
     /** When false, skip the chokidar file-watcher / auto-rebuild loop. Default true. */
     watch?: boolean;
     /**
-     * When false, a completed watcher rebuild does NOT live-reload the preview
-     * (the SSE `reload` → container `window.location.reload()`); `onRebuild`
-     * still fires so the host learns the build finished, but the page stack /
-     * form state survives. Independent of `watch`. Default true.
+     * When false, a completed watcher rebuild does NOT touch the preview at all;
+     * `onRebuild` still fires so the host learns the build finished, but the page
+     * stack / form state survives. When true (default), the preview reacts to the
+     * rebuild: a rebuild touching ONLY stylesheets hot-swaps each `<link>` in
+     * place (SSE `reload-style` — page stack / form state survive), while any
+     * other change does a full page reload (SSE `reload` → container
+     * `window.location.reload()`). Independent of `watch`.
      */
     autoReload?: boolean;
-    onRebuild?: () => void;
+    /**
+     * Fired after each successful watcher rebuild. `info.changedPaths` are the
+     * files that triggered it; `info.styleOnly` is true when every one is a
+     * stylesheet (see {@link isStyleOnlyChange}) — the host can then hot-swap
+     * styles in place instead of a full reload. Both are absent (undefined) for
+     * the SSE-driven web-preview path; native hosts read them to pick a fast path.
+     */
+    onRebuild?: (info?: {
+        changedPaths: string[];
+        styleOnly: boolean;
+    }) => void;
     onBuildError?: (err: unknown) => void;
     /**
      * Per-line dmcc compile log, already filtered through `filterDmccLogLine`
@@ -70,19 +84,6 @@ export interface OpenProjectOptions {
      */
     onWatcherError?: (err: unknown) => void;
 }
-/**
- * Compose the "build completed" subscriber — the single place deciding which of
- * two INDEPENDENT reactions run: live-reloading the preview, and the caller's
- * `onRebuild`. Reload is attached only when `autoReload` is on (so auto-compile
- * can stay ON while reload is OFF, preserving page/form state); when off,
- * `getReload` is not even called. `getReload` is read at call time because the
- * dev server's `reload` is assigned after this subscriber is wired.
- */
-export declare function composeBuildCompleted(opts: {
-    autoReload: boolean;
-    getReload: () => (() => void) | undefined;
-    onRebuild?: () => void;
-}): () => void;
 export declare function openProject(opts: OpenProjectOptions): Promise<ProjectSession>;
 /**
  * Watch a project directory and invoke `onChange` whenever a source file is
@@ -90,7 +91,7 @@ export declare function openProject(opts: OpenProjectOptions): Promise<ProjectSe
  * watcher and whose `ready` resolves once the initial scan is complete (only
  * changes made after that point are guaranteed to surface).
  */
-export declare function createProjectWatcher(projectPath: string, onChange: () => void | Promise<void>, onWatcherError?: (err: unknown) => void): {
+export declare function createProjectWatcher(projectPath: string, onChange: (changedPath?: string) => void | Promise<void>, onWatcherError?: (err: unknown) => void): {
     close: () => Promise<void>;
     ready: Promise<void>;
 };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAgB,eAAe,EAAiB,MAAM,qBAAqB,CAAA;AAEvF,OAAO,KAAK,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAA;AAEpG,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AAC/D,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AACzD,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACzE,OAAO,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAA;AACxE,YAAY,EACX,oBAAoB,EACpB,2BAA2B,EAC3B,YAAY,EACZ,YAAY,GACZ,MAAM,6BAA6B,CAAA;AAYpC;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACzC,IAAI,CAAC,EAAE,2BAA2B,GAChC,oBAAoB,CAKtB;AAoDD,MAAM,WAAW,OAAO;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,WAAW,cAAc;IAC9B,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1B;AAED,MAAM,WAAW,kBAAkB;IAClC,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB;;;;OAIG;IACH,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAA;IAC5E,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,oFAAoF;IACpF,KAAK,CAAC,EAAE,OAAO,CAAA;IACf;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,IAAI,CAAA;IACtB,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAA;IACrC;;;;OAIG;IACH,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAA;IACxC;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAA;CACvC;AAiCD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC3C,UAAU,EAAE,OAAO,CAAA;IACnB,SAAS,EAAE,MAAM,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAA;IACzC,SAAS,CAAC,EAAE,MAAM,IAAI,CAAA;CACtB,GAAG,MAAM,IAAI,CAKb;AAmDD,wBAAsB,WAAW,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,CAAC,CAgKnF;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CACnC,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EACpC,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,GACrC;IAAE,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAqEtD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -10,8 +10,10 @@ import { WATCH_IGNORE_DIRS } from './watch-ignore.js';
 import { applyEsbuildBinaryPath } from './esbuild-binary-path.js';
 import { createRebuildScheduler } from './rebuild-scheduler.js';
 import { createCompileWorker } from './compile-worker.js';
+import { composeBuildCompleted, runRebuild } from './rebuild-dispatch.js';
 import { createCompileWorkerStandby } from './compile-worker-standby.js';
 export { WATCH_IGNORE_DIRS } from './watch-ignore.js';
+export { isStyleOnlyChange, composeBuildCompleted } from './rebuild-dispatch.js';
 export { createRebuildScheduler } from './rebuild-scheduler.js';
 export { filterDmccLogLine } from './compile-log.js';
 export { createCompileWorker } from './compile-worker.js';
@@ -101,42 +103,6 @@ function resolveAppInfoFallback(projectPath) {
         return null;
     }
 }
-/** Insert or replace `rebuilt` in the session's app list, keyed by appId. */
-function upsertSessionApp(sessionApps, rebuilt) {
-    const idx = sessionApps.findIndex(a => a.appId === rebuilt.appId);
-    if (idx === -1)
-        sessionApps.push(rebuilt);
-    else
-        sessionApps[idx] = rebuilt;
-}
-/**
- * Compose the "build completed" subscriber — the single place deciding which of
- * two INDEPENDENT reactions run: live-reloading the preview, and the caller's
- * `onRebuild`. Reload is attached only when `autoReload` is on (so auto-compile
- * can stay ON while reload is OFF, preserving page/form state); when off,
- * `getReload` is not even called. `getReload` is read at call time because the
- * dev server's `reload` is assigned after this subscriber is wired.
- */
-export function composeBuildCompleted(opts) {
-    return () => {
-        if (opts.autoReload)
-            opts.getReload()?.();
-        opts.onRebuild?.();
-    };
-}
-/** Run one watcher-triggered rebuild, then fan out to the build-completed
- * subscriber (reload + onRebuild); a build failure routes to onBuildFailed. */
-async function runRebuild(compileWorker, buildRequest, sessionApps, onBuildCompleted, onBuildFailed) {
-    try {
-        const rebuilt = (await compileWorker.build(buildRequest));
-        if (rebuilt)
-            upsertSessionApp(sessionApps, rebuilt);
-        onBuildCompleted();
-    }
-    catch (e) {
-        onBuildFailed(e);
-    }
-}
 /**
  * Tear down whatever partially started before `openProject` failed: the
  * watcher, the forked compile worker, and the dev server if it was already
@@ -238,6 +204,7 @@ export async function openProject(opts) {
     // propagates — otherwise every failed open leaks a whole compiler process.
     let server = null;
     let reload;
+    let reloadStyles;
     let watcher = null;
     try {
         process.env.DIMINA_NO_OPEN_BROWSER = '1';
@@ -253,17 +220,35 @@ export async function openProject(opts) {
         });
         server = started.server;
         reload = started.reload;
+        reloadStyles = started.reloadStyles;
         // Watcher events are routed through the scheduler so a save landing while
         // a build is in flight is never dropped: it coalesces into exactly one
         // trailing rebuild once the current run settles.
         const onBuildCompleted = composeBuildCompleted({
             autoReload,
             getReload: () => reload,
+            getReloadStyles: () => reloadStyles,
+            styleExts: fileTypes?.style,
             onRebuild,
         });
-        const rebuildScheduler = createRebuildScheduler(() => runRebuild(compileWorker, buildRequest, sessionApps, onBuildCompleted, err => onBuildError?.(err)));
+        // The scheduler coalesces N saves into one trailing rebuild, so the changed
+        // paths accumulate here and are drained (not lost) at the moment that run
+        // actually starts. Draining at run-start — before the build's await — lets
+        // saves landing DURING the build accumulate cleanly for the next trailing
+        // run. An empty set means "changes unknown" → composeBuildCompleted falls
+        // back to a full reload rather than a style-only swap.
+        const pendingChanges = new Set();
+        const rebuildScheduler = createRebuildScheduler(() => {
+            const changed = [...pendingChanges];
+            pendingChanges.clear();
+            return runRebuild(compileWorker, buildRequest, sessionApps, onBuildCompleted, err => onBuildError?.(err), changed);
+        });
         watcher = watch
-            ? createProjectWatcher(projectPath, () => rebuildScheduler.schedule(), onWatcherError)
+            ? createProjectWatcher(projectPath, (changedPath) => {
+                if (changedPath)
+                    pendingChanges.add(changedPath);
+                rebuildScheduler.schedule();
+            }, onWatcherError)
             : null;
         // Don't resolve until the watcher's initial scan is done: a save landing
         // in the gap between `openProject` resolving and chokidar going live
@@ -346,9 +331,9 @@ export function createProjectWatcher(projectPath, onChange, onWatcherError) {
     // source file all surface as onChange. Listening only to 'change' silently
     // dropped the "developer added a new page" case (a chokidar 'add' event)
     // and made auto-compile feel broken on a common save pattern.
-    watcher.on('add', () => { void onChange(); });
-    watcher.on('change', () => { void onChange(); });
-    watcher.on('unlink', () => { void onChange(); });
+    watcher.on('add', (p) => { void onChange(p); });
+    watcher.on('change', (p) => { void onChange(p); });
+    watcher.on('unlink', (p) => { void onChange(p); });
     // A watcher 'error' before the initial scan completes (EMFILE, permission
     // loss, …) must REJECT `ready`: resolving only on 'ready' would leave
     // `await watcher.ready` — and the whole openProject — hung forever. The

package/dist/live-reload.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=live-reload.test.d.ts.map

package/dist/live-reload.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-reload.test.d.ts","sourceRoot":"","sources":["../src/live-reload.test.ts"],"names":[],"mappings":""}

package/dist/live-reload.test.js

@@ -0,0 +1,115 @@
+// @vitest-environment jsdom
+import { EventEmitter } from 'node:events';
+import { describe, expect, it, vi } from 'vitest';
+import { createLiveReload, refreshStylesheets } from '../fe/live-reload.js';
+function makeFakeRes() {
+    const chunks = [];
+    return {
+        setHeader: vi.fn(),
+        flushHeaders: vi.fn(),
+        write: vi.fn((chunk) => {
+            chunks.push(chunk);
+        }),
+        chunks,
+    };
+}
+function makeFakeReq() {
+    const emitter = new EventEmitter();
+    return {
+        on: (ev, cb) => {
+            emitter.on(ev, cb);
+            return emitter;
+        },
+        emit: (ev, ...args) => emitter.emit(ev, ...args),
+    };
+}
+describe('refreshStylesheets', () => {
+    it('appends a sibling link with a cache-busting __hmr param for a stylesheet link', () => {
+        document.head.innerHTML = '<link rel="stylesheet" href="/style.css">';
+        refreshStylesheets(document);
+        const links = Array.from(document.querySelectorAll('link[rel="stylesheet"]'));
+        const withHmr = links.filter((link) => link.href.includes('__hmr'));
+        expect(withHmr).toHaveLength(1);
+    });
+    it('does not touch non-stylesheet links', () => {
+        document.head.innerHTML = '<link rel="icon" href="/favicon.ico">';
+        refreshStylesheets(document);
+        const links = Array.from(document.querySelectorAll('link'));
+        expect(links).toHaveLength(1);
+        expect(links.some((link) => link.href.includes('__hmr'))).toBe(false);
+    });
+    it('recurses into a same-origin iframe and refreshes its inner stylesheet', () => {
+        document.body.innerHTML = '';
+        const iframe = document.createElement('iframe');
+        document.body.appendChild(iframe);
+        const innerDoc = iframe.contentDocument;
+        expect(innerDoc).toBeTruthy();
+        const innerLink = innerDoc.createElement('link');
+        innerLink.rel = 'stylesheet';
+        innerLink.href = 'x.css';
+        innerDoc.head.appendChild(innerLink);
+        refreshStylesheets(document);
+        const innerLinks = Array.from(innerDoc.querySelectorAll('link[rel="stylesheet"]'));
+        expect(innerLinks.some((link) => link.href.includes('__hmr'))).toBe(true);
+    });
+    it('does not throw on an empty document', () => {
+        document.head.innerHTML = '';
+        document.body.innerHTML = '';
+        expect(() => refreshStylesheets(document)).not.toThrow();
+    });
+});
+describe('createLiveReload', () => {
+    function setup() {
+        const routes = {};
+        const app = {
+            get: (p, h) => {
+                routes[p] = h;
+            },
+        };
+        const liveReload = createLiveReload(app);
+        return { routes, app, liveReload };
+    }
+    function connectClient(routes) {
+        const req = makeFakeReq();
+        const res = makeFakeRes();
+        const handler = routes['/__livereload'];
+        if (typeof handler !== 'function')
+            throw new Error('handler not registered');
+        handler(req, res);
+        return { req, res };
+    }
+    it('registers a GET handler for /__livereload', () => {
+        const { routes } = setup();
+        expect(routes['/__livereload']).toBeTypeOf('function');
+    });
+    it('reload() broadcasts an event: reload chunk to connected clients', () => {
+        const { routes, liveReload } = setup();
+        const { res } = connectClient(routes);
+        liveReload.reload();
+        expect(res.chunks.some((chunk) => chunk.includes('event: reload\n'))).toBe(true);
+    });
+    it('reloadStyles() broadcasts an event: reload-style chunk to connected clients', () => {
+        const { routes, liveReload } = setup();
+        const { res } = connectClient(routes);
+        liveReload.reloadStyles();
+        expect(res.chunks.some((chunk) => chunk.includes('event: reload-style\n'))).toBe(true);
+    });
+    it('stops writing to a client after its request closes', () => {
+        const { routes, liveReload } = setup();
+        const { req, res } = connectClient(routes);
+        req.emit('close');
+        res.chunks.length = 0;
+        liveReload.reload();
+        expect(res.write).not.toHaveBeenCalled();
+        expect(res.chunks).toHaveLength(0);
+    });
+    it('reload() only writes to still-connected clients, not a closed one, when multiple are connected', () => {
+        const { routes, liveReload } = setup();
+        const clientA = connectClient(routes);
+        const clientB = connectClient(routes);
+        clientA.req.emit('close');
+        liveReload.reload();
+        expect(clientA.res.chunks.some((chunk) => chunk.includes('event: reload\n'))).toBe(false);
+        expect(clientB.res.chunks.some((chunk) => chunk.includes('event: reload\n'))).toBe(true);
+    });
+});

package/dist/rebuild-dispatch.d.ts

@@ -0,0 +1,41 @@
+import type { AppInfo } from './index.js';
+import type { BuildRequest, CompileWorker } from './compile-worker.js';
+/** Insert or replace `rebuilt` in the session's app list, keyed by appId. */
+export declare function upsertSessionApp(sessionApps: AppInfo[], rebuilt: AppInfo): void;
+/**
+ * True iff `changedPaths` is non-empty AND every path is a stylesheet — the
+ * precondition for a style-only hot swap. Empty is false: "no known paths"
+ * (e.g. a coalesced rebuild that lost its change list) must fall back to a full
+ * reload rather than silently assume styles-only. `extraStyleExts` (from
+ * `fileTypes.style`) is merged in; a leading dot is optional and matching is
+ * case-insensitive.
+ */
+export declare function isStyleOnlyChange(changedPaths: string[], extraStyleExts?: string[]): boolean;
+/**
+ * Compose the "build completed" subscriber — the single place deciding which of
+ * two INDEPENDENT reactions run: reflecting the rebuild in the preview, and the
+ * caller's `onRebuild`. When `autoReload` is on and the rebuild touched ONLY
+ * stylesheets (`isStyleOnlyChange`), it hot-swaps the stylesheets in place
+ * (`getReloadStyles`) so the page stack / form state survives; otherwise it does
+ * a full `getReload()` page reload. With `autoReload` off, neither is called
+ * (auto-compile stays on, preview frozen). Both `getReload`/`getReloadStyles`
+ * are read at call time because the dev server assigns them after this
+ * subscriber is wired; `getReloadStyles` may be absent (older fe server) — then
+ * even a style-only change falls back to a full reload.
+ */
+export declare function composeBuildCompleted(opts: {
+    autoReload: boolean;
+    getReload: () => (() => void) | undefined;
+    getReloadStyles?: () => (() => void) | undefined;
+    styleExts?: string[];
+    onRebuild?: (info?: {
+        changedPaths: string[];
+        styleOnly: boolean;
+    }) => void;
+}): (changedPaths?: string[]) => void;
+/** Run one watcher-triggered rebuild, then fan out to the build-completed
+ * subscriber (style hot-swap or full reload + onRebuild); a build failure routes
+ * to onBuildFailed. `changedPaths` are the files that triggered THIS rebuild —
+ * threaded so the subscriber can pick a style-only hot swap over a full reload. */
+export declare function runRebuild(compileWorker: CompileWorker, buildRequest: BuildRequest, sessionApps: AppInfo[], onBuildCompleted: (changedPaths: string[]) => void, onBuildFailed: (err: unknown) => void, changedPaths?: string[]): Promise<void>;
+//# sourceMappingURL=rebuild-dispatch.d.ts.map

package/dist/rebuild-dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebuild-dispatch.d.ts","sourceRoot":"","sources":["../src/rebuild-dispatch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAEtE,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAI/E;AAaD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,MAAM,EAAE,EAAE,cAAc,GAAE,MAAM,EAAO,GAAG,OAAO,CAOhG;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC3C,UAAU,EAAE,OAAO,CAAA;IACnB,SAAS,EAAE,MAAM,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAA;IACzC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAA;IAChD,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;IACpB,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE;QAAE,YAAY,EAAE,MAAM,EAAE,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAA;CAC3E,GAAG,CAAC,YAAY,CAAC,EAAE,MAAM,EAAE,KAAK,IAAI,CAiBpC;AAED;;;mFAGmF;AACnF,wBAAsB,UAAU,CAC/B,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,OAAO,EAAE,EACtB,gBAAgB,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,IAAI,EAClD,aAAa,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,EACrC,YAAY,GAAE,MAAM,EAAO,GACzB,OAAO,CAAC,IAAI,CAAC,CASf"}

package/dist/rebuild-dispatch.js

@@ -0,0 +1,79 @@
+import path from 'node:path';
+/** Insert or replace `rebuilt` in the session's app list, keyed by appId. */
+export function upsertSessionApp(sessionApps, rebuilt) {
+    const idx = sessionApps.findIndex(a => a.appId === rebuilt.appId);
+    if (idx === -1)
+        sessionApps.push(rebuilt);
+    else
+        sessionApps[idx] = rebuilt;
+}
+/**
+ * Stylesheet extensions whose recompile can hot-swap in place (no full reload):
+ * the built-in `wx*`/`dd*` style dialects plus the CSS pre-processors dimina
+ * feeds through. A rebuild touching ONLY these can swap each `<link>` instead of
+ * reloading the page, because the compiled CSS scope id is a deterministic
+ * `hash(path)` — the recompiled `.css` keeps the same `[data-v-<id>]` selectors,
+ * so they still match the already-mounted DOM. Custom dialects (`.qdss`) are
+ * added per-project via `fileTypes.style`.
+ */
+const DEFAULT_STYLE_EXTS = ['.wxss', '.ddss', '.css', '.less', '.scss', '.sass'];
+/**
+ * True iff `changedPaths` is non-empty AND every path is a stylesheet — the
+ * precondition for a style-only hot swap. Empty is false: "no known paths"
+ * (e.g. a coalesced rebuild that lost its change list) must fall back to a full
+ * reload rather than silently assume styles-only. `extraStyleExts` (from
+ * `fileTypes.style`) is merged in; a leading dot is optional and matching is
+ * case-insensitive.
+ */
+export function isStyleOnlyChange(changedPaths, extraStyleExts = []) {
+    if (changedPaths.length === 0)
+        return false;
+    const exts = new Set([...DEFAULT_STYLE_EXTS, ...extraStyleExts.map(e => (e.startsWith('.') ? e : `.${e}`))]
+        .map(e => e.toLowerCase()));
+    return changedPaths.every(p => exts.has(path.extname(p).toLowerCase()));
+}
+/**
+ * Compose the "build completed" subscriber — the single place deciding which of
+ * two INDEPENDENT reactions run: reflecting the rebuild in the preview, and the
+ * caller's `onRebuild`. When `autoReload` is on and the rebuild touched ONLY
+ * stylesheets (`isStyleOnlyChange`), it hot-swaps the stylesheets in place
+ * (`getReloadStyles`) so the page stack / form state survives; otherwise it does
+ * a full `getReload()` page reload. With `autoReload` off, neither is called
+ * (auto-compile stays on, preview frozen). Both `getReload`/`getReloadStyles`
+ * are read at call time because the dev server assigns them after this
+ * subscriber is wired; `getReloadStyles` may be absent (older fe server) — then
+ * even a style-only change falls back to a full reload.
+ */
+export function composeBuildCompleted(opts) {
+    return (changedPaths = []) => {
+        const styleOnly = isStyleOnlyChange(changedPaths, opts.styleExts);
+        if (opts.autoReload) {
+            const reloadStyles = opts.getReloadStyles?.();
+            if (reloadStyles && styleOnly) {
+                reloadStyles();
+            }
+            else {
+                opts.getReload()?.();
+            }
+        }
+        // Hand the host the same style-only verdict the SSE dispatch used, so a
+        // native host (devtools simulator — no SSE client) can pick its OWN fast
+        // path (in-place stylesheet swap) instead of a full simulator respawn.
+        opts.onRebuild?.({ changedPaths, styleOnly });
+    };
+}
+/** Run one watcher-triggered rebuild, then fan out to the build-completed
+ * subscriber (style hot-swap or full reload + onRebuild); a build failure routes
+ * to onBuildFailed. `changedPaths` are the files that triggered THIS rebuild —
+ * threaded so the subscriber can pick a style-only hot swap over a full reload. */
+export async function runRebuild(compileWorker, buildRequest, sessionApps, onBuildCompleted, onBuildFailed, changedPaths = []) {
+    try {
+        const rebuilt = (await compileWorker.build(buildRequest));
+        if (rebuilt)
+            upsertSessionApp(sessionApps, rebuilt);
+        onBuildCompleted(changedPaths);
+    }
+    catch (e) {
+        onBuildFailed(e);
+    }
+}

package/dist/style-hot-reload.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=style-hot-reload.test.d.ts.map

package/dist/style-hot-reload.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"style-hot-reload.test.d.ts","sourceRoot":"","sources":["../src/style-hot-reload.test.ts"],"names":[],"mappings":""}

package/dist/style-hot-reload.test.js

@@ -0,0 +1,185 @@
+import { describe, expect, it, vi } from 'vitest';
+import { composeBuildCompleted, isStyleOnlyChange } from './index.js';
+describe('isStyleOnlyChange', () => {
+    it('returns true when every changed path is a built-in stylesheet extension', () => {
+        expect(isStyleOnlyChange(['a.wxss', 'b.ddss', 'c.css', 'd.less', 'e.scss', 'f.sass'])).toBe(true);
+    });
+    it('returns false for an empty change set', () => {
+        expect(isStyleOnlyChange([])).toBe(false);
+    });
+    it('returns false for a mix of style and non-style files', () => {
+        expect(isStyleOnlyChange(['a.wxss', 'b.js'])).toBe(false);
+    });
+    it('returns false for a single non-style file', () => {
+        expect(isStyleOnlyChange(['app.js'])).toBe(false);
+    });
+    it('accepts extra style extensions without a leading dot', () => {
+        expect(isStyleOnlyChange(['page.qdss'], ['qdss'])).toBe(true);
+    });
+    it('accepts extra style extensions with a leading dot', () => {
+        expect(isStyleOnlyChange(['page.qdss'], ['.qdss'])).toBe(true);
+    });
+    it('is case-insensitive on both the path extension and the extra extension', () => {
+        expect(isStyleOnlyChange(['X.WXSS'])).toBe(true);
+        expect(isStyleOnlyChange(['page.QDSS'], ['qdss'])).toBe(true);
+    });
+    it('treats a path with no extension as not style-only', () => {
+        expect(isStyleOnlyChange(['Makefile'])).toBe(false);
+    });
+    it('only considers the extension, ignoring absolute vs relative path shape', () => {
+        expect(isStyleOnlyChange(['/a/b/page.wxss'])).toBe(true);
+        expect(isStyleOnlyChange(['page.js'])).toBe(false);
+    });
+});
+describe('composeBuildCompleted', () => {
+    it('when autoReload is false, calls neither reload nor reloadStyles, but still calls onRebuild', () => {
+        const reload = vi.fn();
+        const reloadStyles = vi.fn();
+        const onRebuild = vi.fn();
+        const fn = composeBuildCompleted({
+            autoReload: false,
+            getReload: () => reload,
+            getReloadStyles: () => reloadStyles,
+            onRebuild,
+        });
+        fn(['a.wxss']);
+        expect(reload).not.toHaveBeenCalled();
+        expect(reloadStyles).not.toHaveBeenCalled();
+        expect(onRebuild).toHaveBeenCalledTimes(1);
+    });
+    it('when autoReload is true and change is style-only with reloadStyles available, hot-swaps styles only', () => {
+        const reload = vi.fn();
+        const reloadStyles = vi.fn();
+        const fn = composeBuildCompleted({
+            autoReload: true,
+            getReload: () => reload,
+            getReloadStyles: () => reloadStyles,
+        });
+        fn(['a.wxss', 'b.css']);
+        expect(reloadStyles).toHaveBeenCalledTimes(1);
+        expect(reload).not.toHaveBeenCalled();
+    });
+    it('when style-only but reloadStyles is absent, falls back to a full reload', () => {
+        const reload = vi.fn();
+        const fn = composeBuildCompleted({
+            autoReload: true,
+            getReload: () => reload,
+            getReloadStyles: () => undefined,
+        });
+        fn(['a.wxss']);
+        expect(reload).toHaveBeenCalledTimes(1);
+    });
+    it('when the change is not style-only, does a full reload and does not call reloadStyles', () => {
+        const reload = vi.fn();
+        const reloadStyles = vi.fn();
+        const fn = composeBuildCompleted({
+            autoReload: true,
+            getReload: () => reload,
+            getReloadStyles: () => reloadStyles,
+        });
+        fn(['a.wxss', 'b.js']);
+        expect(reload).toHaveBeenCalledTimes(1);
+        expect(reloadStyles).not.toHaveBeenCalled();
+    });
+    it('calls onRebuild on every invocation regardless of autoReload', () => {
+        const onRebuild = vi.fn();
+        const reload = vi.fn();
+        const fnOff = composeBuildCompleted({
+            autoReload: false,
+            getReload: () => reload,
+            onRebuild,
+        });
+        fnOff(['a.js']);
+        const fnOn = composeBuildCompleted({
+            autoReload: true,
+            getReload: () => reload,
+            onRebuild,
+        });
+        fnOn(['a.js']);
+        expect(onRebuild).toHaveBeenCalledTimes(2);
+    });
+    it('honors custom styleExts so a project dialect file hot-swaps too', () => {
+        const reload = vi.fn();
+        const reloadStyles = vi.fn();
+        const fn = composeBuildCompleted({
+            autoReload: true,
+            getReload: () => reload,
+            getReloadStyles: () => reloadStyles,
+            styleExts: ['qdss'],
+        });
+        fn(['theme.qdss']);
+        expect(reloadStyles).toHaveBeenCalledTimes(1);
+        expect(reload).not.toHaveBeenCalled();
+    });
+    it('when called with no changedPaths, treats it as empty and does a full reload', () => {
+        const reload = vi.fn();
+        const reloadStyles = vi.fn();
+        const fn = composeBuildCompleted({
+            autoReload: true,
+            getReload: () => reload,
+            getReloadStyles: () => reloadStyles,
+        });
+        fn();
+        expect(reload).toHaveBeenCalledTimes(1);
+        expect(reloadStyles).not.toHaveBeenCalled();
+    });
+    it('reads getReload/getReloadStyles at call time, not at compose time', () => {
+        let currentReload = vi.fn();
+        const fn = composeBuildCompleted({
+            autoReload: true,
+            getReload: () => currentReload,
+        });
+        const replacedReload = vi.fn();
+        currentReload = replacedReload;
+        fn(['a.js']);
+        expect(replacedReload).toHaveBeenCalledTimes(1);
+    });
+});
+describe('composeBuildCompleted: onRebuild receives the style-only verdict', () => {
+    it('an all-.wxss change set reports styleOnly:true with the original changedPaths', () => {
+        const onRebuild = vi.fn();
+        const reload = vi.fn();
+        const changedPaths = ['a.wxss', 'b.wxss'];
+        const fn = composeBuildCompleted({
+            autoReload: false,
+            getReload: () => reload,
+            onRebuild,
+        });
+        fn(changedPaths);
+        expect(onRebuild.mock.calls[0][0]).toEqual({ changedPaths, styleOnly: true });
+    });
+    it('a mixed .wxss + .js change set reports styleOnly:false', () => {
+        const onRebuild = vi.fn();
+        const reload = vi.fn();
+        const fn = composeBuildCompleted({
+            autoReload: false,
+            getReload: () => reload,
+            onRebuild,
+        });
+        fn(['a.wxss', 'a.js']);
+        expect(onRebuild.mock.calls[0][0].styleOnly).toBe(false);
+    });
+    it('a custom styleExts-only change (e.g. .qdss) reports styleOnly:true', () => {
+        const onRebuild = vi.fn();
+        const reload = vi.fn();
+        const fn = composeBuildCompleted({
+            autoReload: false,
+            getReload: () => reload,
+            styleExts: ['qdss'],
+            onRebuild,
+        });
+        fn(['theme.qdss']);
+        expect(onRebuild.mock.calls[0][0].styleOnly).toBe(true);
+    });
+    it('called with no changedPaths reports styleOnly:false and an empty changedPaths array', () => {
+        const onRebuild = vi.fn();
+        const reload = vi.fn();
+        const fn = composeBuildCompleted({
+            autoReload: false,
+            getReload: () => reload,
+            onRebuild,
+        });
+        fn();
+        expect(onRebuild.mock.calls[0][0]).toEqual({ changedPaths: [], styleOnly: false });
+    });
+});