@quilted/rollup 0.1.0

package/build/cjs/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/removeNonPrintingValuesTransformer/removeNonPrintingValuesTransformer.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isValidValue = function isValidValue(x) {
+  return x != null && !Number.isNaN(x) && typeof x !== 'boolean';
+};
+
+var removeNonPrintingValuesTransformer = function removeNonPrintingValuesTransformer() {
+  return {
+    onSubstitution: function onSubstitution(substitution) {
+      if (Array.isArray(substitution)) {
+        return substitution.filter(isValidValue);
+      }
+      if (isValidValue(substitution)) {
+        return substitution;
+      }
+      return '';
+    }
+  };
+};
+
+exports["default"] = removeNonPrintingValuesTransformer;

package/build/cjs/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/replaceResultTransformer/replaceResultTransformer.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Replaces tabs, newlines and spaces with the chosen value when they occur in sequences
+ * @param  {(String|RegExp)} replaceWhat - the value or pattern that should be replaced
+ * @param  {*}               replaceWith - the replacement value
+ * @return {Object}                      - a TemplateTag transformer
+ */
+var replaceResultTransformer = function replaceResultTransformer(replaceWhat, replaceWith) {
+  return {
+    onEndResult: function onEndResult(endResult) {
+      if (replaceWhat == null || replaceWith == null) {
+        throw new Error('replaceResultTransformer requires at least 2 arguments.');
+      }
+      return endResult.replace(replaceWhat, replaceWith);
+    }
+  };
+};
+
+exports["default"] = replaceResultTransformer;

package/build/cjs/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/replaceSubstitutionTransformer/replaceSubstitutionTransformer.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var replaceSubstitutionTransformer = function replaceSubstitutionTransformer(replaceWhat, replaceWith) {
+  return {
+    onSubstitution: function onSubstitution(substitution, resultSoFar) {
+      if (replaceWhat == null || replaceWith == null) {
+        throw new Error('replaceSubstitutionTransformer requires at least 2 arguments.');
+      }
+
+      // Do not touch if null or undefined
+      if (substitution == null) {
+        return substitution;
+      } else {
+        return substitution.toString().replace(replaceWhat, replaceWith);
+      }
+    }
+  };
+};
+
+exports["default"] = replaceSubstitutionTransformer;

