Init

node_modules/@preact/preset-vite/dist/cjs/devtools.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from "vite";
+import type { RollupFilter } from "./utils.js";
+export interface PreactDevtoolsPluginOptions {
+    devtoolsInProd?: boolean;
+    devToolsEnabled?: boolean;
+    shouldTransform: RollupFilter;
+}
+export declare function preactDevtoolsPlugin({ devtoolsInProd, devToolsEnabled, shouldTransform, }: PreactDevtoolsPluginOptions): Plugin;

node_modules/@preact/preset-vite/dist/cjs/devtools.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preactDevtoolsPlugin = void 0;
+const vite_1 = require("vite");
+const path_1 = __importDefault(require("path"));
+const debug_1 = __importDefault(require("debug"));
+const kl = __importStar(require("kolorist"));
+const utils_js_1 = require("./utils.js");
+function preactDevtoolsPlugin({ devtoolsInProd, devToolsEnabled, shouldTransform, }) {
+    const log = (0, debug_1.default)("vite:preact-devtools");
+    let entry = "";
+    let config;
+    let found = false;
+    const plugin = {
+        name: "preact:devtools",
+        // Ensure that we resolve before everything else
+        enforce: "pre",
+        config() {
+            return {
+                optimizeDeps: {
+                    include: ["preact/debug", "preact/devtools"],
+                },
+            };
+        },
+        configResolved(resolvedConfig) {
+            config = resolvedConfig;
+            devToolsEnabled =
+                devToolsEnabled !== null && devToolsEnabled !== void 0 ? devToolsEnabled : (!config.isProduction || devtoolsInProd);
+        },
+        resolveId(url, importer = "") {
+            const { id } = (0, utils_js_1.parseId)(url);
+            // Get the main entry file to inject into
+            if (!found && /\.html$/.test(importer) && shouldTransform(id)) {
+                found = true;
+                entry = (0, vite_1.normalizePath)(path_1.default.join(config.root, id));
+                // TODO: Vite types require explicit return
+                // undefined here. They're lacking the "void" type
+                // in their declarations
+                return undefined;
+            }
+        },
+        transform(code, url) {
+            const { id } = (0, utils_js_1.parseId)(url);
+            if (entry === id && (!config.isProduction || devToolsEnabled)) {
+                const source = config.isProduction ? "preact/devtools" : "preact/debug";
+                code = `import "${source}";\n${code}`;
+                log(`[inject] ${kl.cyan(source)} -> ${kl.dim(id)}`);
+                return code;
+            }
+        },
+    };
+    return plugin;
+}
+exports.preactDevtoolsPlugin = preactDevtoolsPlugin;

node_modules/@preact/preset-vite/dist/cjs/index.d.ts

@@ -0,0 +1,83 @@
+import type { Plugin } from "vite";
+import type { FilterPattern } from "@rollup/pluginutils";
+import type { ParserOptions } from "@babel/parser";
+import type { TransformOptions } from "@babel/core";
+export type BabelOptions = Omit<TransformOptions, "ast" | "filename" | "root" | "sourceFileName" | "sourceMaps" | "inputSourceMap">;
+export interface PreactPluginOptions {
+    /**
+     * Inject devtools bridge in production bundle instead of only in development mode.
+     * @default false
+     */
+    devtoolsInProd?: boolean;
+    /**
+     * Whether to use Preact devtools
+     * @default true
+     */
+    devToolsEnabled?: boolean;
+    /**
+     * Whether to use prefresh HMR
+     * @default true
+     */
+    prefreshEnabled?: boolean;
+    /**
+     * Whether to alias react, react-dom to preact/compat
+     * @default true
+     */
+    reactAliasesEnabled?: boolean;
+    /**
+     * Prerender plugin options
+     */
+    prerender?: {
+        /**
+         * Whether to prerender your app on build
+         */
+        enabled: boolean;
+        /**
+         * Absolute path to script containing an exported `prerender()` function
+         */
+        prerenderScript?: string;
+        /**
+         * Query selector for specifying where to insert prerender result in your HTML template
+         */
+        renderTarget?: string;
+        /**
+         * Additional routes that should be prerendered
+         */
+        additionalPrerenderRoutes?: string[];
+        /**
+         * Vite's preview server won't use our prerendered HTML by default, this middleware correct this
+         */
+        previewMiddlewareEnabled?: boolean;
+        /**
+         * Path to use as a fallback/404 route, i.e., `/404` or `/not-found`
+         */
+        previewMiddlewareFallback?: string;
+    };
+    /**
+     * RegExp or glob to match files to be transformed
+     */
+    include?: FilterPattern;
+    /**
+     * RegExp or glob to match files to NOT be transformed
+     */
+    exclude?: FilterPattern;
+    /**
+     * Babel configuration applied in both dev and prod.
+     */
+    babel?: BabelOptions;
+    /**
+     * Import Source for jsx. Defaults to "preact".
+     */
+    jsxImportSource?: string;
+}
+export interface PreactBabelOptions extends BabelOptions {
+    plugins: Extract<BabelOptions["plugins"], any[]>;
+    presets: Extract<BabelOptions["presets"], any[]>;
+    overrides: Extract<BabelOptions["overrides"], any[]>;
+    parserOpts: ParserOptions & {
+        plugins: Extract<ParserOptions["plugins"], any[]>;
+    };
+}
+declare function preactPlugin({ devtoolsInProd, devToolsEnabled, prefreshEnabled, reactAliasesEnabled, prerender, include, exclude, babel, jsxImportSource, }?: PreactPluginOptions): Plugin[];
+export default preactPlugin;
+export { preactPlugin as preact };

