@forgebook/react-native-web 0.0.0-stage → 0.2.0

package/dist/src/vite/forgebookFiles.js

@@ -0,0 +1,51 @@
+/**
+ * Whether a file is Forgebook's own: a module of the catalogue (its shell, its frame, this package) that a React Native
+ * project's compiling must leave alone, wherever it is installed.
+ *
+ * @remarks
+ * A file outside `node_modules` is taken for the project's own, so React Native's compiling (JSX in `.js`, the JSX
+ * import source, `require` of assets) reaches a monorepo's linked packages. Forgebook's own packages can be linked the
+ * same way (a monorepo that develops a catalogue beside it, or this repository): they are told by the name of the
+ * package that holds them, `forgebook` or `@forgebook/…`, read once per folder.
+ *
+ * @module
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+/** The name of the package each folder is in, by folder; none for a folder outside any package. */
+const packageNames = new Map();
+/**
+ * The name of the package a folder is in: its own `package.json`'s, or its parent's.
+ *
+ * @param dir - the folder, absolute.
+ */
+const packageNameOf = (dir) => {
+    if (packageNames.has(dir))
+        return packageNames.get(dir);
+    let name;
+    try {
+        const manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+        name =
+            typeof manifest === "object" &&
+                manifest !== null &&
+                "name" in manifest &&
+                typeof manifest.name === "string"
+                ? manifest.name
+                : "";
+    }
+    catch {
+        const parent = dirname(dir);
+        name = parent === dir ? undefined : packageNameOf(parent);
+    }
+    packageNames.set(dir, name);
+    return name;
+};
+/**
+ * Whether a file is in one of Forgebook's packages.
+ *
+ * @param file - the file's path, absolute, its query left out.
+ */
+export const isForgebookFile = (file) => {
+    const name = packageNameOf(dirname(file));
+    return name !== undefined && (name === "forgebook" || name.startsWith("@forgebook/"));
+};

package/dist/src/vite/nativePlugin.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The Vite plugins that let a React Native project's components run in the browser: `react-native` resolved to
+ * `react-native-web`, the web's files first, React Native's globals, JSX in `.js` files and Flow types compiled, and
+ * `require` of an image or a font made its address.
+ *
+ * @remarks
+ * Metro, React Native's bundler, does all of it for a phone; here Vite does it for the catalogue's frames. Three
+ * places read the project's code, and each compiles the same files (`isNativeSource`), so what draws on the dev
+ * server draws in a built catalogue and reads the same on the Node side:
+ *
+ * - the dev server's dependency pre-bundling (Rolldown, given a plugin of its own here);
+ * - Vite's own pipeline: the project's files on the dev server, everything in a build;
+ * - the dev server's Node side, where the agents' answers load the stories. Node itself would load a package Vite
+ *   leaves external, with the real `react-native` (Flow, native modules), so the packages written for React Native go
+ *   through Vite there too, pre-bundled as in the browser: they mix CommonJS files into ES modules, which only a bundle
+ *   runs on that side.
+ *
+ * A deep import of React Native's own files (`react-native/Libraries/…`) has no web version: it fails with a message
+ * naming the module, instead of a Flow syntax error deep inside React Native.
+ *
+ * @module
+ */
+import { type DepOptimizationOptions, type Plugin, type Rolldown, type UserConfig } from "vite";
+import type { ReactNativeWebOptions } from "./reactNativeWeb.ts";
+/**
+ * The plugin the dependency pre-bundling runs: the dependencies written for React Native compiled as Metro compiles
+ * them, their `.js` files read as JSX once their Flow types are gone, and their `require` of an asset made its
+ * address, as in a build (the pre-bundling would make it a module object, which `Image` cannot draw).
+ *
+ * @param nativePackages - the other packages written for React Native, by name.
+ */
+export declare const prebundlePlugin: (nativePackages: readonly string[]) => Rolldown.Plugin;
+/**
+ * What the plugin adds to Vite's configuration.
+ *
+ * @param isDevelopment - whether the catalogue runs on the dev server.
+ * @param options - the adapter's options: the other packages written for React Native, the JSX import source.
+ * @param entries - the files the dev server scans for the dependencies to pre-bundle (the story files, as Forgebook's
+ *   plugin names them for the browser), scanned on the Node side too.
+ */
+export declare const nativeConfig: (isDevelopment: boolean, options: ReactNativeWebOptions, entries: DepOptimizationOptions["entries"]) => UserConfig;
+/**
+ * The plugins.
+ *
+ * @param options - the packages written for React Native beyond React Native's and Expo's families.
+ * @returns the plugin that sets Vite up and compiles React Native's code, and the one that writes `require` of an
+ * asset as its import (after Vite's own compiling, on plain JavaScript).
+ */
+export declare const nativePlugins: (options: ReactNativeWebOptions) => Plugin[];

