@quilted/rollup 0.0.0-preview-20231014022518

package/source/env.ts

@@ -0,0 +1,176 @@
+import * as path from 'path';
+import * as fs from 'fs';
+
+import type {PluginContext} from 'rollup';
+
+import {MAGIC_MODULE_ENV} from './constants.ts';
+import {multiline} from './shared/strings.ts';
+import {smartReplace} from './shared/rollup.ts';
+import {createMagicModulePlugin} from './shared/magic-module.ts';
+
+const EMPTY_PROCESS_ENV_OBJECT = {
+  'globalThis.process.env.': `({}).`,
+  'global.process.env.': `({}).`,
+  'process.env.': `({}).`,
+};
+
+export function replaceProcessEnv({
+  mode,
+  preserve = true,
+}: {
+  mode: string;
+  preserve?: boolean;
+}) {
+  return smartReplace({
+    // @see https://github.com/vitejs/vite/blob/2b1ffe86328f9d06ef9528ee117b61889893ddcc/packages/vite/src/node/plugins/define.ts#L112
+    'globalThis.process.env.NODE_ENV': JSON.stringify(mode),
+    'global.process.env.NODE_ENV': JSON.stringify(mode),
+    'process.env.NODE_ENV': JSON.stringify(mode),
+    ...(preserve ? {} : EMPTY_PROCESS_ENV_OBJECT),
+  });
+}
+
+export interface MagicModuleEnvOptions {
+  /**
+   * The runtime mode for your target environment.
+   */
+  mode?: 'production' | 'development';
+
+  /**
+   * Environment variables from the build environment to inline into the magic
+   * module. Be careful when using this option! Inlining environment variables
+   * into your application always comes with the risk of exposing sensitive information
+   * to your users. Only use this option for environment variables that are safe
+   * for a human to see if they open their browser developer tools.
+   */
+  inline?: string[];
+
+  /**
+   * A string that will be inlined directly as code to reference a runtime variable
+   * that contains environment variables.
+   */
+  runtime?: string;
+
+  /**
+   * Whether to load environment variables from a `.env` file. The option can
+   * be one of the following types:
+   *
+   * - `false`, which disables loading environment variables from a `.env` file.
+   * - An object containing a `roots` field, specifying the directories to search
+   * for `.env` files in.
+   * - An object containing a `files` field, specifying the directories to search
+   * for `.env` files in.
+   *
+   * @default {roots: ['.', 'configuration']}
+   */
+  dotenv?:
+    | false
+    | {roots?: string[]; files?: never}
+    | {roots?: never; files?: string[]};
+}
+
+export function magicModuleEnv({
+  mode,
+  dotenv = {roots: ['.', 'configuration']},
+  inline = [],
+  runtime = '{}',
+}: MagicModuleEnvOptions = {}) {
+  return createMagicModulePlugin({
+    name: '@quilted/magic-module/env',
+    module: MAGIC_MODULE_ENV,
+    async source() {
+      const inlineEnv: Record<string, string> = {};
+
+      if (mode) {
+        inlineEnv.MODE = mode;
+      }
+
+      const loadedEnv = await loadEnv.call(this, {mode, dotenv});
+
+      for (const inlineVariable of inline.sort()) {
+        if (inlineVariable in inlineEnv) continue;
+        const value = process.env[inlineVariable] ?? loadedEnv[inlineVariable];
+        if (value == null) continue;
+        inlineEnv[inlineVariable] =
+          typeof value === 'string' &&
+          value[0] === '"' &&
+          value[value.length - 1] === '"'
+            ? JSON.parse(value)
+            : value;
+      }
+
+      return multiline`
+        const runtime = (${runtime});
+        const inline = JSON.parse(${JSON.stringify(JSON.stringify(inlineEnv))});
+
+        const Env = new Proxy(
+          {},
+          {
+            get(_, property) {
+              return runtime[property] ?? inline[property];
+            },
+          },
+        );
+
+        export default Env;
+      `;
+    },
+  });
+}
+
+// Inspired by https://github.com/vitejs/vite/blob/e0a4d810598d1834933ed437ac5a2168cbbbf2f8/packages/vite/source/node/config.ts#L1050-L1113
+async function loadEnv(
+  this: PluginContext,
+  {
+    mode,
+    dotenv,
+  }: {mode?: string} & Required<Pick<MagicModuleEnvOptions, 'dotenv'>>,
+): Promise<Record<string, string | undefined>> {
+  const env: Record<string, string | undefined> = {...process.env};
+
+  if (dotenv !== false) {
+    const {parse} = await import('dotenv');
+
+    let files = dotenv.files;
+
+    if (files == null) {
+      const testFiles = [
+        // default file
+        `.env`,
+        // local file
+        `.env.local`,
+      ];
+
+      if (mode) {
+        testFiles.push(
+          // mode file
+          `.env.${mode}`,
+          // mode local file
+          `.env.${mode}.local`,
+        );
+      }
+
+      files = testFiles.flatMap((file) =>
+        (dotenv.roots ?? ['.', 'configuration']).map((root) =>
+          path.resolve(root, file),
+        ),
+      );
+    }
+
+    const envFileResults = await Promise.all(
+      files.map(async (file) => {
+        if (fs.existsSync(file)) {
+          this.addWatchFile(file);
+          return parse(await fs.promises.readFile(file, 'utf-8'));
+        }
+      }),
+    );
+
+    for (const envFileResult of envFileResults) {
+      if (envFileResult == null) continue;
+      Object.assign(env, envFileResult);
+    }
+  }
+
+  return env;
+}

