@quilted/rollup 0.1.19 → 0.2.1

package/build/esnext/features/env.esnext

@@ -1,112 +0,0 @@
-import * as path from 'node:path';
-import * as fs from 'node:fs';
-import { MAGIC_MODULE_ENV } from '../constants.esnext';
-import { multiline } from '../shared/strings.esnext';
-import { smartReplace } from '../shared/rollup.esnext';
-import { createMagicModulePlugin } from '../shared/magic-module.esnext';
-
-const EMPTY_PROCESS_ENV_OBJECT = {
-  'globalThis.process.env.': `({}).`,
-  'global.process.env.': `({}).`,
-  'process.env.': `({}).`
-};
-function replaceProcessEnv({
-  mode,
-  preserve = true
-}) {
-  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)
-  });
-}
-function magicModuleEnv({
-  mode,
-  dotenv = {
-    roots: ['.', 'configuration']
-  },
-  inline = [],
-  runtime = '{}'
-} = {}) {
-  return createMagicModulePlugin({
-    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
-      });
-      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({
-  mode,
-  dotenv
-}) {
-  const env = {
-    ...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;
-}
-
-export { magicModuleEnv, replaceProcessEnv };

package/build/esnext/features/graphql/transform.esnext

@@ -1,181 +0,0 @@
-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
-} = {}) {
-  if (removeUnused) {
-    removeUnusedDefinitions(document, {
-      exclude: removeUnused === true ? new Set() : removeUnused.exclude
-    });
-  }
-  for (const definition of document.definitions) {
-    addTypename(definition);
-  }
-  const normalizedSource = minifyGraphQLSource(print(document));
-  const normalizedDocument = parse(normalizedSource);
-  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', {
-    value: id,
-    enumerable: true,
-    writable: false,
-    configurable: false
-  });
-  Reflect.defineProperty(normalizedDocument, 'loc', {
-    value: stripDocumentLoc(normalizedDocument.loc),
-    enumerable: true,
-    writable: false,
-    configurable: false
-  });
-  return normalizedDocument;
-}
-function extractGraphQLImports(rawSource) {
-  const imports = new Set();
-  const source = rawSource.replace(IMPORT_REGEX, (_, imported) => {
-    imports.add(imported);
-    return '';
-  });
-  return {
-    imports: [...imports],
-    source
-  };
-}
-function toGraphQLOperation(documentOrSource) {
-  const document = typeof documentOrSource === 'string' ? cleanGraphQLDocument(parse(documentOrSource)) : documentOrSource;
-  return {
-    id: document.id,
-    name: operationNameForDocument(document),
-    source: document.loc.source.body
-  };
-}
-function operationNameForDocument(document) {
-  return document.definitions.find(definition => definition.kind === 'OperationDefinition')?.name?.value;
-}
-function removeUnusedDefinitions(document, {
-  exclude
-}) {
-  const usedDefinitions = new Set();
-  const dependencies = definitionDependencies(document.definitions);
-  const markAsUsed = definition => {
-    if (usedDefinitions.has(definition)) {
-      return;
-    }
-    usedDefinitions.add(definition);
-    for (const dependency of dependencies.get(definition) || []) {
-      markAsUsed(dependency);
-    }
-  };
-  for (const definition of document.definitions) {
-    if (definition.kind === 'FragmentDefinition') {
-      if (exclude.has(definition.name.value)) {
-        markAsUsed(definition);
-      }
-    } else {
-      markAsUsed(definition);
-    }
-  }
-  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 TYPENAME_FIELD = {
-  kind: 'Field',
-  alias: null,
-  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');
-    if (!hasTypename) {
-      selections.push(TYPENAME_FIELD);
-    }
-  }
-}
-function collectUsedFragmentSpreads(definition, usedSpreads) {
-  for (const selection of selectionsForDefinition(definition)) {
-    if (selection.kind === 'FragmentSpread') {
-      usedSpreads.add(selection.name.value);
-    }
-  }
-  return usedSpreads;
-}
-function selectionsForDefinition(definition) {
-  if (!('selectionSet' in definition) || definition.selectionSet == null) {
-    return [][Symbol.iterator]();
-  }
-  return selectionsForSelectionSet(definition.selectionSet);
-}
-function* selectionSetsForDefinition(definition) {
-  if (!('selectionSet' in definition) || definition.selectionSet == null) {
-    return [][Symbol.iterator]();
-  }
-  if (definition.kind !== 'OperationDefinition') {
-    yield definition.selectionSet;
-  }
-  for (const nestedSelection of selectionsForDefinition(definition)) {
-    if ('selectionSet' in nestedSelection && nestedSelection.selectionSet != null) {
-      yield nestedSelection.selectionSet;
-    }
-  }
-}
-function* selectionsForSelectionSet({
-  selections
-}) {
-  for (const selection of selections) {
-    yield selection;
-    if ('selectionSet' in selection && selection.selectionSet != null) {
-      yield* selectionsForSelectionSet(selection.selectionSet);
-    }
-  }
-}
-function stripDocumentLoc(loc) {
-  const normalizedLoc = {
-    ...loc
-  };
-  delete normalizedLoc.endToken;
-  delete normalizedLoc.startToken;
-  return normalizedLoc;
-}
-function stripLoc(value) {
-  if (Array.isArray(value)) {
-    value.forEach(stripLoc);
-  } else if (typeof value === 'object') {
-    if (value == null) {
-      return;
-    }
-    if ('loc' in value) {
-      delete value.loc;
-    }
-    for (const key of Object.keys(value)) {
-      stripLoc(value[key]);
-    }
-  }
-}
-function minifyGraphQLSource(source) {
-  return source.replace(/#.*/g, '').replace(/\\n/g, ' ').replace(/\s\s+/g, ' ').replace(/\s*({|}|\(|\)|\.|:|,)\s*/g, '$1');
-}
-
-export { cleanGraphQLDocument, extractGraphQLImports, minifyGraphQLSource, toGraphQLOperation };

package/build/esnext/features/graphql.esnext

@@ -1,84 +0,0 @@
-import { dirname } from 'node:path';
-import { mkdir, writeFile, readFile } from 'node:fs/promises';
-import { parse } from 'graphql';
-import { toGraphQLOperation, cleanGraphQLDocument, extractGraphQLImports } from './graphql/transform.esnext';
-
-function graphql({
-  manifest
-} = {}) {
-  const shouldWriteManifest = Boolean(manifest);
-  const manifestPath = typeof manifest === 'string' ? manifest : `manifests/graphql.json`;
-  return {
-    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);
-          }
-        }
-      });
-      const document = toGraphQLOperation(cleanGraphQLDocument(loadedDocument, {
-        removeUnused: {
-          exclude: topLevelDefinitions
-        }
-      }));
-      return {
-        code: `export default JSON.parse(${JSON.stringify(JSON.stringify(document))})`,
-        meta: shouldWriteManifest ? {
-          quilt: {
-            graphql: document
-          }
-        } : undefined
-      };
-    },
-    async generateBundle() {
-      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') {
-          operations[operation.id] = operation.source;
-        }
-      }
-      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);
-  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);
-  }));
-  for (const importedDocument of resolvedImports) {
-    if (importedDocument == null) continue;
-    document.definitions.push(...importedDocument.definitions);
-  }
-  return document;
-}
-
-export { graphql };

