@quilted/rollup 0.1.18 → 0.2.0

package/build/esm/features/env.mjs

@@ -6,9 +6,9 @@ import { smartReplace } from '../shared/rollup.mjs';
 import { createMagicModulePlugin } from '../shared/magic-module.mjs';
 
 const EMPTY_PROCESS_ENV_OBJECT = {
-  'globalThis.process.env.': `({}).`,
-  'global.process.env.': `({}).`,
-  'process.env.': `({}).`
+  "globalThis.process.env.": `({}).`,
+  "global.process.env.": `({}).`,
+  "process.env.": `({}).`
 };
 function replaceProcessEnv({
   mode,
@@ -16,37 +16,37 @@ function replaceProcessEnv({
 }) {
   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)
+    "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
   });
 }
+function resolveEnvOption(option) {
+  return typeof option === "string" ? { mode: option } : option ?? {};
+}
 function magicModuleEnv({
   mode,
-  dotenv = {
-    roots: ['.', 'configuration']
-  },
+  dotenv = { roots: [".", "configuration"] },
   inline = [],
-  runtime = '{}'
+  runtime = "{}"
 } = {}) {
   return createMagicModulePlugin({
-    name: '@quilted/magic-module/env',
+    name: "@quilted/magic-module/env",
     module: MAGIC_MODULE_ENV,
     async source() {
       const inlineEnv = {};
       if (mode) {
         inlineEnv.MODE = mode;
       }
-      const loadedEnv = await loadEnv.call(this, {
-        mode,
-        dotenv
-      });
+      const loadedEnv = await loadEnv.call(this, { mode, dotenv });
       for (const inlineVariable of inline.sort()) {
-        if (inlineVariable in inlineEnv) continue;
+        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;
+        if (value == null)
+          continue;
+        inlineEnv[inlineVariable] = typeof value === "string" && value[0] === '"' && value[value.length - 1] === '"' ? JSON.parse(value) : value;
       }
       return multiline`
         const runtime = (${runtime});
@@ -66,47 +66,50 @@ function magicModuleEnv({
     }
   });
 }
-
-// Inspired by https://github.com/vitejs/vite/blob/e0a4d810598d1834933ed437ac5a2168cbbbf2f8/packages/vite/source/node/config.ts#L1050-L1113
 async function loadEnv({
   mode,
   dotenv
 }) {
-  const env = {
-    ...process.env
-  };
+  const env = { ...process.env };
   if (dotenv !== false) {
-    const {
-      parse
-    } = await import('dotenv');
+    const { parse } = await import('dotenv');
     let files = dotenv.files;
     if (files == null) {
       const testFiles = [
-      // default file
-      `.env`,
-      // local file
-      `.env.local`];
+        // default file
+        `.env`,
+        // local file
+        `.env.local`
+      ];
       if (mode) {
         testFiles.push(
-        // mode file
-        `.env.${mode}`,
-        // mode local file
-        `.env.${mode}.local`);
+          // mode file
+          `.env.${mode}`,
+          // mode local file
+          `.env.${mode}.local`
+        );
       }
-      files = testFiles.flatMap(file => (dotenv.roots ?? ['.', 'configuration']).map(root => path.resolve(root, file)));
+      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'));
-      }
-    }));
+    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;
+      if (envFileResult == null)
+        continue;
       Object.assign(env, envFileResult);
     }
   }
   return env;
 }
 
-export { magicModuleEnv, replaceProcessEnv };
+export { magicModuleEnv, replaceProcessEnv, resolveEnvOption };

package/build/esm/features/esnext.mjs

@@ -0,0 +1,57 @@
+import { createRequire } from 'node:module';
+import babel from '@rollup/plugin-babel';
+import esbuild from 'rollup-plugin-esbuild';
+
+const require = createRequire(import.meta.url);
+function esnext({
+  mode,
+  targets,
+  babel: useBabel = true
+}) {
+  if (!useBabel) {
+    return esbuild({
+      // Support very modern features
+      include: /\.esnext$/,
+      target: "es2022",
+      loaders: {
+        ".esnext": "js"
+      }
+    });
+  }
+  let babelOptions = {
+    envName: mode,
+    configFile: false,
+    babelrc: false,
+    presets: [
+      [
+        require.resolve("@babel/preset-env"),
+        {
+          useBuiltIns: false,
+          bugfixes: true,
+          shippedProposals: true
+          // I thought I wanted this, but it seems to break the `targets` option
+          // passed as a root argument.
+          // ignoreBrowserslistConfig: targets != null,
+        }
+      ]
+    ],
+    plugins: [
+      [
+        require.resolve("@babel/plugin-proposal-decorators"),
+        { version: "2023-01" }
+      ]
+    ],
+    include: /\.esnext$/,
+    extensions: [".esnext"],
+    babelHelpers: "bundled",
+    skipPreflightCheck: true,
+    // Babel doesn’t like this option being set to `undefined`.
+    ...targets ? { targets } : {}
+  };
+  if (typeof useBabel === "object") {
+    babelOptions = useBabel.options?.(babelOptions) ?? babelOptions;
+  }
+  return babel(babelOptions);
+}
+
+export { esnext };

package/build/esm/features/graphql/transform.mjs

@@ -2,13 +2,11 @@ import { createHash } from 'node:crypto';
 import { print, parse } from 'graphql';
 
 const IMPORT_REGEX = /^#import\s+['"]([^'"]*)['"];?[\s\n]*/gm;
-const DEFAULT_NAME = 'Operation';
-function cleanGraphQLDocument(document, {
-  removeUnused = true
-} = {}) {
+const DEFAULT_NAME = "Operation";
+function cleanGraphQLDocument(document, { removeUnused = true } = {}) {
   if (removeUnused) {
     removeUnusedDefinitions(document, {
-      exclude: removeUnused === true ? new Set() : removeUnused.exclude
+      exclude: removeUnused === true ? /* @__PURE__ */ new Set() : removeUnused.exclude
     });
   }
   for (const definition of document.definitions) {
@@ -19,18 +17,14 @@ function cleanGraphQLDocument(document, {
   for (const definition of normalizedDocument.definitions) {
     stripLoc(definition);
   }
-
-  // This ID is a hash of the full file contents that are part of the document,
-  // including other documents that are injected in, but excluding any unused
-  // fragments. This is useful for things like persisted queries.
-  const id = createHash('sha256').update(normalizedSource).digest('hex');
-  Reflect.defineProperty(normalizedDocument, 'id', {
+  const id = createHash("sha256").update(normalizedSource).digest("hex");
+  Reflect.defineProperty(normalizedDocument, "id", {
     value: id,
     enumerable: true,
     writable: false,
     configurable: false
   });
-  Reflect.defineProperty(normalizedDocument, 'loc', {
+  Reflect.defineProperty(normalizedDocument, "loc", {
     value: stripDocumentLoc(normalizedDocument.loc),
     enumerable: true,
     writable: false,
@@ -39,18 +33,15 @@ function cleanGraphQLDocument(document, {
   return normalizedDocument;
 }
 function extractGraphQLImports(rawSource) {
-  const imports = new Set();
+  const imports = /* @__PURE__ */ new Set();
   const source = rawSource.replace(IMPORT_REGEX, (_, imported) => {
     imports.add(imported);
-    return '';
+    return "";
   });
-  return {
-    imports: [...imports],
-    source
-  };
+  return { imports: [...imports], source };
 }
 function toGraphQLOperation(documentOrSource) {
-  const document = typeof documentOrSource === 'string' ? cleanGraphQLDocument(parse(documentOrSource)) : documentOrSource;
+  const document = typeof documentOrSource === "string" ? cleanGraphQLDocument(parse(documentOrSource)) : documentOrSource;
   return {
     id: document.id,
     name: operationNameForDocument(document),
@@ -58,14 +49,14 @@ function toGraphQLOperation(documentOrSource) {
   };
 }
 function operationNameForDocument(document) {
-  return document.definitions.find(definition => definition.kind === 'OperationDefinition')?.name?.value;
+  return document.definitions.find(
+    (definition) => definition.kind === "OperationDefinition"
+  )?.name?.value;
 }
-function removeUnusedDefinitions(document, {
-  exclude
-}) {
-  const usedDefinitions = new Set();
+function removeUnusedDefinitions(document, { exclude }) {
+  const usedDefinitions = /* @__PURE__ */ new Set();
   const dependencies = definitionDependencies(document.definitions);
-  const markAsUsed = definition => {
+  const markAsUsed = (definition) => {
     if (usedDefinitions.has(definition)) {
       return;
     }
@@ -75,7 +66,7 @@ function removeUnusedDefinitions(document, {
     }
   };
   for (const definition of document.definitions) {
-    if (definition.kind === 'FragmentDefinition') {
+    if (definition.kind === "FragmentDefinition") {
       if (exclude.has(definition.name.value)) {
         markAsUsed(definition);
       }
@@ -86,29 +77,44 @@ function removeUnusedDefinitions(document, {
   document.definitions = [...usedDefinitions];
 }
 function definitionDependencies(definitions) {
-  const executableDefinitions = definitions.filter(definition => definition.kind === 'OperationDefinition' || definition.kind === 'FragmentDefinition');
-  const definitionsByName = new Map(executableDefinitions.map(definition => [definition.name ? definition.name.value : DEFAULT_NAME, definition]));
-  return new Map(executableDefinitions.map(executableNode => [executableNode, [...collectUsedFragmentSpreads(executableNode, new Set())].map(usedFragment => {
-    const definition = definitionsByName.get(usedFragment);
-    if (definition == null) {
-      throw new Error(`You attempted to use the fragment '${usedFragment}' (in '${executableNode.name ? executableNode.name.value : DEFAULT_NAME}'), but it does not exist. Maybe you forgot to import it from another document?`);
-    }
-    return definition;
-  })]));
+  const executableDefinitions = definitions.filter(
+    (definition) => definition.kind === "OperationDefinition" || definition.kind === "FragmentDefinition"
+  );
+  const definitionsByName = new Map(
+    executableDefinitions.map((definition) => [
+      definition.name ? definition.name.value : DEFAULT_NAME,
+      definition
+    ])
+  );
+  return new Map(
+    executableDefinitions.map(
+      (executableNode) => [
+        executableNode,
+        [...collectUsedFragmentSpreads(executableNode, /* @__PURE__ */ new Set())].map(
+          (usedFragment) => {
+            const definition = definitionsByName.get(usedFragment);
+            if (definition == null) {
+              throw new Error(
+                `You attempted to use the fragment '${usedFragment}' (in '${executableNode.name ? executableNode.name.value : DEFAULT_NAME}'), but it does not exist. Maybe you forgot to import it from another document?`
+              );
+            }
+            return definition;
+          }
+        )
+      ]
+    )
+  );
 }
 const TYPENAME_FIELD = {
-  kind: 'Field',
+  kind: "Field",
   alias: null,
-  name: {
-    kind: 'Name',
-    value: '__typename'
-  }
+  name: { kind: "Name", value: "__typename" }
 };
 function addTypename(definition) {
-  for (const {
-    selections
-  } of selectionSetsForDefinition(definition)) {
-    const hasTypename = selections.some(selection => selection.kind === 'Field' && selection.name.value === '__typename');
+  for (const { selections } of selectionSetsForDefinition(definition)) {
+    const hasTypename = selections.some(
+      (selection) => selection.kind === "Field" && selection.name.value === "__typename"
+    );
     if (!hasTypename) {
       selections.push(TYPENAME_FIELD);
     }
@@ -116,27 +122,27 @@ function addTypename(definition) {
 }
 function collectUsedFragmentSpreads(definition, usedSpreads) {
   for (const selection of selectionsForDefinition(definition)) {
-    if (selection.kind === 'FragmentSpread') {
+    if (selection.kind === "FragmentSpread") {
       usedSpreads.add(selection.name.value);
     }
   }
   return usedSpreads;
 }
 function selectionsForDefinition(definition) {
-  if (!('selectionSet' in definition) || definition.selectionSet == null) {
+  if (!("selectionSet" in definition) || definition.selectionSet == null) {
     return [][Symbol.iterator]();
   }
   return selectionsForSelectionSet(definition.selectionSet);
 }
 function* selectionSetsForDefinition(definition) {
-  if (!('selectionSet' in definition) || definition.selectionSet == null) {
+  if (!("selectionSet" in definition) || definition.selectionSet == null) {
     return [][Symbol.iterator]();
   }
-  if (definition.kind !== 'OperationDefinition') {
+  if (definition.kind !== "OperationDefinition") {
     yield definition.selectionSet;
   }
   for (const nestedSelection of selectionsForDefinition(definition)) {
-    if ('selectionSet' in nestedSelection && nestedSelection.selectionSet != null) {
+    if ("selectionSet" in nestedSelection && nestedSelection.selectionSet != null) {
       yield nestedSelection.selectionSet;
     }
   }
@@ -146,15 +152,13 @@ function* selectionsForSelectionSet({
 }) {
   for (const selection of selections) {
     yield selection;
-    if ('selectionSet' in selection && selection.selectionSet != null) {
+    if ("selectionSet" in selection && selection.selectionSet != null) {
       yield* selectionsForSelectionSet(selection.selectionSet);
     }
   }
 }
 function stripDocumentLoc(loc) {
-  const normalizedLoc = {
-    ...loc
-  };
+  const normalizedLoc = { ...loc };
   delete normalizedLoc.endToken;
   delete normalizedLoc.startToken;
   return normalizedLoc;
@@ -162,11 +166,11 @@ function stripDocumentLoc(loc) {
 function stripLoc(value) {
   if (Array.isArray(value)) {
     value.forEach(stripLoc);
-  } else if (typeof value === 'object') {
+  } else if (typeof value === "object") {
     if (value == null) {
       return;
     }
-    if ('loc' in value) {
+    if ("loc" in value) {
       delete value.loc;
     }
     for (const key of Object.keys(value)) {
@@ -175,7 +179,7 @@ function stripLoc(value) {
   }
 }
 function minifyGraphQLSource(source) {
-  return source.replace(/#.*/g, '').replace(/\\n/g, ' ').replace(/\s\s+/g, ' ').replace(/\s*({|}|\(|\)|\.|:|,)\s*/g, '$1');
+  return source.replace(/#.*/g, "").replace(/\\n/g, " ").replace(/\s\s+/g, " ").replace(/\s*({|}|\(|\)|\.|:|,)\s*/g, "$1");
 }
 
 export { cleanGraphQLDocument, extractGraphQLImports, minifyGraphQLSource, toGraphQLOperation };

package/build/esm/features/graphql.mjs

@@ -3,79 +3,97 @@ import { mkdir, writeFile, readFile } from 'node:fs/promises';
 import { parse } from 'graphql';
 import { toGraphQLOperation, cleanGraphQLDocument, extractGraphQLImports } from './graphql/transform.mjs';
 
-function graphql({
-  manifest
-} = {}) {
+function graphql({ manifest } = {}) {
   const shouldWriteManifest = Boolean(manifest);
-  const manifestPath = typeof manifest === 'string' ? manifest : `manifests/graphql.json`;
+  const manifestPath = typeof manifest === "string" ? manifest : `manifests/graphql.json`;
   return {
-    name: '@quilted/graphql',
+    name: "@quilted/graphql",
     async transform(code, id) {
-      if (!id.endsWith('.graphql') && !id.endsWith('.gql')) return null;
-      const topLevelDefinitions = new Set();
-      const loadedDocument = await loadDocument(code, id, this, (document, level) => {
-        if (level !== 0) return;
-        for (const definition of document.definitions) {
-          if ('name' in definition && definition.name != null) {
-            topLevelDefinitions.add(definition.name.value);
+      if (!id.endsWith(".graphql") && !id.endsWith(".gql"))
+        return null;
+      const topLevelDefinitions = /* @__PURE__ */ new Set();
+      const loadedDocument = await loadDocument(
+        code,
+        id,
+        this,
+        (document2, level) => {
+          if (level !== 0)
+            return;
+          for (const definition of document2.definitions) {
+            if ("name" in definition && definition.name != null) {
+              topLevelDefinitions.add(definition.name.value);
+            }
           }
         }
-      });
-      const document = toGraphQLOperation(cleanGraphQLDocument(loadedDocument, {
-        removeUnused: {
-          exclude: topLevelDefinitions
-        }
-      }));
+      );
+      const document = toGraphQLOperation(
+        cleanGraphQLDocument(loadedDocument, {
+          removeUnused: { exclude: topLevelDefinitions }
+        })
+      );
       return {
-        code: `export default JSON.parse(${JSON.stringify(JSON.stringify(document))})`,
+        code: `export default JSON.parse(${JSON.stringify(
+          JSON.stringify(document)
+        )})`,
         meta: shouldWriteManifest ? {
-          quilt: {
-            graphql: document
-          }
-        } : undefined
+          quilt: { graphql: document }
+        } : void 0
       };
     },
     async generateBundle() {
-      if (!shouldWriteManifest) return;
+      if (!shouldWriteManifest)
+        return;
       const operations = {};
       for (const moduleId of this.getModuleIds()) {
         const operation = this.getModuleInfo(moduleId)?.meta?.quilt?.graphql;
-        if (operation != null && typeof operation.id === 'string' && typeof operation.source === 'string') {
+        if (operation != null && typeof operation.id === "string" && typeof operation.source === "string") {
           operations[operation.id] = operation.source;
         }
       }
-      await mkdir(dirname(manifestPath), {
-        recursive: true
-      });
+      if (Object.keys(operations).length === 0)
+        return;
+      await mkdir(dirname(manifestPath), { recursive: true });
       await writeFile(manifestPath, JSON.stringify(operations, null, 2));
     }
   };
 }
-async function loadDocument(code, file, plugin, add, level = 0, seen = new Set()) {
-  const {
-    imports,
-    source
-  } = extractGraphQLImports(code);
+async function loadDocument(code, file, plugin, add, level = 0, seen = /* @__PURE__ */ new Set()) {
+  const { imports, source } = extractGraphQLImports(code);
   const document = parse(source);
   add?.(document, level);
   if (imports.length === 0) {
     return document;
   }
-  const resolvedImports = await Promise.all(imports.map(async imported => {
-    if (seen.has(imported)) return;
-    seen.add(imported);
-    const resolvedId = await plugin.resolve(imported, file);
-    if (resolvedId == null) {
-      throw new Error(`Could not find ${JSON.stringify(imported)} from ${JSON.stringify(file)}`);
-    }
-    plugin.addWatchFile(resolvedId.id);
-    const contents = await readFile(resolvedId.id, {
-      encoding: 'utf8'
-    });
-    return loadDocument(contents, resolvedId.id, plugin, add, level + 1, seen);
-  }));
+  const resolvedImports = await Promise.all(
+    imports.map(async (imported) => {
+      if (seen.has(imported))
+        return;
+      seen.add(imported);
+      const resolvedId = await plugin.resolve(imported, file);
+      if (resolvedId == null) {
+        throw new Error(
+          `Could not find ${JSON.stringify(imported)} from ${JSON.stringify(
+            file
+          )}`
+        );
+      }
+      plugin.addWatchFile(resolvedId.id);
+      const contents = await readFile(resolvedId.id, {
+        encoding: "utf8"
+      });
+      return loadDocument(
+        contents,
+        resolvedId.id,
+        plugin,
+        add,
+        level + 1,
+        seen
+      );
+    })
+  );
   for (const importedDocument of resolvedImports) {
-    if (importedDocument == null) continue;
+    if (importedDocument == null)
+      continue;
     document.definitions.push(...importedDocument.definitions);
   }
   return document;

package/build/esm/features/request-router.mjs

@@ -7,17 +7,19 @@ function magicModuleRequestRouterEntry({
   port
 } = {}) {
   return createMagicModulePlugin({
-    name: '@quilted/request-router',
+    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 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'};
+        const port = ${port ?? "Number.parseInt(process.env.PORT, 10)"};
+        const host = ${host ? JSON.stringify(host) : "process.env.HOST"};
       
         createHttpServer(requestRouter).listen(port, host);
       `;