package/build/cjs/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/safeHtml/safeHtml.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var TemplateTag = require('../TemplateTag/TemplateTag.cjs');
+var stripIndentTransformer = require('../stripIndentTransformer/stripIndentTransformer.cjs');
+var inlineArrayTransformer = require('../inlineArrayTransformer/inlineArrayTransformer.cjs');
+var trimResultTransformer = require('../trimResultTransformer/trimResultTransformer.cjs');
+var splitStringTransformer = require('../splitStringTransformer/splitStringTransformer.cjs');
+var replaceSubstitutionTransformer = require('../replaceSubstitutionTransformer/replaceSubstitutionTransformer.cjs');
+
+new TemplateTag["default"](splitStringTransformer["default"]('\n'), inlineArrayTransformer["default"], stripIndentTransformer["default"], trimResultTransformer["default"], replaceSubstitutionTransformer["default"](/&/g, '&amp;'), replaceSubstitutionTransformer["default"](/</g, '&lt;'), replaceSubstitutionTransformer["default"](/>/g, '&gt;'), replaceSubstitutionTransformer["default"](/"/g, '&quot;'), replaceSubstitutionTransformer["default"](/'/g, '&#x27;'), replaceSubstitutionTransformer["default"](/`/g, '&#x60;'));

package/build/cjs/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/splitStringTransformer/splitStringTransformer.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var splitStringTransformer = function splitStringTransformer(splitBy) {
+  return {
+    onSubstitution: function onSubstitution(substitution, resultSoFar) {
+      if (splitBy != null && typeof splitBy === 'string') {
+        if (typeof substitution === 'string' && substitution.includes(splitBy)) {
+          substitution = substitution.split(splitBy);
+        }
+      } else {
+        throw new Error('You need to specify a string character to split by.');
+      }
+      return substitution;
+    }
+  };
+};
+
+exports["default"] = splitStringTransformer;

package/build/cjs/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndent/stripIndent.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var TemplateTag = require('../TemplateTag/TemplateTag.cjs');
+var stripIndentTransformer = require('../stripIndentTransformer/stripIndentTransformer.cjs');
+var trimResultTransformer = require('../trimResultTransformer/trimResultTransformer.cjs');
+
+var stripIndent = new TemplateTag["default"](stripIndentTransformer["default"], trimResultTransformer["default"]);
+
+exports["default"] = stripIndent;

package/build/cjs/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndentTransformer/stripIndentTransformer.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+/**
+ * strips indentation from a template literal
+ * @param  {String} type = 'initial' - whether to remove all indentation or just leading indentation. can be 'all' or 'initial'
+ * @return {Object}                  - a TemplateTag transformer
+ */
+var stripIndentTransformer = function stripIndentTransformer() {
+  var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'initial';
+  return {
+    onEndResult: function onEndResult(endResult) {
+      if (type === 'initial') {
+        // remove the shortest leading indentation from each line
+        var match = endResult.match(/^[^\S\n]*(?=\S)/gm);
+        var indent = match && Math.min.apply(Math, _toConsumableArray(match.map(function (el) {
+          return el.length;
+        })));
+        if (indent) {
+          var regexp = new RegExp('^.{' + indent + '}', 'gm');
+          return endResult.replace(regexp, '');
+        }
+        return endResult;
+      }
+      if (type === 'all') {
+        // remove all indentation from each line
+        return endResult.replace(/^[^\S\n]+/gm, '');
+      }
+      throw new Error('Unknown type: ' + type);
+    }
+  };
+};
+
+exports["default"] = stripIndentTransformer;

package/build/cjs/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndents/stripIndents.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var TemplateTag = require('../TemplateTag/TemplateTag.cjs');
+var stripIndentTransformer = require('../stripIndentTransformer/stripIndentTransformer.cjs');
+var trimResultTransformer = require('../trimResultTransformer/trimResultTransformer.cjs');
+
+new TemplateTag["default"](stripIndentTransformer["default"]('all'), trimResultTransformer["default"]);

package/build/cjs/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/trimResultTransformer/trimResultTransformer.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * TemplateTag transformer that trims whitespace on the end result of a tagged template
+ * @param  {String} side = '' - The side of the string to trim. Can be 'start' or 'end' (alternatively 'left' or 'right')
+ * @return {Object}           - a TemplateTag transformer
+ */
+var trimResultTransformer = function trimResultTransformer() {
+  var side = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return {
+    onEndResult: function onEndResult(endResult) {
+      if (side === '') {
+        return endResult.trim();
+      }
+
+      side = side.toLowerCase();
+
+      if (side === 'start' || side === 'left') {
+        return endResult.replace(/^\s*/, '');
+      }
+
+      if (side === 'end' || side === 'right') {
+        return endResult.replace(/\s*$/, '');
+      }
+
+      throw new Error('Side not supported: ' + side);
+    }
+  };
+};
+
+exports["default"] = trimResultTransformer;

package/build/cjs/request-router.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+var magicModule = require('./shared/magic-module.cjs');
+var strings = require('./shared/strings.cjs');
+
+function magicModuleRequestRouterEntry({
+  host,
+  port
+} = {}) {
+  return magicModule.createMagicModuleEntryPlugin({
+    name: '@quilted/request-router',
+    sideEffects: true,
+    async source() {
+      const initialContent = strings.multiline`
+        import requestRouter from ${JSON.stringify(constants.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;
+    }
+  });
+}
+
+exports.magicModuleRequestRouterEntry = magicModuleRequestRouterEntry;

package/build/cjs/shared/magic-module.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+var constants = require('../constants.cjs');
+
+const VIRTUAL_MODULE_PREFIX = '\0';
+const VIRTUAL_MODULE_POSTFIX = '/module.js';
+function createMagicModulePlugin({
+  name,
+  module,
+  alias = `${VIRTUAL_MODULE_PREFIX}${module}${VIRTUAL_MODULE_POSTFIX}`,
+  source: getSource,
+  sideEffects = false
+}) {
+  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
+  };
+}
+function createMagicModuleEntryPlugin({
+  module = constants.MAGIC_MODULE_ENTRY,
+  ...options
+}) {
+  return createMagicModulePlugin({
+    ...options,
+    module
+  });
+}
+
+exports.createMagicModuleEntryPlugin = createMagicModuleEntryPlugin;
+exports.createMagicModulePlugin = createMagicModulePlugin;

package/build/cjs/shared/strings.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+function multiline(strings, ...values) {
+  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();
+}
+
+exports.multiline = multiline;

package/build/esm/app.mjs

@@ -0,0 +1,130 @@
+import { MAGIC_MODULE_APP_COMPONENT, MAGIC_MODULE_REQUEST_ROUTER, MAGIC_MODULE_BROWSER_ASSETS } from './constants.mjs';
+import { magicModuleEnv } from './env.mjs';
+import { magicModuleRequestRouterEntry } from './request-router.mjs';
+import { multiline } from './shared/strings.mjs';
+import { createMagicModulePlugin, createMagicModuleEntryPlugin } from './shared/magic-module.mjs';
+
+function quiltApp({
+  env,
+  entry
+} = {}) {
+  return {
+    name: '@quilted/app',
+    options(originalOptions) {
+      const newPlugins = [...(Array.isArray(originalOptions.plugins) ? originalOptions.plugins : originalOptions.plugins ? [originalOptions.plugins] : [])];
+      const newOptions = {
+        ...originalOptions,
+        plugins: newPlugins
+      };
+      if (env) {
+        newPlugins.push(typeof env === 'boolean' ? magicModuleEnv() : magicModuleEnv(env));
+      }
+      if (entry) {
+        newPlugins.push(magicModuleAppComponent({
+          entry
+        }));
+      }
+      return newOptions;
+    }
+  };
+}
+function quiltAppBrowser(options = {}) {
+  return {
+    name: '@quilted/app/browser',
+    options(originalOptions) {
+      const newPlugins = [...(Array.isArray(originalOptions.plugins) ? originalOptions.plugins : originalOptions.plugins ? [originalOptions.plugins] : [])];
+      const newOptions = {
+        ...originalOptions,
+        plugins: newPlugins
+      };
+      newPlugins.push(magicModuleAppBrowserEntry(options));
+      return newOptions;
+    }
+  };
+}
+function quiltAppServer(options = {}) {
+  return {
+    name: '@quilted/app/server',
+    options(originalOptions) {
+      const newPlugins = [...(Array.isArray(originalOptions.plugins) ? originalOptions.plugins : originalOptions.plugins ? [originalOptions.plugins] : [])];
+      const newOptions = {
+        ...originalOptions,
+        plugins: newPlugins
+      };
+      newPlugins.push(magicModuleRequestRouterEntry());
+      newPlugins.push(magicModuleAppRequestRouter(options));
+      return newOptions;
+    }
+  };
+}
+function magicModuleAppComponent({
+  entry
+}) {
+  return createMagicModulePlugin({
+    name: '@quilted/magic-module/app',
+    module: MAGIC_MODULE_APP_COMPONENT,
+    alias: entry
+  });
+}
+function magicModuleAppRequestRouter({
+  entry
+} = {}) {
+  return createMagicModulePlugin({
+    name: '@quilted/magic-module/app-request-router',
+    module: MAGIC_MODULE_REQUEST_ROUTER,
+    alias: entry,
+    source: entry ? undefined : async function source() {
+      return multiline`
+            import '@quilted/quilt/globals';
+
+            import {jsx} from 'react/jsx-runtime';
+            import {RequestRouter} from '@quilted/quilt/request-router';
+            import {renderToResponse} from '@quilted/quilt/server';
+
+            import App from ${JSON.stringify(MAGIC_MODULE_APP_COMPONENT)};
+            import {BrowserAssets} from ${JSON.stringify(MAGIC_MODULE_BROWSER_ASSETS)};
+
+            const router = new RequestRouter();
+            const assets = new BrowserAssets();
+
+            // For all GET requests, render our React application.
+            router.get(async (request) => {
+              const response = await renderToResponse(jsx(App), {
+                request,
+                assets,
+              });
+
+              return response;
+            });
+
+            export default router;
+          `;
+    }
+  });
+}
+function magicModuleAppBrowserEntry({
+  hydrate = true,
+  selector = '#app'
+} = {}) {
+  return createMagicModuleEntryPlugin({
+    name: '@quilted/magic-module/app-browser-entry',
+    sideEffects: true,
+    async source() {
+      const reactRootFunction = hydrate ? 'hydrateRoot' : 'createRoot';
+      return multiline`
+        import '@quilted/quilt/globals';
+
+        import {jsx} from 'react/jsx-runtime';
+        import {${reactRootFunction}} from 'react-dom/client';
+
+        import App from ${JSON.stringify(MAGIC_MODULE_APP_COMPONENT)};
+
+        const element = document.querySelector(${JSON.stringify(selector)});
+
+        ${hydrate ? `${reactRootFunction}(element, jsx(App));` : `${reactRootFunction}(element).render(jsx(App));`}
+      `;
+    }
+  });
+}
+
+export { magicModuleAppBrowserEntry, magicModuleAppComponent, magicModuleAppRequestRouter, quiltApp, quiltAppBrowser, quiltAppServer };

package/build/esm/constants.mjs

@@ -0,0 +1,7 @@
+const MAGIC_MODULE_ENV = 'quilt:module/env';
+const MAGIC_MODULE_ENTRY = 'quilt:module/entry';
+const MAGIC_MODULE_APP_COMPONENT = 'quilt:module/app';
+const MAGIC_MODULE_BROWSER_ASSETS = 'quilt:module/assets';
+const MAGIC_MODULE_REQUEST_ROUTER = 'quilt:module/request-router';
+
+export { MAGIC_MODULE_APP_COMPONENT, MAGIC_MODULE_BROWSER_ASSETS, MAGIC_MODULE_ENTRY, MAGIC_MODULE_ENV, MAGIC_MODULE_REQUEST_ROUTER };

package/build/esm/env.mjs

@@ -0,0 +1,108 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/TemplateTag/TemplateTag.mjs';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaLists/commaLists.mjs';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaListsAnd/commaListsAnd.mjs';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaListsOr/commaListsOr.mjs';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/html/html.mjs';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/safeHtml/safeHtml.mjs';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLine/oneLine.mjs';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineTrim/oneLineTrim.mjs';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaLists/oneLineCommaLists.mjs';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaListsOr/oneLineCommaListsOr.mjs';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaListsAnd/oneLineCommaListsAnd.mjs';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/inlineLists/inlineLists.mjs';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineInlineLists/oneLineInlineLists.mjs';
+import stripIndent from './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndent/stripIndent.mjs';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndents/stripIndents.mjs';
+import { MAGIC_MODULE_ENV } from './constants.mjs';
+import { createMagicModulePlugin } from './shared/magic-module.mjs';
+
+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 stripIndent`
+        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 };

package/build/esm/index.mjs

@@ -0,0 +1,3 @@
+export { magicModuleEnv } from './env.mjs';
+export { magicModuleAppBrowserEntry, magicModuleAppComponent, magicModuleAppRequestRouter, quiltApp, quiltAppBrowser, quiltAppServer } from './app.mjs';
+export { magicModuleRequestRouterEntry } from './request-router.mjs';