package/build/esnext/features/request-router.esnext

@@ -1,29 +0,0 @@
-import { MAGIC_MODULE_ENTRY, MAGIC_MODULE_REQUEST_ROUTER } from '../constants.esnext';
-import { createMagicModulePlugin } from '../shared/magic-module.esnext';
-import { multiline } from '../shared/strings.esnext';
-
-function magicModuleRequestRouterEntry({
-  host,
-  port
-} = {}) {
-  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;
-    }
-  });
-}
-
-export { magicModuleRequestRouterEntry };

package/build/esnext/features/source-code.esnext

@@ -1,51 +0,0 @@
-import { createRequire } from 'node:module';
-import babel from '@rollup/plugin-babel';
-import esbuild from 'rollup-plugin-esbuild';
-
-const require = createRequire(import.meta.url);
-function sourceCode({
-  mode,
-  targets,
-  babel: useBabel = true
-}) {
-  if (!useBabel) {
-    return esbuild({
-      // Support very modern features
-      target: 'es2022',
-      jsx: 'automatic',
-      jsxImportSource: 'react',
-      exclude: 'node_modules/**'
-    });
-  }
-  return babel({
-    envName: mode,
-    configFile: false,
-    babelrc: false,
-    presets: [require.resolve('@babel/preset-typescript'), [require.resolve('@babel/preset-react'), {
-      runtime: 'automatic',
-      importSource: 'react',
-      development: mode === 'development'
-    }], [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'
-    }]],
-    extensions: ['.ts', '.tsx', '.mts', '.mtsx', '.js', '.jsx', '.es6', '.es', '.mjs'],
-    exclude: 'node_modules/**',
-    babelHelpers: 'bundled',
-    skipPreflightCheck: true,
-    // Babel doesn’t like this option being set to `undefined`.
-    ...(targets ? {
-      targets
-    } : {})
-  });
-}
-
-export { sourceCode };