package/source/index.ts

@@ -0,0 +1,13 @@
+export {magicModuleEnv, type MagicModuleEnvOptions} from './env.ts';
+export {
+  quiltApp,
+  quiltAppBrowser,
+  quiltAppServer,
+  magicModuleAppComponent,
+  magicModuleAppBrowserEntry,
+  magicModuleAppRequestRouter,
+  type AppOptions,
+  type AppBrowserOptions,
+  type AppServerOptions,
+} from './app.ts';
+export {magicModuleRequestRouterEntry} from './request-router.ts';

package/source/request-router.ts

@@ -0,0 +1,34 @@
+import {MAGIC_MODULE_ENTRY, MAGIC_MODULE_REQUEST_ROUTER} from './constants.ts';
+
+import {createMagicModulePlugin} from './shared/magic-module.ts';
+import {multiline} from './shared/strings.ts';
+
+export function magicModuleRequestRouterEntry({
+  host,
+  port,
+}: {
+  host?: string;
+  port?: number;
+} = {}) {
+  return createMagicModulePlugin({
+    name: '@quilted/request-router',
+    sideEffects: true,
+    module: MAGIC_MODULE_ENTRY,
+    async source() {
+      const initialContent = multiline`
+        import requestRouter from ${JSON.stringify(
+          MAGIC_MODULE_REQUEST_ROUTER,
+        )};
+
+        import {createHttpServer} from '@quilted/quilt/request-router/node';
+
+        const port = ${port ?? 'Number.parseInt(process.env.PORT, 10)'};
+        const host = ${host ? JSON.stringify(host) : 'process.env.HOST'};
+      
+        createHttpServer(requestRouter).listen(port, host);
+      `;
+
+      return initialContent;
+    },
+  });
+}

package/source/shared/magic-module.ts

@@ -0,0 +1,42 @@
+import type {Plugin, PluginContext} from 'rollup';
+
+const VIRTUAL_MODULE_PREFIX = '\0';
+const VIRTUAL_MODULE_POSTFIX = '/module.js';
+
+export function createMagicModulePlugin({
+  name,
+  module,
+  alias = `${VIRTUAL_MODULE_PREFIX}${module}${VIRTUAL_MODULE_POSTFIX}`,
+  source: getSource,
+  sideEffects = false,
+}: {
+  readonly name: string;
+  readonly alias?: string;
+  readonly module: string;
+  readonly sideEffects?: boolean;
+  source?(this: PluginContext): string | Promise<string>;
+}) {
+  return {
+    name,
+    resolveId(id) {
+      if (id !== module) return null;
+
+      return {
+        id: alias,
+        moduleSideEffects: sideEffects ? 'no-treeshake' : undefined,
+      };
+    },
+    load: getSource
+      ? async function load(source) {
+          if (source !== alias) return null;
+
+          const code = await getSource.call(this);
+
+          return {
+            code,
+            moduleSideEffects: sideEffects ? 'no-treeshake' : undefined,
+          };
+        }
+      : undefined,
+  } satisfies Plugin;
+}

package/source/shared/rollup.ts

@@ -0,0 +1,38 @@
+import type {InputOptions} from 'rollup';
+import replace, {type RollupReplaceOptions} from '@rollup/plugin-replace';
+
+export function smartReplace(
+  values: NonNullable<RollupReplaceOptions['values']>,
+  options?: Omit<RollupReplaceOptions, 'values'>,
+) {
+  return replace({
+    // @see https://github.com/vitejs/vite/blob/2b1ffe86328f9d06ef9528ee117b61889893ddcc/packages/vite/src/node/plugins/define.ts#L108-L119
+    delimiters: [
+      '(?<![\\p{L}\\p{N}_$]|(?<!\\.\\.)\\.)(',
+      ')(?:(?<=\\.)|(?![\\p{L}\\p{N}_$]|\\s*?=[^=]))',
+    ],
+    preventAssignment: true,
+    ...options,
+    values,
+  });
+}
+
+export function addRollupOnWarn(
+  options: InputOptions,
+  warn: NonNullable<InputOptions['onwarn']>,
+): InputOptions {
+  const {onwarn: originalOnWarn} = options;
+
+  return {
+    ...options,
+    onwarn(warning, defaultWarn) {
+      warn(warning, (warning) => {
+        if (originalOnWarn && typeof warning === 'object') {
+          originalOnWarn(warning, defaultWarn);
+        } else {
+          defaultWarn(warning);
+        }
+      });
+    },
+  };
+}

package/source/shared/strings.ts

@@ -0,0 +1,17 @@
+export function multiline(strings: TemplateStringsArray, ...values: any[]) {
+  let result = strings.reduce(
+    (combined, string, index) => `${combined}${string}${values[index] ?? ''}`,
+    '',
+  );
+
+  // Inspired by https://github.com/zspecza/common-tags/blob/master/src/stripIndentTransformer/stripIndentTransformer.js#L8
+  const match = result.match(/^[^\S\n]*(?=\S)/gm);
+  const indent = match && Math.min(...match.map((indent) => indent.length));
+
+  if (indent) {
+    const regexp = new RegExp(`^.{${indent}}`, 'gm');
+    result = result.replace(regexp, '');
+  }
+
+  return result.trim();
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "@quilted/typescript/project.json",
+  "compilerOptions": {
+    "rootDir": "source",
+    "outDir": "build/typescript"
+  },
+  "include": ["source"],
+  "exclude": ["quilt.project.ts", "**/*.test.ts", "**/*.test.tsx"],
+  "references": []
+}