package/dist/src/vite/nativePlugin.js

@@ -0,0 +1,213 @@
+/**
+ * The Vite plugins that let a React Native project's components run in the browser: `react-native` resolved to
+ * `react-native-web`, the web's files first, React Native's globals, JSX in `.js` files and Flow types compiled, and
+ * `require` of an image or a font made its address.
+ *
+ * @remarks
+ * Metro, React Native's bundler, does all of it for a phone; here Vite does it for the catalogue's frames. Three
+ * places read the project's code, and each compiles the same files (`isNativeSource`), so what draws on the dev
+ * server draws in a built catalogue and reads the same on the Node side:
+ *
+ * - the dev server's dependency pre-bundling (Rolldown, given a plugin of its own here);
+ * - Vite's own pipeline: the project's files on the dev server, everything in a build;
+ * - the dev server's Node side, where the agents' answers load the stories. Node itself would load a package Vite
+ *   leaves external, with the real `react-native` (Flow, native modules), so the packages written for React Native go
+ *   through Vite there too, pre-bundled as in the browser: they mix CommonJS files into ES modules, which only a bundle
+ *   runs on that side.
+ *
+ * A deep import of React Native's own files (`react-native/Libraries/…`) has no web version: it fails with a message
+ * naming the module, instead of a Flow syntax error deep inside React Native.
+ *
+ * @module
+ */
+import { parseAst, transformWithOxc } from "vite";
+import { importedAssets } from "./assetRequires.js";
+import { isForgebookFile } from "./forgebookFiles.js";
+import { isNativeSource, NATIVE_SCRIPT, nativeDefines, nativePackagePattern, serverDefines, WEB_EXTENSIONS, withoutFlow } from "./nativeSources.js";
+/** React Native's own files, imported by path: Metro's internals, which have no web version. */
+const DEEP_NATIVE_IMPORT = /^react-native\/(.+)$/;
+/** A script that may hold JSX besides `.js`: the JSX import source is named in it. */
+const JSX_SCRIPT = /\.[jt]sx(?:\?|$)/;
+/** A pragma that names a file's JSX import source already. */
+const JSX_PRAGMA = /@jsxImportSource\s/;
+/** The scripts a `require` of an asset is looked for in: every kind Vite compiles. */
+const SCRIPT_FILE = /\.(?:[cm]?[jt]sx?)(?:\?|$)/;
+/**
+ * A module's path without its query (`?v=…`, `?import`).
+ *
+ * @param id - the module's id.
+ */
+const withoutQuery = (id) => id.split("?", 1)[0] ?? id;
+/**
+ * The plugin the dependency pre-bundling runs: the dependencies written for React Native compiled as Metro compiles
+ * them, their `.js` files read as JSX once their Flow types are gone, and their `require` of an asset made its
+ * address, as in a build (the pre-bundling would make it a module object, which `Image` cannot draw).
+ *
+ * @param nativePackages - the other packages written for React Native, by name.
+ */
+export const prebundlePlugin = (nativePackages) => ({
+    name: "forgebook:react-native-web-prebundle",
+    transform: {
+        filter: { id: NATIVE_SCRIPT },
+        handler: async (code, id) => {
+            if (!isNativeSource(withoutQuery(id), nativePackages))
+                return null;
+            const plain = await withoutFlow(code);
+            const withAssets = plain.includes("require")
+                ? importedAssets(plain, parseAst(plain, { lang: "jsx" }))
+                : undefined;
+            return { code: withAssets ?? plain, moduleType: "jsx" };
+        }
+    }
+});
+/**
+ * The packages written for React Native that a catalogue names, with its JSX import source's: NativeWind's runtime
+ * imports `react-native` as the other packages do.
+ *
+ * @param options - the adapter's options.
+ */
+const nativePackagesOf = (options) => [
+    ...(options.nativePackages ?? []),
+    ...(options.jsxImportSource === undefined || options.jsxImportSource === "react"
+        ? []
+        : [options.jsxImportSource])
+];
+/**
+ * How JSX is compiled: React's automatic runtime, from the catalogue's import source (NativeWind's) when it names one.
+ *
+ * @param options - the adapter's options.
+ */
+const jsxOptions = (options) => ({
+    runtime: "automatic",
+    ...(options.jsxImportSource === undefined ? {} : { importSource: options.jsxImportSource })
+});
+/**
+ * What the plugin adds to Vite's configuration.
+ *
+ * @param isDevelopment - whether the catalogue runs on the dev server.
+ * @param options - the adapter's options: the other packages written for React Native, the JSX import source.
+ * @param entries - the files the dev server scans for the dependencies to pre-bundle (the story files, as Forgebook's
+ *   plugin names them for the browser), scanned on the Node side too.
+ */
+export const nativeConfig = (isDevelopment, options, entries) => {
+    const nativePackages = nativePackagesOf(options);
+    const define = nativeDefines(isDevelopment);
+    /**
+     * The pre-bundling's options, with the globals it defines.
+     *
+     * @param defines - the globals.
+     */
+    const prebundling = (defines) => ({
+        rolldownOptions: {
+            // Expo's packages are compiled from TypeScript one file at a time, so an import of a type is left as an import
+            // of a module that exports nothing (`expo-modules-core`'s declarations): Metro lets it be `undefined`, as here
+            shimMissingExports: true,
+            resolve: { extensions: [...WEB_EXTENSIONS] },
+            transform: { define: { ...defines }, jsx: jsxOptions(options) },
+            plugins: [prebundlePlugin(nativePackages)]
+        }
+    });
+    return {
+        resolve: {
+            // exactly `react-native`: `react-native-web`, `react-native-svg` and the others keep their own name
+            alias: [{ find: /^react-native$/, replacement: "react-native-web" }],
+            extensions: [...WEB_EXTENSIONS]
+        },
+        define,
+        build: { rolldownOptions: { shimMissingExports: true } },
+        optimizeDeps: { ...prebundling(define), include: ["react-native-web"] },
+        environments: {
+            ssr: {
+                resolve: { noExternal: [nativePackagePattern(nativePackages), "react-native-web"] },
+                // scanned up front as the browser's are, so no answer meets a dependency the bundle lacks and fails while the
+                // bundle is made again
+                optimizeDeps: {
+                    ...prebundling(serverDefines(isDevelopment)),
+                    noDiscovery: false,
+                    include: ["react-native-web"],
+                    ...(entries === undefined ? {} : { entries })
+                }
+            }
+        }
+    };
+};
+/**
+ * The plugins.
+ *
+ * @param options - the packages written for React Native beyond React Native's and Expo's families.
+ * @returns the plugin that sets Vite up and compiles React Native's code, and the one that writes `require` of an
+ * asset as its import (after Vite's own compiling, on plain JavaScript).
+ */
+export const nativePlugins = (options) => {
+    const nativePackages = nativePackagesOf(options);
+    // the project's own files and the packages written for React Native, never Forgebook's own modules
+    const isProjectSource = (id) => {
+        const file = withoutQuery(id);
+        return isNativeSource(file, nativePackages) && !isForgebookFile(file);
+    };
+    const { jsxImportSource } = options;
+    let isDevelopment = true;
+    return [
+        {
+            name: "forgebook:react-native-web",
+            enforce: "pre",
+            config: (config, environment) => {
+                isDevelopment = environment.command === "serve";
+                return nativeConfig(isDevelopment, options, config.optimizeDeps?.entries);
+            },
+            resolveId: {
+                filter: { id: DEEP_NATIVE_IMPORT },
+                handler(source, importer) {
+                    const from = importer === undefined ? "" : ` (imported by ${withoutQuery(importer)})`;
+                    this.error(`${source}${from} is one of React Native's own files, which have no web version: ` +
+                        "only `react-native` itself runs in the browser, as react-native-web");
+                }
+            },
+            // React Native writes JSX in `.js` files, which Vite reads as plain JavaScript: compiled before Vite reads them
+            transform: {
+                filter: { id: NATIVE_SCRIPT },
+                handler: async (code, id) => {
+                    const file = withoutQuery(id);
+                    if (!isProjectSource(file))
+                        return null;
+                    const compiled = await transformWithOxc(await withoutFlow(code), file, {
+                        lang: "jsx",
+                        jsx: { ...jsxOptions(options), development: isDevelopment },
+                        sourcemap: true
+                    });
+                    return { code: compiled.code, map: compiled.map ?? null };
+                }
+            }
+        },
+        {
+            // the JSX import source (NativeWind's) is the project's, not Forgebook's own pages': named in each of its files,
+            // on their first line so the others keep their place
+            name: "forgebook:react-native-web-jsx-source",
+            enforce: "pre",
+            transform: {
+                filter: { id: JSX_SCRIPT },
+                handler: (code, id) => {
+                    // a file run as a program starts with its interpreter's line, before which nothing may go
+                    if (jsxImportSource === undefined || code.startsWith("#!") || JSX_PRAGMA.test(code))
+                        return null;
+                    if (!isProjectSource(id))
+                        return null;
+                    return { code: `/** @jsxImportSource ${jsxImportSource} */ ${code}`, map: null };
+                }
+            }
+        },
+        {
+            name: "forgebook:react-native-web-assets",
+            transform: {
+                filter: { id: SCRIPT_FILE, code: "require" },
+                handler(code, id) {
+                    if (!isProjectSource(id))
+                        return null;
+                    const rewritten = importedAssets(code, this.parse(code));
+                    // the module keeps its lines and columns, so its source map stays as it is
+                    return rewritten === undefined ? null : { code: rewritten, map: null };
+                }
+            }
+        }
+    ];
+};