package/build/esnext/features/system-js.esnext

@@ -1,33 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { createRequire } from 'node:module';
-
-function systemJS({
-  minify = false
-} = {}) {
-  return {
-    name: '@quilted/system-js',
-    async renderChunk(_, chunk, options) {
-      if (options.format !== 'system' || !chunk.isEntry) return null;
-      const require = createRequire(import.meta.url);
-      const systemjs = minify ? require.resolve('systemjs/dist/s.min.js') : require.resolve('systemjs/dist/s.js');
-
-      // We write the systemjs loader to a dedicated file, and we make it the
-      // "first import" of the chunk so that it is the first file listed in
-      // the manifest.
-      const fileHandle = this.emitFile({
-        type: 'asset',
-        name: 'loader.js',
-        source: (await readFile(systemjs, {
-          encoding: 'utf8'
-        })).replace(
-        // Remove the source map comment, if it is present, because we don’t upload the
-        // sourcemap for this file.
-        /\n?[/][/]# sourceMappingURL=s.*\.map\n?$/, '')
-      });
-      chunk.imports.unshift(this.getFileName(fileHandle));
-      return null;
-    }
-  };
-}
-
-export { systemJS };

package/build/esnext/features/typescript.esnext

@@ -1,34 +0,0 @@
-import * as path from 'node:path';
-import * as fs from 'node:fs';
-
-async function createTSConfigAliasPlugin({
-  root = process.cwd()
-} = {}) {
-  const [{
-    default: alias
-  }, tsconfig] = await Promise.all([import('@rollup/plugin-alias'), getTSConfig(root)]);
-  const tsconfigPaths = tsconfig?.compilerOptions?.paths;
-  if (tsconfigPaths == null) return undefined;
-  return alias({
-    entries: Object.entries(tsconfigPaths).map(([name, aliases]) => {
-      return {
-        find: name.includes('*') ? new RegExp(`^${name.replace(/\*/, '(.*)')}$`) : name,
-        replacement: aliases[0].replace('*', '$1')
-      };
-    })
-  });
-}
-async function getTSConfig(root) {
-  const tsconfigPath = path.join(root, 'tsconfig.json');
-  if (!fs.existsSync(tsconfigPath)) {
-    return undefined;
-  }
-  try {
-    const tsconfig = JSON.parse(await fs.promises.readFile(tsconfigPath, 'utf8'));
-    return tsconfig;
-  } catch {
-    // intentional noop
-  }
-}
-
-export { createTSConfigAliasPlugin };

package/build/esnext/index.esnext

@@ -1,3 +0,0 @@
-export { quiltAppBrowser, quiltAppServer } from './app.esnext';
-export { quiltModule } from './module.esnext';
-export { quiltPackageESModules, quiltPackageESNext } from './package.esnext';

package/build/esnext/module.esnext

@@ -1,100 +0,0 @@
-import * as path from 'node:path';
-import { glob } from 'glob';
-import { fileURLToPath } from 'node:url';
-import { getNodePlugins, removeBuildFiles } from './shared/rollup.esnext';
-import { loadPackageJSON } from './shared/package-json.esnext';
-import { getBrowserTargetDetails } from './shared/browserslist.esnext';
-
-async function quiltModule({
-  root: rootPath = process.cwd(),
-  env,
-  assets,
-  graphql = true
-} = {}) {
-  const root = typeof rootPath === 'string' ? rootPath : fileURLToPath(rootPath);
-  const mode = (typeof env === 'object' ? env?.mode : undefined) ?? 'production';
-  const outputDirectory = path.join(root, 'build/assets');
-  const minify = assets?.minify ?? true;
-  const hash = assets?.hash ?? 'async-only';
-  const browserTarget = await getBrowserTargetDetails(assets?.targets, {
-    root
-  });
-  const targetFilenamePart = browserTarget.name ? `.${browserTarget.name}` : '';
-  const [{
-    visualizer
-  }, {
-    magicModuleEnv,
-    replaceProcessEnv
-  }, {
-    sourceCode
-  }, nodePlugins, packageJSON] = await Promise.all([import('rollup-plugin-visualizer'), import('./features/env.esnext'), import('./features/source-code.esnext'), getNodePlugins(), loadPackageJSON(root)]);
-  const source = await sourceForModule(root, packageJSON);
-  const plugins = [...nodePlugins, replaceProcessEnv({
-    mode
-  }), magicModuleEnv({
-    ...env,
-    mode
-  }), sourceCode({
-    mode: 'production',
-    targets: browserTarget.browsers
-  }), removeBuildFiles(['build/assets', 'build/reports'], {
-    root
-  })];
-  if (graphql) {
-    const {
-      graphql
-    } = await import('./features/graphql.esnext');
-    plugins.push(graphql({
-      manifest: false
-    }));
-  }
-  if (minify) {
-    const {
-      minify
-    } = await import('rollup-plugin-esbuild');
-    plugins.push(minify());
-  }
-  plugins.push(visualizer({
-    template: 'treemap',
-    open: false,
-    brotliSize: true,
-    filename: path.resolve(root, `build/reports/bundle-visualizer${targetFilenamePart}.html`)
-  }));
-  return {
-    input: source,
-    plugins,
-    onwarn(warning, defaultWarn) {
-      // Removes annoying warnings for React-focused libraries that
-      // include 'use client' directives.
-      if (warning.code === 'MODULE_LEVEL_DIRECTIVE' && /['"]use client['"]/.test(warning.message)) {
-        return;
-      }
-      defaultWarn(warning);
-    },
-    output: {
-      format: 'esm',
-      dir: outputDirectory,
-      entryFileNames: `[name]${targetFilenamePart}${hash === true ? `.[hash]` : ''}.js`,
-      chunkFileNames: `[name]${targetFilenamePart}${hash === true || hash === 'async-only' ? `.[hash]` : ''}.js`,
-      assetFileNames: `[name]${targetFilenamePart}${hash === true ? `.[hash]` : ''}.[ext]`
-    }
-  };
-}
-async function sourceForModule(root, packageJSON) {
-  const {
-    main,
-    exports
-  } = packageJSON;
-  const entryFromPackageJSON = main ?? exports?.['.'];
-  if (entryFromPackageJSON) {
-    return path.resolve(root, entryFromPackageJSON);
-  }
-  const possibleSourceFiles = await glob('{index,module,entry,input}.{ts,tsx,mjs,js,jsx}', {
-    cwd: root,
-    nodir: true,
-    absolute: true
-  });
-  return possibleSourceFiles[0];
-}
-
-export { quiltModule };