node_modules/@preact/preset-vite/dist/cjs/index.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preact = void 0;
+const vite_1 = __importDefault(require("@prefresh/vite"));
+const devtools_js_1 = require("./devtools.js");
+const utils_js_1 = require("./utils.js");
+const vite_prerender_plugin_1 = require("vite-prerender-plugin");
+const core_1 = require("@babel/core");
+// @ts-ignore package doesn't ship with declaration files
+const plugin_transform_react_jsx_1 = __importDefault(require("@babel/plugin-transform-react-jsx"));
+// @ts-ignore package doesn't ship with declaration files
+const plugin_transform_react_jsx_development_1 = __importDefault(require("@babel/plugin-transform-react-jsx-development"));
+// @ts-ignore package doesn't ship with declaration files
+const babel_plugin_transform_hook_names_1 = __importDefault(require("babel-plugin-transform-hook-names"));
+// Taken from https://github.com/vitejs/vite/blob/main/packages/plugin-react/src/index.ts
+function preactPlugin({ devtoolsInProd, devToolsEnabled, prefreshEnabled, reactAliasesEnabled, prerender, include, exclude, babel, jsxImportSource, } = {}) {
+    var _a;
+    const baseParserOptions = [
+        "importMeta",
+        "explicitResourceManagement",
+        "topLevelAwait",
+    ];
+    let config;
+    let babelOptions = {
+        babelrc: false,
+        configFile: false,
+        ...babel,
+    };
+    babelOptions.plugins || (babelOptions.plugins = []);
+    babelOptions.presets || (babelOptions.presets = []);
+    babelOptions.overrides || (babelOptions.overrides = []);
+    babelOptions.parserOpts || (babelOptions.parserOpts = {});
+    (_a = babelOptions.parserOpts).plugins || (_a.plugins = []);
+    let useBabel = typeof babel !== "undefined";
+    const shouldTransform = (0, utils_js_1.createFilter)(include || [/\.[cm]?[tj]sx?$/], exclude || [/node_modules/]);
+    devtoolsInProd = devtoolsInProd !== null && devtoolsInProd !== void 0 ? devtoolsInProd : false;
+    prefreshEnabled = prefreshEnabled !== null && prefreshEnabled !== void 0 ? prefreshEnabled : true;
+    reactAliasesEnabled = reactAliasesEnabled !== null && reactAliasesEnabled !== void 0 ? reactAliasesEnabled : true;
+    prerender = prerender !== null && prerender !== void 0 ? prerender : { enabled: false };
+    const prerenderPlugin = (0, vite_prerender_plugin_1.vitePrerenderPlugin)(prerender);
+    if (!prerender.previewMiddlewareEnabled) {
+        const idx = prerenderPlugin.findIndex(p => p.name == "serve-prerendered-html");
+        if (idx > -1) {
+            prerenderPlugin.splice(idx, 1);
+        }
+    }
+    const jsxPlugin = {
+        name: "vite:preact-jsx",
+        enforce: "pre",
+        config() {
+            return {
+                build: {
+                    rollupOptions: {
+                        onwarn(warning, warn) {
+                            // Silence Rollup's module-level directive warnings re:"use client".
+                            // They're likely to come from `node_modules` and won't be actionable.
+                            if (warning.code === "MODULE_LEVEL_DIRECTIVE" &&
+                                warning.message.includes("use client"))
+                                return;
+                            // ESBuild seemingly doesn't include mappings for directives, causing
+                            // Rollup to emit warnings about missing source locations. This too is
+                            // likely to come from `node_modules` and won't be actionable.
+                            // evanw/esbuild#3548
+                            if (warning.code === "SOURCEMAP_ERROR" &&
+                                warning.message.includes("resolve original location") &&
+                                warning.pos === 0)
+                                return;
+                            warn(warning);
+                        },
+                    },
+                },
+                esbuild: useBabel
+                    ? undefined
+                    : {
+                        jsx: "automatic",
+                        jsxImportSource: jsxImportSource !== null && jsxImportSource !== void 0 ? jsxImportSource : "preact",
+                    },
+                optimizeDeps: {
+                    include: ["preact", "preact/jsx-runtime", "preact/jsx-dev-runtime"],
+                },
+            };
+        },
+        configResolved(resolvedConfig) {
+            config = resolvedConfig;
+            devToolsEnabled =
+                devToolsEnabled !== null && devToolsEnabled !== void 0 ? devToolsEnabled : (!config.isProduction || devtoolsInProd);
+            useBabel || (useBabel = !config.isProduction || !!devToolsEnabled);
+        },
+        async transform(code, url) {
+            // Ignore query parameters, as in Vue SFC virtual modules.
+            const { id } = (0, utils_js_1.parseId)(url);
+            if (!useBabel || !shouldTransform(id))
+                return;
+            const parserPlugins = [
+                ...baseParserOptions,
+                "classProperties",
+                "classPrivateProperties",
+                "classPrivateMethods",
+                !id.endsWith(".ts") && "jsx",
+                /\.tsx?$/.test(id) && "typescript",
+            ].filter(Boolean);
+            const result = await (0, core_1.transformAsync)(code, {
+                ...babelOptions,
+                ast: true,
+                root: config.root,
+                filename: id,
+                parserOpts: {
+                    ...babelOptions.parserOpts,
+                    sourceType: "module",
+                    allowAwaitOutsideFunction: true,
+                    plugins: parserPlugins,
+                },
+                generatorOpts: {
+                    ...babelOptions.generatorOpts,
+                    decoratorsBeforeExport: true,
+                },
+                plugins: [
+                    ...babelOptions.plugins,
+                    [
+                        config.isProduction ? plugin_transform_react_jsx_1.default : plugin_transform_react_jsx_development_1.default,
+                        {
+                            runtime: "automatic",
+                            importSource: jsxImportSource !== null && jsxImportSource !== void 0 ? jsxImportSource : "preact",
+                        },
+                    ],
+                    ...(devToolsEnabled ? [babel_plugin_transform_hook_names_1.default] : []),
+                ],
+                sourceMaps: true,
+                inputSourceMap: false,
+            });
+            // NOTE: Since no config file is being loaded, this path wouldn't occur.
+            if (!result)
+                return;
+            return {
+                code: result.code || code,
+                map: result.map,
+            };
+        },
+    };
+    return [
+        ...(reactAliasesEnabled
+            ? [
+                {
+                    name: "preact:config",
+                    config() {
+                        return {
+                            resolve: {
+                                alias: {
+                                    "react-dom/test-utils": "preact/test-utils",
+                                    "react-dom": "preact/compat",
+                                    react: "preact/compat",
+                                },
+                            },
+                        };
+                    },
+                },
+            ]
+            : []),
+        jsxPlugin,
+        (0, devtools_js_1.preactDevtoolsPlugin)({
+            devtoolsInProd,
+            devToolsEnabled,
+            shouldTransform,
+        }),
+        ...(prefreshEnabled
+            ? [(0, vite_1.default)({ include, exclude, parserPlugins: baseParserOptions })]
+            : []),
+        ...(prerender.enabled ? prerenderPlugin : []),
+    ];
+}
+exports.preact = preactPlugin;
+exports.default = preactPlugin;

node_modules/@preact/preset-vite/dist/cjs/utils.d.ts

@@ -0,0 +1,6 @@
+import type { CreateFilter } from "@rollup/pluginutils";
+export { createFilter } from "@rollup/pluginutils";
+export type RollupFilter = ReturnType<CreateFilter>;
+export declare function parseId(url: string): {
+    id: string;
+};

node_modules/@preact/preset-vite/dist/cjs/utils.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseId = exports.createFilter = void 0;
+var pluginutils_1 = require("@rollup/pluginutils");
+Object.defineProperty(exports, "createFilter", { enumerable: true, get: function () { return pluginutils_1.createFilter; } });
+// Allows to ignore query parameters, as in Vue SFC virtual modules.
+function parseId(url) {
+    return { id: url.split("?", 2)[0] };
+}
+exports.parseId = parseId;