package/dist/src/vite/nativeSources.d.ts

@@ -0,0 +1,75 @@
+/**
+ * What a React Native project's code needs before the browser can run it: which files are written as React Native
+ * writes them (JSX in `.js`, Flow types), the extensions a web build resolves first, the globals React Native's code
+ * reads. Pure: the plugin (`nativePlugin.ts`) applies it, the tests read it.
+ *
+ * @remarks
+ * Metro, React Native's bundler, compiles every file with Babel, so React Native code and many of its libraries ship
+ * JSX in `.js` files and Flow types: a web bundler reads neither. Those files are compiled here: the project's own
+ * `.js` files, and the packages written for React Native: those of React Native's and Expo's families
+ * (`react-native-*`, `@react-native/*`, `expo-*`, `@expo/*`) and any the catalogue names. Every other package in
+ * `node_modules` is taken as the plain JavaScript its publisher ships, as Vite takes it.
+ *
+ * @module
+ */
+/**
+ * The extensions a module is looked for with, the web's first: `Button.web.tsx` wins over `Button.tsx` and over
+ * `Button.native.tsx`, which is never read, as Metro does for the web platform.
+ */
+export declare const WEB_EXTENSIONS: readonly string[];
+/**
+ * The packages written for React Native, as a pattern that matches their names and the modules inside them
+ * (`@expo/vector-icons/Ionicons`): the families, and the packages the catalogue names.
+ *
+ * @param nativePackages - the other packages written for React Native, by name.
+ */
+export declare const nativePackagePattern: (nativePackages: readonly string[]) => RegExp;
+/** A script React Native writes JSX in: the `.js` and `.mjs` files a web bundler reads as plain JavaScript. */
+export declare const NATIVE_SCRIPT: RegExp;
+/**
+ * The package a file belongs to, from its path: the name after its last `node_modules`, so a package pnpm stores in
+ * `node_modules/.pnpm/…/node_modules/<name>` is named too.
+ *
+ * @param file - the file's path, with `/` separators.
+ * @returns the package's name, or none for a file of the project's own.
+ */
+export declare const packageOf: (file: string) => string | undefined;
+/**
+ * Whether a package is written for React Native: one of React Native's or Expo's families, or one the catalogue names.
+ *
+ * @param name - the package's name.
+ * @param nativePackages - the other packages written for React Native, by name.
+ */
+export declare const isNativePackage: (name: string, nativePackages: readonly string[]) => boolean;
+/**
+ * Whether a file is compiled as React Native's code: one of the project's own (a linked package of a monorepo among
+ * them), or one of a package written for React Native.
+ *
+ * @param file - the file's path, its query left out.
+ * @param nativePackages - the other packages written for React Native, by name.
+ */
+export declare const isNativeSource: (file: string, nativePackages: readonly string[]) => boolean;
+/**
+ * The globals React Native's code reads, as the web build gives them: Metro defines `__DEV__`, Expo's Babel preset
+ * `process.env.EXPO_OS`, and React Native's runtime names the global object `global`.
+ *
+ * @param isDevelopment - whether the catalogue runs in development (the dev server) or is built.
+ * @returns the definitions, each value a JavaScript expression.
+ */
+export declare const nativeDefines: (isDevelopment: boolean) => Readonly<Record<string, string>>;
+/**
+ * The globals React Native's code reads on the dev server's Node side, where the agents' answers load the stories:
+ * the browser's, and the animation frames Node has none of. Reanimated asks for a frame as it loads; without one, the
+ * request throws outside any story and stops the dev server. A frame there is a timer's turn: nothing is drawn.
+ *
+ * @param isDevelopment - whether the catalogue runs in development.
+ */
+export declare const serverDefines: (isDevelopment: boolean) => Readonly<Record<string, string>>;
+/**
+ * A file's code without its Flow types: blanked out in place, so its lines and columns, and the source map of what
+ * compiles it next, stay right. A file without a Flow pragma is returned as it is, and `flow-remove-types` is loaded
+ * the first time a file needs it: most projects never do.
+ *
+ * @param code - the file's code.
+ */
+export declare const withoutFlow: (code: string) => Promise<string>;

