@hanzogui/vite-plugin 8.3.1 → 8.3.2

package/dist/cjs/extensions.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extensions = void 0;
+exports.extensions = [
+    '.ios.js',
+    '.native.js',
+    '.native.ts',
+    '.native.tsx',
+    '.js',
+    '.jsx',
+    '.json',
+    '.ts',
+    '.tsx',
+    '.mjs',
+];
+//# sourceMappingURL=extensions.js.map

package/dist/cjs/extensions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.js","sourceRoot":"","sources":["../../src/extensions.ts"],"names":[],"mappings":";;;AAAa,QAAA,UAAU,GAAG;IACxB,SAAS;IACT,YAAY;IACZ,YAAY;IACZ,aAAa;IACb,KAAK;IACL,MAAM;IACN,OAAO;IACP,KAAK;IACL,MAAM;IACN,MAAM;CACP,CAAA"}

package/dist/cjs/here.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.url = void 0;
+const node_url_1 = require("node:url");
+exports.url = (0, node_url_1.pathToFileURL)(__filename).href;
+//# sourceMappingURL=here.js.map

package/dist/cjs/here.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"here.cjs.js","sourceRoot":"","sources":["../../src/here.cjs.ts"],"names":[],"mappings":";;;AAAA,uCAAwC;AAE3B,QAAA,GAAG,GAAG,IAAA,wBAAa,EAAC,UAAU,CAAC,CAAC,IAAI,CAAA"}

package/dist/cjs/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./plugin.js"), exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;AAAA,sDAA2B"}

package/dist/cjs/loadGui.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGuiOptions = getGuiOptions;
+exports.getLoadPromise = getLoadPromise;
+exports.loadGuiBuildConfig = loadGuiBuildConfig;
+exports.ensureFullConfigLoaded = ensureFullConfigLoaded;
+exports.cleanup = cleanup;
+const tslib_1 = require("tslib");
+const StaticWorker = tslib_1.__importStar(require("@hanzogui/static-worker"));
+// use globalThis to share state across vite environments (SSR, client, etc.)
+const LOAD_STATE_KEY = '__hanzogui_load_state__';
+function getLoadState() {
+    if (!globalThis[LOAD_STATE_KEY]) {
+        ;
+        globalThis[LOAD_STATE_KEY] = {
+            loadPromise: null,
+            loadedOptions: null,
+            fullConfigLoaded: false,
+            fullConfigLoadPromise: null,
+        };
+    }
+    return globalThis[LOAD_STATE_KEY];
+}
+function getGuiOptions() {
+    return getLoadState().loadedOptions;
+}
+function getLoadPromise() {
+    return getLoadState().loadPromise;
+}
+/**
+ * Load just the hanzogui.build.ts config (lightweight)
+ * This doesn't bundle the full hanzogui config - call ensureFullConfigLoaded() for that
+ */
+async function loadGuiBuildConfig(optionsIn) {
+    const state = getLoadState();
+    if (state.loadedOptions)
+        return state.loadedOptions;
+    if (state.loadPromise)
+        return state.loadPromise;
+    state.loadPromise = (async () => {
+        const options = await StaticWorker.loadGuiBuildConfig({
+            ...optionsIn,
+            platform: 'web',
+        });
+        state.loadedOptions = options;
+        return options;
+    })();
+    return state.loadPromise;
+}
+/**
+ * Ensure the full hanzogui config is loaded (heavy - bundles config + components)
+ * Call this lazily when transform/extraction is actually needed
+ */
+async function ensureFullConfigLoaded() {
+    const state = getLoadState();
+    if (state.fullConfigLoaded)
+        return;
+    if (state.fullConfigLoadPromise)
+        return state.fullConfigLoadPromise;
+    // set promise immediately to prevent race conditions
+    // (don't await loadGuiBuildConfig before setting this)
+    state.fullConfigLoadPromise = (async () => {
+        const options = await loadGuiBuildConfig();
+        // load full hanzogui config in worker (asynchronous)
+        if (!options.disableWatchGuiConfig && !options.disable) {
+            await StaticWorker.loadGui({
+                components: ['@hanzo/gui'],
+                platform: 'web',
+                ...options,
+            });
+        }
+        state.fullConfigLoaded = true;
+    })();
+    return state.fullConfigLoadPromise;
+}
+async function cleanup() {
+    await StaticWorker.destroyPool();
+    const state = getLoadState();
+    state.loadPromise = null;
+    state.loadedOptions = null;
+    state.fullConfigLoaded = false;
+    state.fullConfigLoadPromise = null;
+}
+//# sourceMappingURL=loadGui.js.map