package/dist/src/vite/nativeSources.js

@@ -0,0 +1,150 @@
+/**
+ * What a React Native project's code needs before the browser can run it: which files are written as React Native
+ * writes them (JSX in `.js`, Flow types), the extensions a web build resolves first, the globals React Native's code
+ * reads. Pure: the plugin (`nativePlugin.ts`) applies it, the tests read it.
+ *
+ * @remarks
+ * Metro, React Native's bundler, compiles every file with Babel, so React Native code and many of its libraries ship
+ * JSX in `.js` files and Flow types: a web bundler reads neither. Those files are compiled here: the project's own
+ * `.js` files, and the packages written for React Native: those of React Native's and Expo's families
+ * (`react-native-*`, `@react-native/*`, `expo-*`, `@expo/*`) and any the catalogue names. Every other package in
+ * `node_modules` is taken as the plain JavaScript its publisher ships, as Vite takes it.
+ *
+ * @module
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { codeLiteral } from "forgebook/code-literal";
+/**
+ * The extensions a module is looked for with, the web's first: `Button.web.tsx` wins over `Button.tsx` and over
+ * `Button.native.tsx`, which is never read, as Metro does for the web platform.
+ */
+export const WEB_EXTENSIONS = [
+    ".web.tsx",
+    ".web.ts",
+    ".web.jsx",
+    ".web.js",
+    ".web.mjs",
+    ".tsx",
+    ".ts",
+    ".jsx",
+    ".js",
+    ".mjs",
+    ".mts",
+    ".cjs",
+    ".json"
+];
+/**
+ * The packages written for React Native, as a pattern of their names: React Native's family (`react-native-*`,
+ * `@react-native/*`) and Expo's (`expo`, `expo-*`, `@expo/*`). `react-native` itself is not among them, since it is
+ * never loaded (react-native-web stands for it), nor react-native-web, which ships plain JavaScript.
+ */
+const NATIVE_FAMILIES = "(?!react-native-web(?:/|$))(?:react-native-|@react-native/|expo(?:-|/|$)|@expo/)";
+/**
+ * A text matched as it is in a regular expression.
+ *
+ * @param text - the text.
+ */
+const escapedPattern = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+ * The packages written for React Native, as a pattern that matches their names and the modules inside them
+ * (`@expo/vector-icons/Ionicons`): the families, and the packages the catalogue names.
+ *
+ * @param nativePackages - the other packages written for React Native, by name.
+ */
+export const nativePackagePattern = (nativePackages) => {
+    const named = nativePackages.map((name) => `|${escapedPattern(name)}(?:/|$)`).join("");
+    return new RegExp(`^(?:${NATIVE_FAMILIES}${named})`);
+};
+/** A script React Native writes JSX in: the `.js` and `.mjs` files a web bundler reads as plain JavaScript. */
+export const NATIVE_SCRIPT = /\.m?js(?:\?|$)/;
+/** The last `node_modules` of a path, and what follows it: the package's name and the file. */
+const IN_PACKAGE = /\/node_modules\/((?:@[^/]+\/)?[^/]+)\//g;
+/**
+ * The package a file belongs to, from its path: the name after its last `node_modules`, so a package pnpm stores in
+ * `node_modules/.pnpm/…/node_modules/<name>` is named too.
+ *
+ * @param file - the file's path, with `/` separators.
+ * @returns the package's name, or none for a file of the project's own.
+ */
+export const packageOf = (file) => {
+    const matches = [...file.split("\\").join("/").matchAll(IN_PACKAGE)];
+    return matches.at(-1)?.[1];
+};
+/**
+ * Whether a package is written for React Native: one of React Native's or Expo's families, or one the catalogue names.
+ *
+ * @param name - the package's name.
+ * @param nativePackages - the other packages written for React Native, by name.
+ */
+export const isNativePackage = (name, nativePackages) => nativePackagePattern(nativePackages).test(name);
+/**
+ * Whether a file is compiled as React Native's code: one of the project's own (a linked package of a monorepo among
+ * them), or one of a package written for React Native.
+ *
+ * @param file - the file's path, its query left out.
+ * @param nativePackages - the other packages written for React Native, by name.
+ */
+export const isNativeSource = (file, nativePackages) => {
+    const name = packageOf(file);
+    return name === undefined || isNativePackage(name, nativePackages);
+};
+/**
+ * The globals React Native's code reads, as the web build gives them: Metro defines `__DEV__`, Expo's Babel preset
+ * `process.env.EXPO_OS`, and React Native's runtime names the global object `global`.
+ *
+ * @param isDevelopment - whether the catalogue runs in development (the dev server) or is built.
+ * @returns the definitions, each value a JavaScript expression.
+ */
+export const nativeDefines = (isDevelopment) => ({
+    // biome-ignore lint/style/useNamingConvention: the global's name, as React Native's code reads it
+    __DEV__: codeLiteral(isDevelopment),
+    "process.env.EXPO_OS": codeLiteral("web"),
+    global: "globalThis"
+});
+/**
+ * The globals React Native's code reads on the dev server's Node side, where the agents' answers load the stories:
+ * the browser's, and the animation frames Node has none of. Reanimated asks for a frame as it loads; without one, the
+ * request throws outside any story and stops the dev server. A frame there is a timer's turn: nothing is drawn.
+ *
+ * @param isDevelopment - whether the catalogue runs in development.
+ */
+export const serverDefines = (isDevelopment) => ({
+    ...nativeDefines(isDevelopment),
+    requestAnimationFrame: "globalThis.setTimeout",
+    cancelAnimationFrame: "globalThis.clearTimeout"
+});
+/** A pragma that marks a file as Flow's: `@flow`, or `@noflow`, which may still hold types. */
+const FLOW_PRAGMA = /@(?:no)?flow\b/;
+/** The package that strips Flow types: named by a variable, since it ships no types and is checked once loaded. */
+const FLOW_REMOVE_TYPES = "flow-remove-types";
+/**
+ * Whether a loaded module is `flow-remove-types`: its default export is a function.
+ *
+ * @param module - the module, as `import()` gave it.
+ */
+const isFlowRemoveTypes = (module) => typeof module === "object" &&
+    module !== null &&
+    "default" in module &&
+    typeof module.default === "function";
+/**
+ * A file's code without its Flow types: blanked out in place, so its lines and columns, and the source map of what
+ * compiles it next, stay right. A file without a Flow pragma is returned as it is, and `flow-remove-types` is loaded
+ * the first time a file needs it: most projects never do.
+ *
+ * @param code - the file's code.
+ */
+export const withoutFlow = async (code) => {
+    if (!FLOW_PRAGMA.test(code))
+        return code;
+    const loaded = await import(__rewriteRelativeImportExtension(FLOW_REMOVE_TYPES));
+    if (!isFlowRemoveTypes(loaded))
+        throw new Error(`${FLOW_REMOVE_TYPES} has no default export to strip Flow types with`);
+    return loaded.default(code).toString();
+};

package/dist/src/vite/projectPostcss.d.ts

@@ -0,0 +1,19 @@
+import type { Plugin } from "vite";
+/** A folder a style sheet's result depends on (Tailwind's content), with the files in it that count. */
+type DirDependency = {
+    /** The folder, absolute. */
+    readonly dir: string;
+};
+/**
+ * The folders a PostCSS result depends on, from its messages.
+ *
+ * @param messages - the result's messages.
+ * @returns each folder, and each file, a result names.
+ */
+export declare const dependenciesOf: (messages: readonly unknown[]) => {
+    readonly dirs: DirDependency[];
+    readonly files: string[];
+};
+/** The plugin. */
+export declare const projectPostcss: () => Plugin;
+export {};