package/dist/cjs/loadGui.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadGui.js","sourceRoot":"","sources":["../../src/loadGui.ts"],"names":[],"mappings":";;;;;;;;AAAA,MAAY,YAAY,4DAA+B;AAGvD,6EAA6E;AAC7E,MAAM,cAAc,GAAG,yBAAyB,CAAA;AAShD,SAAS,YAAY;IACnB,IAAI,CAAE,UAAkB,CAAC,cAAc,CAAC,EAAE,CAAC;QACzC,CAAC;QAAC,UAAkB,CAAC,cAAc,CAAC,GAAG;YACrC,WAAW,EAAE,IAAI;YACjB,aAAa,EAAE,IAAI;YACnB,gBAAgB,EAAE,KAAK;YACvB,qBAAqB,EAAE,IAAI;SAC5B,CAAA;IACH,CAAC;IACD,OAAQ,UAAkB,CAAC,cAAc,CAAC,CAAA;AAC5C,CAAC;AAED;IACE,OAAO,YAAY,EAAE,CAAC,aAAa,CAAA;AACrC,CAAC;AAED;IACE,OAAO,YAAY,EAAE,CAAC,WAAW,CAAA;AACnC,CAAC;AAED;;;GAGG;AACI,KAAK,6BACV,SAA+B;IAE/B,MAAM,KAAK,GAAG,YAAY,EAAE,CAAA;IAC5B,IAAI,KAAK,CAAC,aAAa;QAAE,OAAO,KAAK,CAAC,aAAa,CAAA;IACnD,IAAI,KAAK,CAAC,WAAW;QAAE,OAAO,KAAK,CAAC,WAAW,CAAA;IAE/C,KAAK,CAAC,WAAW,GAAG,CAAC,KAAK,IAAI,EAAE;QAC9B,MAAM,OAAO,GAAG,MAAM,YAAY,CAAC,kBAAkB,CAAC;YACpD,GAAG,SAAS;YACZ,QAAQ,EAAE,KAAK;SAChB,CAAC,CAAA;QAEF,KAAK,CAAC,aAAa,GAAG,OAAO,CAAA;QAC7B,OAAO,OAAO,CAAA;IAChB,CAAC,CAAC,EAAE,CAAA;IAEJ,OAAO,KAAK,CAAC,WAAW,CAAA;AAC1B,CAAC;AAED;;;GAGG;AACI,KAAK;IACV,MAAM,KAAK,GAAG,YAAY,EAAE,CAAA;IAE5B,IAAI,KAAK,CAAC,gBAAgB;QAAE,OAAM;IAClC,IAAI,KAAK,CAAC,qBAAqB;QAAE,OAAO,KAAK,CAAC,qBAAqB,CAAA;IAEnE,qDAAqD;IACrD,uDAAuD;IACvD,KAAK,CAAC,qBAAqB,GAAG,CAAC,KAAK,IAAI,EAAE;QACxC,MAAM,OAAO,GAAG,MAAM,kBAAkB,EAAE,CAAA;QAE1C,qDAAqD;QACrD,IAAI,CAAC,OAAO,CAAC,qBAAqB,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YACvD,MAAM,YAAY,CAAC,OAAO,CAAC;gBACzB,UAAU,EAAE,CAAC,YAAY,CAAC;gBAC1B,QAAQ,EAAE,KAAK;gBACf,GAAG,OAAO;aACX,CAAC,CAAA;QACJ,CAAC;QACD,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAA;IAC/B,CAAC,CAAC,EAAE,CAAA;IAEJ,OAAO,KAAK,CAAC,qBAAqB,CAAA;AACpC,CAAC;AAEM,KAAK;IACV,MAAM,YAAY,CAAC,WAAW,EAAE,CAAA;IAChC,MAAM,KAAK,GAAG,YAAY,EAAE,CAAA;IAC5B,KAAK,CAAC,WAAW,GAAG,IAAI,CAAA;IACxB,KAAK,CAAC,aAAa,GAAG,IAAI,CAAA;IAC1B,KAAK,CAAC,gBAAgB,GAAG,KAAK,CAAA;IAC9B,KAAK,CAAC,qBAAqB,GAAG,IAAI,CAAA;AACpC,CAAC"}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs" }

package/dist/cjs/plugin.js

@@ -0,0 +1,523 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hanzoguiAliases = hanzoguiAliases;
+exports.hanzoguiPlugin = hanzoguiPlugin;
+const tslib_1 = require("tslib");
+const Static = tslib_1.__importStar(require("@hanzogui/static-worker"));
+const static_worker_1 = require("@hanzogui/static-worker");
+const node_crypto_1 = require("node:crypto");
+const node_module_1 = require("node:module");
+const here_ts_1 = require("./here.js");
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const loadGui_ts_1 = require("./loadGui.js");
+// Plugin dependencies resolve from the plugin's own location, not the user's project.
+const _pluginRequire = (0, node_module_1.createRequire)(here_ts_1.url);
+const resolve = (name) => _pluginRequire.resolve(name);
+const normalizePath = (value) => value.replace(/\\/g, '/');
+/** what an installed package can hold extractable source in */
+const PACKAGE_EXTENSIONS = /\.(mjs|js|jsx|tsx)$/;
+const CACHE_KEY = '__hanzogui_vite_cache__';
+const CACHE_SIZE_KEY = '__hanzogui_vite_cache_size__';
+const PENDING_KEY = '__hanzogui_vite_pending__';
+function getSharedCache() {
+    if (!globalThis[CACHE_KEY]) {
+        ;
+        globalThis[CACHE_KEY] = {};
+    }
+    return globalThis[CACHE_KEY];
+}
+function getSharedCacheSize() {
+    return globalThis[CACHE_SIZE_KEY] || 0;
+}
+function setSharedCacheSize(size) {
+    ;
+    globalThis[CACHE_SIZE_KEY] = size;
+}
+function clearSharedCache() {
+    ;
+    globalThis[CACHE_KEY] = {};
+    globalThis[CACHE_SIZE_KEY] = 0;
+}
+// resolves package ids against the user's project root (not the plugin's
+// install location). returns true if the id is resolvable, false if the
+// dep isn't installed, safe to call for optional deps.
+function isInstalled(projectRoot, id) {
+    try {
+        const req = (0, node_module_1.createRequire)(node_path_1.default.join(projectRoot, 'package.json'));
+        req.resolve(id);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function addIfInstalled(userConf, projectRoot, ids) {
+    var _a;
+    const root = projectRoot || process.cwd();
+    userConf.optimizeDeps || (userConf.optimizeDeps = {});
+    (_a = userConf.optimizeDeps).include || (_a.include = []);
+    for (const id of ids) {
+        if (!userConf.optimizeDeps.include.includes(id) && isInstalled(root, id)) {
+            userConf.optimizeDeps.include.push(id);
+        }
+    }
+}
+// pending extractions map - dedupes concurrent requests for same file
+function getPendingExtractions() {
+    if (!globalThis[PENDING_KEY]) {
+        ;
+        globalThis[PENDING_KEY] = new Map();
+    }
+    return globalThis[PENDING_KEY];
+}
+/**
+ * returns vite-compatible aliases for hanzogui
+ * use this when you need control over alias ordering in your config
+ */
+function hanzoguiAliases(options = {}) {
+    const aliases = [];
+    if (options.svg) {
+        aliases.push({
+            find: 'react-native-svg',
+            replacement: resolve('@hanzogui/react-native-svg'),
+        });
+    }
+    if (options.rnwLite) {
+        // base package path for subpath imports (package directory, not entry file)
+        const rnwlBase = node_path_1.default.dirname(resolve('@hanzogui/react-native-web-lite/package.json'));
+        // vite aliases need the esm entry; require.resolve points at cjs.
+        const rnwl = normalizePath(node_path_1.default.join(rnwlBase, options.rnwLite === 'without-animated'
+            ? 'dist/esm/without-animated.js'
+            : 'dist/esm/index.js'));
+        aliases.push({
+            // map deep RNW paths like dist/exports/StyleSheet/preprocess to rnw-lite's flat structure
+            // extracts the final path segment (e.g. "preprocess" or "createReactDOMStyle")
+            find: /^react-native(?:-web)?\/dist\/(?:exports|modules)\/.*\/([^/]+)$/,
+            replacement: `${normalizePath(rnwlBase)}/dist/esm/$1.js`,
+        }, {
+            find: /^react-native$/,
+            replacement: rnwl,
+        }, {
+            find: /^react-native\/(Libraries\/Utilities\/codegenNativeComponent|Libraries\/Utilities\/codegenNativeCommand)$/,
+            replacement: `${rnwlBase}/$1`,
+        }, {
+            find: 'react-native/package.json',
+            replacement: resolve('@hanzogui/react-native-web-lite/package.json'),
+        }, {
+            find: /^react-native-web$/,
+            replacement: rnwl,
+        });
+    }
+    return aliases;
+}
+function hanzoguiPlugin({ disableResolveConfig, ...hanzoguiOptionsIn } = {}) {
+    // extraction ON by default, set disableExtraction: true to opt out
+    let shouldExtract = !hanzoguiOptionsIn.disableExtraction;
+    let watcher;
+    // temporary vxrn native env bridge
+    const enableNativeEnv = !!globalThis.__vxrnEnableNativeEnv;
+    const extensions = [
+        `.web.mjs`,
+        `.web.js`,
+        `.web.jsx`,
+        `.web.ts`,
+        `.web.tsx`,
+        '.mjs',
+        '.js',
+        '.mts',
+        '.ts',
+        '.jsx',
+        '.tsx',
+        '.json',
+    ];
+    // start loading immediately but don't block
+    (0, loadGui_ts_1.loadGuiBuildConfig)(hanzoguiOptionsIn);
+    // helper to await load when needed
+    const ensureLoaded = async () => {
+        const promise = (0, loadGui_ts_1.getLoadPromise)();
+        if (promise)
+            await promise;
+        const options = (0, loadGui_ts_1.getGuiOptions)();
+        // update shouldExtract from loaded config (hanzogui.build.ts)
+        if (options) {
+            shouldExtract = !options.disableExtraction;
+        }
+        return options;
+    };
+    // extract plugin state
+    const getHash = (input) => (0, node_crypto_1.createHash)('sha1').update(input).digest('base64');
+    // use shared cache across environments
+    const memoryCache = getSharedCache();
+    const cssMap = new Map();
+    let config;
+    let server;
+    const virtualExt = `.hanzogui.css`;
+    const getAbsoluteVirtualFileId = (filePath) => {
+        if (filePath.startsWith(config.root)) {
+            return filePath;
+        }
+        return normalizePath(node_path_1.default.join(config.root, filePath));
+    };
+    function isNotClient(environment) {
+        return environment?.name && environment.name !== 'client';
+    }
+    function isNative(environment) {
+        return (environment?.name && (environment.name === 'ios' || environment.name === 'android'));
+    }
+    function invalidateModule(absoluteId) {
+        if (!server)
+            return;
+        const { moduleGraph } = server;
+        const modules = moduleGraph.getModulesByFile(absoluteId);
+        if (modules) {
+            for (const module of modules) {
+                moduleGraph.invalidateModule(module);
+                module.lastHMRTimestamp = module.lastInvalidationTimestamp || Date.now();
+            }
+        }
+    }
+    const basePlugin = {
+        name: 'hanzogui',
+        enforce: 'pre',
+        configureServer(_server) {
+            server = _server;
+        },
+        async buildEnd() {
+            await watcher?.then((res) => {
+                res?.dispose();
+            });
+        },
+        async config(_, env) {
+            const options = await ensureLoaded();
+            if (!options) {
+                throw new Error(`No hanzogui options loaded`);
+            }
+            // start watching config if enabled
+            if (!options.disableWatchGuiConfig) {
+                watcher = Static.watchGuiConfig({
+                    components: ['@hanzo/gui'],
+                    config: './src/hanzogui.config.ts',
+                    ...options,
+                }).catch((err) => {
+                    console.error(` [Gui] Error watching config: ${err}`);
+                });
+            }
+            return {
+                envPrefix: ['GUI_'],
+                // A dependency that RENDERS is bundled, not externalised.
+                //
+                // An externalised package resolves react itself, and under SSR that is a
+                // second module instance of the one react in the tree — its dispatcher is
+                // null while the app renders, so the package's first hook throws and the
+                // whole page fails, not just the subtree. GuiProvider mounts a telemetry
+                // client for every app, so these two arrive in apps that never named them.
+                //
+                // It belongs here rather than in each app's config because every gui app
+                // already mounts this plugin, and a list repeated per app is a list the
+                // next app forgets.
+                ssr: { noExternal: ['@hanzo/event', '@hanzo/observe'] },
+                environments: {
+                    client: {
+                        define: {
+                            'process.env.GUI_IS_CLIENT': JSON.stringify(true),
+                            'process.env.GUI_ENVIRONMENT': '"client"',
+                        },
+                    },
+                },
+                define: {
+                    // reanimated support
+                    _frameTimestamp: undefined,
+                    _WORKLET: false,
+                    __DEV__: `${env.mode === 'development'}`,
+                    'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || env.mode),
+                    'process.env.ENABLE_RSC': JSON.stringify(process.env.ENABLE_RSC || ''),
+                    'process.env.ENABLE_STEPS': JSON.stringify(process.env.ENABLE_STEPS || ''),
+                    'process.env.IS_STATIC': JSON.stringify(false),
+                    ...(env.mode === 'production' && {
+                        'process.env.GUI_OPTIMIZE_THEMES': JSON.stringify(true),
+                    }),
+                },
+                resolve: disableResolveConfig || enableNativeEnv
+                    ? {}
+                    : {
+                        extensions,
+                        alias: {
+                            ...(options.platform !== 'native' && {
+                                'react-native/Libraries/Renderer/shims/ReactFabric': resolve('@hanzogui/proxy-worm'),
+                                'react-native/Libraries/Utilities/codegenNativeComponent': resolve('@hanzogui/proxy-worm'),
+                                'react-native-svg': resolve('@hanzogui/react-native-svg'),
+                                ...(!options?.useReactNativeWebLite && {
+                                    'react-native': resolve('react-native-web'),
+                                }),
+                            }),
+                        },
+                    },
+            };
+        },
+    };
+    const rnwLitePlugin = {
+        name: 'hanzogui-rnw-lite',
+        config() {
+            if (enableNativeEnv) {
+                return {};
+            }
+            const options = (0, loadGui_ts_1.getGuiOptions)();
+            if (!options?.useReactNativeWebLite) {
+                return {};
+            }
+            // react-native-web-lite imports memoize-one internally. the esbuild dep
+            // scanner doesn't follow it through the react-native -> rnw-lite alias, so
+            // vite discovers it only at request time, re-optimizes mid-load, and full
+            // reloads. on slow runners (CI) the in-flight optimized-dep request 504s
+            // ("Outdated Optimize Dep") and surfaces as a console error. pre-include
+            // it so the first optimize pass is complete and no reload is triggered.
+            const include = [];
+            if (isInstalled(process.cwd(), 'memoize-one')) {
+                include.push('memoize-one');
+            }
+            return {
+                resolve: {
+                    alias: hanzoguiAliases({ rnwLite: options.useReactNativeWebLite }),
+                },
+                optimizeDeps: {
+                    // upstream react-native-web must not be pre-bundled when aliased to lite
+                    exclude: ['react-native-web'],
+                    include,
+                },
+            };
+        },
+    };
+    // extract plugin for optimize mode
+    // always included, but checks shouldExtract dynamically after config loads
+    const extractPlugin = {
+        name: 'hanzogui-extract',
+        enforce: 'pre',
+        async config(userConf) {
+            var _a, _b;
+            // wait for config to load to know if we should extract
+            const options = await ensureLoaded();
+            userConf.optimizeDeps || (userConf.optimizeDeps = {});
+            (_a = userConf.optimizeDeps).include || (_a.include = []);
+            // inline-style-prefixer is CJS with __esModule and breaks without pre-bundling
+            // (reference error: exports is not defined). always include it.
+            userConf.optimizeDeps.include.push('inline-style-prefixer');
+            // pre-bundle hanzogui packages that use internal hooks (useThemeName, etc.)
+            // from sub-entries, vite's dep crawler can otherwise split them into a
+            // separate chunk with its own hanzogui copy, producing two ThemeStateContext
+            // instances and "Missing theme" errors at runtime.
+            //
+            // @hanzogui/sheet/controller is the lightweight controller subpath imported
+            // by popover/dialog/select; the app imports @hanzogui/sheet (full). if these
+            // land in separate optimized chunks they each get their own copy of
+            // SheetControllerContext, so the SheetController provider (from /controller)
+            // and the Sheet consumer (from the full entry) never match and adapted
+            // sheets silently never open. include both so they share one context chunk.
+            addIfInstalled(userConf, userConf.root, [
+                '@hanzogui/toast',
+                '@hanzogui/toast/v2',
+                '@hanzogui/sheet',
+                '@hanzogui/sheet/controller',
+            ]);
+            // dedupe hanzogui packages so nested resolutions collapse to a single
+            // instance. pairs with the include above: include pre-bundles, dedupe
+            // prevents duplicate bundling when sub-deps re-resolve them.
+            userConf.resolve || (userConf.resolve = {});
+            (_b = userConf.resolve).dedupe || (_b.dedupe = []);
+            for (const id of [
+                'hanzogui',
+                '@hanzogui/core',
+                '@hanzogui/web',
+                '@hanzogui/toast',
+                '@hanzogui/sheet',
+            ]) {
+                if (!userConf.resolve.dedupe.includes(id) &&
+                    isInstalled(userConf.root || process.cwd(), id)) {
+                    userConf.resolve.dedupe.push(id);
+                }
+            }
+            if (!shouldExtract)
+                return;
+            userConf.optimizeDeps.include.push('@hanzogui/core/inject-styles');
+        },
+        async configResolved(resolvedConfig) {
+            config = resolvedConfig;
+        },
+        async resolveId(source) {
+            if (!shouldExtract)
+                return;
+            if (isNative(this.environment)) {
+                return;
+            }
+            if (isNotClient(this.environment)) {
+                return;
+            }
+            const [validId, query] = source.split('?');
+            if (!validId.endsWith(virtualExt)) {
+                return;
+            }
+            const absoluteId = source.startsWith(config.root)
+                ? source
+                : getAbsoluteVirtualFileId(validId);
+            if (cssMap.has(absoluteId)) {
+                return absoluteId + (query ? `?${query}` : '');
+            }
+        },
+        async load(id) {
+            if (!shouldExtract)
+                return;
+            const options = (0, loadGui_ts_1.getGuiOptions)();
+            if (options?.disable) {
+                return;
+            }
+            if (isNative(this.environment)) {
+                return;
+            }
+            if (isNotClient(this.environment)) {
+                return;
+            }
+            const [validId] = id.split('?');
+            return cssMap.get(validId);
+        },
+        transform: {
+            order: 'pre',
+            async handler(code, id) {
+                // ensure hanzogui is loaded before transform
+                const options = await ensureLoaded();
+                // ensure full config (heavy bundling) is loaded before extraction
+                await (0, loadGui_ts_1.ensureFullConfigLoaded)();
+                // fully disabled = no extraction AND no debug attrs
+                if (options?.disable) {
+                    return;
+                }
+                if (isNative(this.environment)) {
+                    return;
+                }
+                const [validId] = id.split('?');
+                // app source is .tsx; an allowlisted package is whatever it publishes,
+                // which for our design system is the jsx-preserving .mjs/.js build
+                const pkg = (0, static_worker_1.installedPackageOf)(validId);
+                if (pkg
+                    ? !(0, static_worker_1.isExtractable)(validId, options?.extractPackages) ||
+                        !PACKAGE_EXTENSIONS.test(validId)
+                    : !validId.endsWith('.tsx')) {
+                    return;
+                }
+                const { shouldDisable, shouldPrintDebug } = await (0, static_worker_1.getPragmaOptions)({
+                    source: code,
+                    path: validId,
+                });
+                if (shouldPrintDebug) {
+                    console.trace(`Current file: ${id} in environment: ${this.environment?.name}, shouldDisable: ${shouldDisable}`);
+                    console.info(`\n\nOriginal source:\n${code}\n\n`);
+                }
+                if (shouldDisable) {
+                    return;
+                }
+                const isSSR = isNotClient(this.environment);
+                // cache key without environment - share compiled JS between SSR/client
+                const cacheKey = getHash(`${code}${id}`);
+                const pending = getPendingExtractions();
+                // helper to format result based on environment
+                const formatResult = (entry) => {
+                    const finalCode = !isSSR && entry.cssImport ? `${entry.js}\n${entry.cssImport}` : entry.js;
+                    return { code: finalCode, map: entry.map };
+                };
+                // check cache first
+                const cached = memoryCache[cacheKey];
+                if (cached) {
+                    if (process.env.DEBUG_GUI_CACHE) {
+                        console.info(`[hanzogui-cache] HIT ${this.environment?.name || 'unknown'} ${id.split('/').pop()} key=${cacheKey.slice(0, 8)}`);
+                    }
+                    return formatResult(cached);
+                }
+                // check if another request is already extracting this file
+                const pendingExtraction = pending.get(cacheKey);
+                if (pendingExtraction) {
+                    if (process.env.DEBUG_GUI_CACHE) {
+                        console.info(`[hanzogui-cache] WAIT ${this.environment?.name || 'unknown'} ${id.split('/').pop()} key=${cacheKey.slice(0, 8)}`);
+                    }
+                    const result = await pendingExtraction;
+                    if (result) {
+                        return formatResult(result);
+                    }
+                    return;
+                }
+                if (process.env.DEBUG_GUI_CACHE) {
+                    console.info(`[hanzogui-cache] EXTRACT ${this.environment?.name || 'unknown'} ${id.split('/').pop()} key=${cacheKey.slice(0, 8)}`);
+                }
+                // create extraction promise and store it for deduplication
+                const extractionPromise = (async () => {
+                    let extracted;
+                    try {
+                        extracted = await Static.extractToClassNames({
+                            source: code,
+                            sourcePath: validId,
+                            options: options,
+                            shouldPrintDebug,
+                        });
+                    }
+                    catch (err) {
+                        if (process.env.DEBUG_GUI_CACHE) {
+                            console.info(`[hanzogui-cache] ERROR extracting ${id.split('/').pop()}:`, err);
+                        }
+                        console.error(err instanceof Error ? err.message : String(err));
+                        return null;
+                    }
+                    if (!extracted) {
+                        if (process.env.DEBUG_GUI_CACHE) {
+                            console.info(`[hanzogui-cache] no extraction result for ${id.split('/').pop()}`);
+                        }
+                        return null;
+                    }
+                    const rootRelativeId = `${validId}${virtualExt}`;
+                    const absoluteId = getAbsoluteVirtualFileId(rootRelativeId);
+                    let cssImport = null;
+                    // store CSS and prepare import (but don't include in cached JS)
+                    if (extracted.styles) {
+                        this.addWatchFile(rootRelativeId);
+                        if (server && cssMap.has(absoluteId)) {
+                            invalidateModule(rootRelativeId);
+                        }
+                        cssImport = `import "${rootRelativeId}";`;
+                        cssMap.set(absoluteId, extracted.styles);
+                    }
+                    // cache the JS separately from CSS import
+                    const jsCode = extracted.js.toString();
+                    const cacheEntry = {
+                        js: jsCode,
+                        map: extracted.map,
+                        cssImport,
+                    };
+                    // track cache size and clear if too large (64MB)
+                    const newSize = getSharedCacheSize() + jsCode.length;
+                    if (newSize > 67108864) {
+                        clearSharedCache();
+                    }
+                    else {
+                        setSharedCacheSize(newSize);
+                    }
+                    memoryCache[cacheKey] = cacheEntry;
+                    if (process.env.DEBUG_GUI_CACHE) {
+                        console.info(`[hanzogui-cache] WRITE key=${cacheKey.slice(0, 8)} cacheSize=${Object.keys(memoryCache).length}`);
+                    }
+                    return cacheEntry;
+                })();
+                // store pending promise for deduplication
+                pending.set(cacheKey, extractionPromise);
+                try {
+                    const result = await extractionPromise;
+                    if (result) {
+                        return formatResult(result);
+                    }
+                    return;
+                }
+                finally {
+                    // clean up pending map
+                    pending.delete(cacheKey);
+                }
+            },
+        },
+    };
+    return [basePlugin, rnwLitePlugin, extractPlugin];
+}
+//# sourceMappingURL=plugin.js.map