@qpqjs/user-script 0.0.0-stage → 0.2.1

package/lib/commonjs/build/buildUserScript.js

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUserScript = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const getUserScriptRspackConfig_1 = require("./getUserScriptRspackConfig");
+const resolveUserScriptEntry_1 = require("./resolveUserScriptEntry");
+const runUserScriptRspack_1 = require("./runUserScriptRspack");
+const USER_SCRIPT_OUTPUT_FILENAME_1 = require("./USER_SCRIPT_OUTPUT_FILENAME");
+const UserScriptBuildError_1 = require("./UserScriptBuildError");
+const getErrorMessage = (error) => (error instanceof Error ? error.message : String(error));
+/**
+ * Builds a script project into `<outDir>/main.js`, the only file written. The output is not
+ * loaded here: a platform build has the sandbox report its exports (askUserScriptListExports)
+ * and a local build uses checkUserScriptOutput. Throws UserScriptBuildError; the `code` says
+ * whether the project or the bundle was at fault. `outDir` is emptied first.
+ */
+const buildUserScript = (_a) => __awaiter(void 0, [_a], void 0, function* ({ projectDir, outDir, sourceMap = false, hostModules = {}, }) {
+    const absoluteProjectDir = path_1.default.resolve(projectDir);
+    const absoluteOutDir = path_1.default.resolve(outDir);
+    const entrySource = (0, resolveUserScriptEntry_1.resolveUserScriptEntry)(absoluteProjectDir);
+    try {
+        yield (0, runUserScriptRspack_1.runUserScriptRspack)((0, getUserScriptRspackConfig_1.getUserScriptRspackConfig)({
+            projectDir: absoluteProjectDir,
+            entryPath: entrySource,
+            outDir: absoluteOutDir,
+            sourceMap,
+            hostModuleNames: Object.keys(hostModules),
+        }));
+    }
+    catch (error) {
+        throw new UserScriptBuildError_1.UserScriptBuildError(UserScriptBuildError_1.UserScriptBuildErrorCode.BuildFailed, `Building [${absoluteProjectDir}] failed:\n${getErrorMessage(error)}`);
+    }
+    // Every emitted file counts, not just scripts: the build's whole output is one file, so a
+    // stray map, chunk or asset would be silently lost when only main.js is published.
+    const emitted = fs_1.default.readdirSync(absoluteOutDir);
+    if (emitted.length !== 1 || emitted[0] !== USER_SCRIPT_OUTPUT_FILENAME_1.USER_SCRIPT_OUTPUT_FILENAME) {
+        throw new UserScriptBuildError_1.UserScriptBuildError(UserScriptBuildError_1.UserScriptBuildErrorCode.OutputNotSingleFile, `Building [${absoluteProjectDir}] emitted [${emitted.join(', ')}]; a script must build to exactly ${USER_SCRIPT_OUTPUT_FILENAME_1.USER_SCRIPT_OUTPUT_FILENAME}`);
+    }
+    return { entryPath: path_1.default.join(absoluteOutDir, USER_SCRIPT_OUTPUT_FILENAME_1.USER_SCRIPT_OUTPUT_FILENAME) };
+});
+exports.buildUserScript = buildUserScript;
+//# sourceMappingURL=buildUserScript.js.map

package/lib/commonjs/build/buildUserScript.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildUserScript.js","sourceRoot":"","sources":["../../../src/build/buildUserScript.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAEA,4CAAoB;AACpB,gDAAwB;AAExB,2EAAwE;AACxE,qEAAkE;AAClE,+DAA4D;AAC5D,+EAA4E;AAC5E,iEAAwF;AAaxF,MAAM,eAAe,GAAG,CAAC,KAAc,EAAU,EAAE,CAAC,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;AAE7G;;;;;GAKG;AACI,MAAM,eAAe,GAAG,KAK4B,EAAE,4CALvB,EACpC,UAAU,EACV,MAAM,EACN,SAAS,GAAG,KAAK,EACjB,WAAW,GAAG,EAAE,GACO;IACvB,MAAM,kBAAkB,GAAG,cAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IACpD,MAAM,cAAc,GAAG,cAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5C,MAAM,WAAW,GAAG,IAAA,+CAAsB,EAAC,kBAAkB,CAAC,CAAC;IAE/D,IAAI,CAAC;QACH,MAAM,IAAA,yCAAmB,EACvB,IAAA,qDAAyB,EAAC;YACxB,UAAU,EAAE,kBAAkB;YAC9B,SAAS,EAAE,WAAW;YACtB,MAAM,EAAE,cAAc;YACtB,SAAS;YACT,eAAe,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC;SAC1C,CAAC,CACH,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,2CAAoB,CAAC,+CAAwB,CAAC,WAAW,EAAE,aAAa,kBAAkB,cAAc,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAC9I,CAAC;IAED,0FAA0F;IAC1F,mFAAmF;IACnF,MAAM,OAAO,GAAG,YAAE,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;IAC/C,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,yDAA2B,EAAE,CAAC;QACvE,MAAM,IAAI,2CAAoB,CAC5B,+CAAwB,CAAC,mBAAmB,EAC5C,aAAa,kBAAkB,cAAc,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,qCAAqC,yDAA2B,EAAE,CAClI,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,SAAS,EAAE,cAAI,CAAC,IAAI,CAAC,cAAc,EAAE,yDAA2B,CAAC,EAAE,CAAC;AAC/E,CAAC,CAAA,CAAC;AAnCW,QAAA,eAAe,mBAmC1B","sourcesContent":["import { UserScriptModuleMap } from '@qpqjs/actionprocessor-node';\n\nimport fs from 'fs';\nimport path from 'path';\n\nimport { getUserScriptRspackConfig } from './getUserScriptRspackConfig';\nimport { resolveUserScriptEntry } from './resolveUserScriptEntry';\nimport { runUserScriptRspack } from './runUserScriptRspack';\nimport { USER_SCRIPT_OUTPUT_FILENAME } from './USER_SCRIPT_OUTPUT_FILENAME';\nimport { UserScriptBuildError, UserScriptBuildErrorCode } from './UserScriptBuildError';\nimport { UserScriptBuildResult } from './UserScriptBuildResult';\n\nexport type BuildUserScriptOptions = {\n  projectDir: string;\n  outDir: string;\n  // Embed a source map in main.js. Off by default; a separate .map file is never written.\n  sourceMap?: boolean;\n  // The service's own script modules (defineUserScriptModule), by import name, which the\n  // bundler keeps external. A local build has none.\n  hostModules?: UserScriptModuleMap;\n};\n\nconst getErrorMessage = (error: unknown): string => (error instanceof Error ? error.message : String(error));\n\n/**\n * Builds a script project into `<outDir>/main.js`, the only file written. The output is not\n * loaded here: a platform build has the sandbox report its exports (askUserScriptListExports)\n * and a local build uses checkUserScriptOutput. Throws UserScriptBuildError; the `code` says\n * whether the project or the bundle was at fault. `outDir` is emptied first.\n */\nexport const buildUserScript = async ({\n  projectDir,\n  outDir,\n  sourceMap = false,\n  hostModules = {},\n}: BuildUserScriptOptions): Promise<UserScriptBuildResult> => {\n  const absoluteProjectDir = path.resolve(projectDir);\n  const absoluteOutDir = path.resolve(outDir);\n  const entrySource = resolveUserScriptEntry(absoluteProjectDir);\n\n  try {\n    await runUserScriptRspack(\n      getUserScriptRspackConfig({\n        projectDir: absoluteProjectDir,\n        entryPath: entrySource,\n        outDir: absoluteOutDir,\n        sourceMap,\n        hostModuleNames: Object.keys(hostModules),\n      }),\n    );\n  } catch (error) {\n    throw new UserScriptBuildError(UserScriptBuildErrorCode.BuildFailed, `Building [${absoluteProjectDir}] failed:\\n${getErrorMessage(error)}`);\n  }\n\n  // Every emitted file counts, not just scripts: the build's whole output is one file, so a\n  // stray map, chunk or asset would be silently lost when only main.js is published.\n  const emitted = fs.readdirSync(absoluteOutDir);\n  if (emitted.length !== 1 || emitted[0] !== USER_SCRIPT_OUTPUT_FILENAME) {\n    throw new UserScriptBuildError(\n      UserScriptBuildErrorCode.OutputNotSingleFile,\n      `Building [${absoluteProjectDir}] emitted [${emitted.join(', ')}]; a script must build to exactly ${USER_SCRIPT_OUTPUT_FILENAME}`,\n    );\n  }\n\n  return { entryPath: path.join(absoluteOutDir, USER_SCRIPT_OUTPUT_FILENAME) };\n};\n"]}

package/lib/commonjs/build/checkUserScriptOutput.d.ts

@@ -0,0 +1,7 @@
+import { UserScriptModuleMap } from '@qpqjs/actionprocessor-node';
+/**
+ * Loads a built file in this process and applies the output contract. For a developer's own
+ * build (`qpq script:build`) only: a platform build asks the sandbox with
+ * askUserScriptListExports instead, so no script code runs in the host.
+ */
+export declare const checkUserScriptOutput: (entryPath: string, hostModules?: UserScriptModuleMap) => string[];

package/lib/commonjs/build/checkUserScriptOutput.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkUserScriptOutput = void 0;
+const actionprocessor_node_1 = require("@qpqjs/actionprocessor-node");
+const fs_1 = __importDefault(require("fs"));
+const assertUserScriptExports_1 = require("./assertUserScriptExports");
+/**
+ * Loads a built file in this process and applies the output contract. For a developer's own
+ * build (`qpq script:build`) only: a platform build asks the sandbox with
+ * askUserScriptListExports instead, so no script code runs in the host.
+ */
+const checkUserScriptOutput = (entryPath, hostModules = {}) => (0, assertUserScriptExports_1.assertUserScriptExports)(entryPath, (0, actionprocessor_node_1.listUserScriptExports)(entryPath, fs_1.default.readFileSync(entryPath, 'utf8'), (0, actionprocessor_node_1.getUserScriptModuleMap)(hostModules)));
+exports.checkUserScriptOutput = checkUserScriptOutput;
+//# sourceMappingURL=checkUserScriptOutput.js.map

package/lib/commonjs/build/checkUserScriptOutput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkUserScriptOutput.js","sourceRoot":"","sources":["../../../src/build/checkUserScriptOutput.ts"],"names":[],"mappings":";;;;;;AAAA,sEAAiH;AAEjH,4CAAoB;AAEpB,uEAAoE;AAEpE;;;;GAIG;AACI,MAAM,qBAAqB,GAAG,CAAC,SAAiB,EAAE,cAAmC,EAAE,EAAY,EAAE,CAC1G,IAAA,iDAAuB,EAAC,SAAS,EAAE,IAAA,4CAAqB,EAAC,SAAS,EAAE,YAAE,CAAC,YAAY,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE,IAAA,6CAAsB,EAAC,WAAW,CAAC,CAAC,CAAC,CAAC;AADnI,QAAA,qBAAqB,yBAC8G","sourcesContent":["import { getUserScriptModuleMap, listUserScriptExports, UserScriptModuleMap } from '@qpqjs/actionprocessor-node';\n\nimport fs from 'fs';\n\nimport { assertUserScriptExports } from './assertUserScriptExports';\n\n/**\n * Loads a built file in this process and applies the output contract. For a developer's own\n * build (`qpq script:build`) only: a platform build asks the sandbox with\n * askUserScriptListExports instead, so no script code runs in the host.\n */\nexport const checkUserScriptOutput = (entryPath: string, hostModules: UserScriptModuleMap = {}): string[] =>\n  assertUserScriptExports(entryPath, listUserScriptExports(entryPath, fs.readFileSync(entryPath, 'utf8'), getUserScriptModuleMap(hostModules)));\n"]}

package/lib/commonjs/build/createUserScriptExternals.d.ts

@@ -0,0 +1,11 @@
+import type { ExternalItemFunctionData } from '@rspack/core';
+type ExternalsCallback = (error?: Error, result?: string) => void;
+/**
+ * The externals rule for a user-script build: the shared framework packages and the
+ * service's own script modules (`hostModuleNames`, from defineUserScriptModule) stay
+ * external (the host provides them at run time), Node builtins are refused here with
+ * the importing file named, because the loader would refuse them at run time anyway,
+ * and everything else is bundled.
+ */
+export declare const createUserScriptExternals: (hostModuleNames?: readonly string[]) => ({ request, contextInfo }: ExternalItemFunctionData, callback: ExternalsCallback) => void;
+export {};

package/lib/commonjs/build/createUserScriptExternals.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUserScriptExternals = void 0;
+const core_1 = require("@qpqjs/core");
+const module_1 = require("module");
+const sharedPackageNames = core_1.FEDERATED_SHARED_PACKAGE_NAMES;
+const isNodeBuiltin = (request) => request.startsWith('node:') || module_1.builtinModules.includes(request);
+// A subpath of a shared package would bundle a second copy of it beside the host's.
+const isSharedPackageSubpath = (request) => sharedPackageNames.some((name) => request.startsWith(`${name}/`));
+/**
+ * The externals rule for a user-script build: the shared framework packages and the
+ * service's own script modules (`hostModuleNames`, from defineUserScriptModule) stay
+ * external (the host provides them at run time), Node builtins are refused here with
+ * the importing file named, because the loader would refuse them at run time anyway,
+ * and everything else is bundled.
+ */
+const createUserScriptExternals = (hostModuleNames = []) => ({ request, contextInfo }, callback) => {
+    if (!request) {
+        return callback();
+    }
+    if (sharedPackageNames.includes(request) || hostModuleNames.includes(request)) {
+        return callback(undefined, `commonjs ${request}`);
+    }
+    const importer = (contextInfo === null || contextInfo === void 0 ? void 0 : contextInfo.issuer) || 'the entry';
+    if (isNodeBuiltin(request)) {
+        return callback(new Error(`[${importer}] imports the Node builtin [${request}], which a user script cannot use`));
+    }
+    if (isSharedPackageSubpath(request)) {
+        return callback(new Error(`[${importer}] imports [${request}]; import the package root instead so the host's copy is used`));
+    }
+    return callback();
+};
+exports.createUserScriptExternals = createUserScriptExternals;
+//# sourceMappingURL=createUserScriptExternals.js.map

package/lib/commonjs/build/createUserScriptExternals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createUserScriptExternals.js","sourceRoot":"","sources":["../../../src/build/createUserScriptExternals.ts"],"names":[],"mappings":";;;AAAA,sCAA6D;AAE7D,mCAAwC;AAKxC,MAAM,kBAAkB,GAAsB,qCAA8B,CAAC;AAE7E,MAAM,aAAa,GAAG,CAAC,OAAe,EAAW,EAAE,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,uBAAc,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;AAEpH,oFAAoF;AACpF,MAAM,sBAAsB,GAAG,CAAC,OAAe,EAAW,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC;AAE/H;;;;;;GAMG;AACI,MAAM,yBAAyB,GACpC,CAAC,kBAAqC,EAAE,EAAE,EAAE,CAC5C,CAAC,EAAE,OAAO,EAAE,WAAW,EAA4B,EAAE,QAA2B,EAAQ,EAAE;IACxF,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,QAAQ,EAAE,CAAC;IACpB,CAAC;IAED,IAAI,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,eAAe,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QAC9E,OAAO,QAAQ,CAAC,SAAS,EAAE,YAAY,OAAO,EAAE,CAAC,CAAC;IACpD,CAAC;IAED,MAAM,QAAQ,GAAG,CAAA,WAAW,aAAX,WAAW,uBAAX,WAAW,CAAE,MAAM,KAAI,WAAW,CAAC;IAEpD,IAAI,aAAa,CAAC,OAAO,CAAC,EAAE,CAAC;QAC3B,OAAO,QAAQ,CAAC,IAAI,KAAK,CAAC,IAAI,QAAQ,+BAA+B,OAAO,mCAAmC,CAAC,CAAC,CAAC;IACpH,CAAC;IAED,IAAI,sBAAsB,CAAC,OAAO,CAAC,EAAE,CAAC;QACpC,OAAO,QAAQ,CAAC,IAAI,KAAK,CAAC,IAAI,QAAQ,cAAc,OAAO,+DAA+D,CAAC,CAAC,CAAC;IAC/H,CAAC;IAED,OAAO,QAAQ,EAAE,CAAC;AACpB,CAAC,CAAC;AAtBS,QAAA,yBAAyB,6BAsBlC","sourcesContent":["import { FEDERATED_SHARED_PACKAGE_NAMES } from '@qpqjs/core';\n\nimport { builtinModules } from 'module';\nimport type { ExternalItemFunctionData } from '@rspack/core';\n\ntype ExternalsCallback = (error?: Error, result?: string) => void;\n\nconst sharedPackageNames: readonly string[] = FEDERATED_SHARED_PACKAGE_NAMES;\n\nconst isNodeBuiltin = (request: string): boolean => request.startsWith('node:') || builtinModules.includes(request);\n\n// A subpath of a shared package would bundle a second copy of it beside the host's.\nconst isSharedPackageSubpath = (request: string): boolean => sharedPackageNames.some((name) => request.startsWith(`${name}/`));\n\n/**\n * The externals rule for a user-script build: the shared framework packages and the\n * service's own script modules (`hostModuleNames`, from defineUserScriptModule) stay\n * external (the host provides them at run time), Node builtins are refused here with\n * the importing file named, because the loader would refuse them at run time anyway,\n * and everything else is bundled.\n */\nexport const createUserScriptExternals =\n  (hostModuleNames: readonly string[] = []) =>\n  ({ request, contextInfo }: ExternalItemFunctionData, callback: ExternalsCallback): void => {\n    if (!request) {\n      return callback();\n    }\n\n    if (sharedPackageNames.includes(request) || hostModuleNames.includes(request)) {\n      return callback(undefined, `commonjs ${request}`);\n    }\n\n    const importer = contextInfo?.issuer || 'the entry';\n\n    if (isNodeBuiltin(request)) {\n      return callback(new Error(`[${importer}] imports the Node builtin [${request}], which a user script cannot use`));\n    }\n\n    if (isSharedPackageSubpath(request)) {\n      return callback(new Error(`[${importer}] imports [${request}]; import the package root instead so the host's copy is used`));\n    }\n\n    return callback();\n  };\n"]}

package/lib/commonjs/build/getUserScriptRspackConfig.d.ts

@@ -0,0 +1,15 @@
+import type { Configuration } from '@rspack/core';
+export type UserScriptRspackConfigOptions = {
+    projectDir: string;
+    entryPath: string;
+    outDir: string;
+    sourceMap: boolean;
+    hostModuleNames?: readonly string[];
+};
+/**
+ * The rspack config that bundles a script project into one CommonJS `main.js`: the
+ * author's files and npm packages folded in, the shared framework packages external,
+ * no chunks, and a source map only when asked for, embedded in `main.js`. TypeScript goes
+ * through swc, so nothing is type checked here.
+ */
+export declare const getUserScriptRspackConfig: ({ projectDir, entryPath, outDir, sourceMap, hostModuleNames, }: UserScriptRspackConfigOptions) => Configuration;

package/lib/commonjs/build/getUserScriptRspackConfig.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserScriptRspackConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const createUserScriptExternals_1 = require("./createUserScriptExternals");
+const USER_SCRIPT_OUTPUT_FILENAME_1 = require("./USER_SCRIPT_OUTPUT_FILENAME");
+const userScriptTsRule_1 = require("./userScriptTsRule");
+/**
+ * The rspack config that bundles a script project into one CommonJS `main.js`: the
+ * author's files and npm packages folded in, the shared framework packages external,
+ * no chunks, and a source map only when asked for, embedded in `main.js`. TypeScript goes
+ * through swc, so nothing is type checked here.
+ */
+const getUserScriptRspackConfig = ({ projectDir, entryPath, outDir, sourceMap, hostModuleNames = [], }) => ({
+    context: projectDir,
+    mode: 'production',
+    target: 'node',
+    entry: { main: entryPath },
+    output: {
+        path: outDir,
+        filename: USER_SCRIPT_OUTPUT_FILENAME_1.USER_SCRIPT_OUTPUT_FILENAME,
+        library: { type: 'commonjs2' },
+        clean: true,
+    },
+    externals: [(0, createUserScriptExternals_1.createUserScriptExternals)(hostModuleNames)],
+    externalsType: 'commonjs',
+    // The build is ONE file, so a map can only ride inside it. The output is read from a
+    // drive, never served, so the size an inline map adds does not matter.
+    devtool: sourceMap ? 'inline-source-map' : false,
+    optimization: {
+        minimize: false,
+        splitChunks: false,
+        runtimeChunk: false,
+    },
+    resolve: {
+        extensions: ['.ts', '.tsx', '.js', '.json'],
+        modules: [path_1.default.join(projectDir, 'node_modules'), 'node_modules'],
+    },
+    module: {
+        // A dynamic import must land in the one file, not a sibling chunk.
+        parser: { javascript: { dynamicImportMode: 'eager' } },
+        rules: [(0, userScriptTsRule_1.userScriptTsRule)()],
+    },
+});
+exports.getUserScriptRspackConfig = getUserScriptRspackConfig;
+//# sourceMappingURL=getUserScriptRspackConfig.js.map

package/lib/commonjs/build/getUserScriptRspackConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getUserScriptRspackConfig.js","sourceRoot":"","sources":["../../../src/build/getUserScriptRspackConfig.ts"],"names":[],"mappings":";;;;;;AAAA,gDAAwB;AAGxB,2EAAwE;AACxE,+EAA4E;AAC5E,yDAAsD;AAatD;;;;;GAKG;AACI,MAAM,yBAAyB,GAAG,CAAC,EACxC,UAAU,EACV,SAAS,EACT,MAAM,EACN,SAAS,EACT,eAAe,GAAG,EAAE,GACU,EAAiB,EAAE,CAAC,CAAC;IACnD,OAAO,EAAE,UAAU;IACnB,IAAI,EAAE,YAAY;IAClB,MAAM,EAAE,MAAM;IAEd,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;IAE1B,MAAM,EAAE;QACN,IAAI,EAAE,MAAM;QACZ,QAAQ,EAAE,yDAA2B;QACrC,OAAO,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE;QAC9B,KAAK,EAAE,IAAI;KACZ;IAED,SAAS,EAAE,CAAC,IAAA,qDAAyB,EAAC,eAAe,CAAC,CAAC;IACvD,aAAa,EAAE,UAAU;IAEzB,qFAAqF;IACrF,uEAAuE;IACvE,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,KAAK;IAChD,YAAY,EAAE;QACZ,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,KAAK;KACpB;IAED,OAAO,EAAE;QACP,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC;QAC3C,OAAO,EAAE,CAAC,cAAI,CAAC,IAAI,CAAC,UAAU,EAAE,cAAc,CAAC,EAAE,cAAc,CAAC;KACjE;IAED,MAAM,EAAE;QACN,mEAAmE;QACnE,MAAM,EAAE,EAAE,UAAU,EAAE,EAAE,iBAAiB,EAAE,OAAO,EAAE,EAAE;QACtD,KAAK,EAAE,CAAC,IAAA,mCAAgB,GAAE,CAAC;KAC5B;CACF,CAAC,CAAC;AA1CU,QAAA,yBAAyB,6BA0CnC","sourcesContent":["import path from 'path';\nimport type { Configuration } from '@rspack/core';\n\nimport { createUserScriptExternals } from './createUserScriptExternals';\nimport { USER_SCRIPT_OUTPUT_FILENAME } from './USER_SCRIPT_OUTPUT_FILENAME';\nimport { userScriptTsRule } from './userScriptTsRule';\n\nexport type UserScriptRspackConfigOptions = {\n  projectDir: string;\n  // Absolute path of the entry file (see resolveUserScriptEntry).\n  entryPath: string;\n  outDir: string;\n  // Embed a source map in main.js; never a separate .map file.\n  sourceMap: boolean;\n  // The service's own script modules (defineUserScriptModule), kept external like the shared packages.\n  hostModuleNames?: readonly string[];\n};\n\n/**\n * The rspack config that bundles a script project into one CommonJS `main.js`: the\n * author's files and npm packages folded in, the shared framework packages external,\n * no chunks, and a source map only when asked for, embedded in `main.js`. TypeScript goes\n * through swc, so nothing is type checked here.\n */\nexport const getUserScriptRspackConfig = ({\n  projectDir,\n  entryPath,\n  outDir,\n  sourceMap,\n  hostModuleNames = [],\n}: UserScriptRspackConfigOptions): Configuration => ({\n  context: projectDir,\n  mode: 'production',\n  target: 'node',\n\n  entry: { main: entryPath },\n\n  output: {\n    path: outDir,\n    filename: USER_SCRIPT_OUTPUT_FILENAME,\n    library: { type: 'commonjs2' },\n    clean: true,\n  },\n\n  externals: [createUserScriptExternals(hostModuleNames)],\n  externalsType: 'commonjs',\n\n  // The build is ONE file, so a map can only ride inside it. The output is read from a\n  // drive, never served, so the size an inline map adds does not matter.\n  devtool: sourceMap ? 'inline-source-map' : false,\n  optimization: {\n    minimize: false,\n    splitChunks: false,\n    runtimeChunk: false,\n  },\n\n  resolve: {\n    extensions: ['.ts', '.tsx', '.js', '.json'],\n    modules: [path.join(projectDir, 'node_modules'), 'node_modules'],\n  },\n\n  module: {\n    // A dynamic import must land in the one file, not a sibling chunk.\n    parser: { javascript: { dynamicImportMode: 'eager' } },\n    rules: [userScriptTsRule()],\n  },\n});\n"]}

package/lib/commonjs/build/index.d.ts

@@ -0,0 +1,13 @@
+export * from './assertUserScriptExports';
+export * from './buildUserScript';
+export * from './checkUserScriptOutput';
+export * from './createUserScriptExternals';
+export * from './getUserScriptRspackConfig';
+export * from './loadRspackModule';
+export * from './resolveUserScriptEntry';
+export * from './runUserScriptRspack';
+export * from './USER_SCRIPT_ENTRY_CANDIDATES';
+export * from './USER_SCRIPT_OUTPUT_FILENAME';
+export * from './UserScriptBuildError';
+export * from './UserScriptBuildResult';
+export * from './userScriptTsRule';

package/lib/commonjs/build/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./assertUserScriptExports"), exports);
+__exportStar(require("./buildUserScript"), exports);
+__exportStar(require("./checkUserScriptOutput"), exports);
+__exportStar(require("./createUserScriptExternals"), exports);
+__exportStar(require("./getUserScriptRspackConfig"), exports);
+__exportStar(require("./loadRspackModule"), exports);
+__exportStar(require("./resolveUserScriptEntry"), exports);
+__exportStar(require("./runUserScriptRspack"), exports);
+__exportStar(require("./USER_SCRIPT_ENTRY_CANDIDATES"), exports);
+__exportStar(require("./USER_SCRIPT_OUTPUT_FILENAME"), exports);
+__exportStar(require("./UserScriptBuildError"), exports);
+__exportStar(require("./UserScriptBuildResult"), exports);
+__exportStar(require("./userScriptTsRule"), exports);
+//# sourceMappingURL=index.js.map

package/lib/commonjs/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/build/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4DAA0C;AAC1C,oDAAkC;AAClC,0DAAwC;AACxC,8DAA4C;AAC5C,8DAA4C;AAC5C,qDAAmC;AACnC,2DAAyC;AACzC,wDAAsC;AACtC,iEAA+C;AAC/C,gEAA8C;AAC9C,yDAAuC;AACvC,0DAAwC;AACxC,qDAAmC","sourcesContent":["export * from './assertUserScriptExports';\nexport * from './buildUserScript';\nexport * from './checkUserScriptOutput';\nexport * from './createUserScriptExternals';\nexport * from './getUserScriptRspackConfig';\nexport * from './loadRspackModule';\nexport * from './resolveUserScriptEntry';\nexport * from './runUserScriptRspack';\nexport * from './USER_SCRIPT_ENTRY_CANDIDATES';\nexport * from './USER_SCRIPT_OUTPUT_FILENAME';\nexport * from './UserScriptBuildError';\nexport * from './UserScriptBuildResult';\nexport * from './userScriptTsRule';\n"]}

package/lib/commonjs/build/loadRspackModule.d.ts

@@ -0,0 +1,8 @@
+export type RspackModule = typeof import('@rspack/core');
+/**
+ * Loads @rspack/core, which ships as ES modules only, from CommonJS code that may be
+ * bundled and running on a lambda with rspack on a layer: resolve the entry with Node's
+ * require (NODE_PATH aware), require it where Node allows that, otherwise import it by
+ * file URL. Loaded once per process.
+ */
+export declare const loadRspackModule: () => Promise<RspackModule>;

package/lib/commonjs/build/loadRspackModule.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRspackModule = void 0;
+const module_1 = require("module");
+const url_1 = require("url");
+// Node refuses require() of an ES module on versions before 22.12, or when the module
+// graph awaits at top level; both mean "use import() instead".
+const REQUIRE_ESM_ERROR_CODES = ['ERR_REQUIRE_ESM', 'ERR_REQUIRE_ASYNC_MODULE'];
+// Inside a bundle `require` is the bundler's own and cannot see a layer-provided package;
+// Node's real require can, and honours NODE_PATH, which is how a lambda layer is found.
+const getNodeRequire = () => (typeof __non_webpack_require__ === 'function' ? __non_webpack_require__ : (0, module_1.createRequire)(__filename));
+// Built at run time so neither tsc (which rewrites a literal import() to require() in
+// CommonJS output) nor the bundler can turn it into a require.
+const importByUrl = new Function('url', 'return import(url)');
+const isRequireEsmError = (error) => { var _a; return REQUIRE_ESM_ERROR_CODES.includes((_a = error === null || error === void 0 ? void 0 : error.code) !== null && _a !== void 0 ? _a : ''); };
+const requireOrImport = () => __awaiter(void 0, void 0, void 0, function* () {
+    const nodeRequire = getNodeRequire();
+    const entry = nodeRequire.resolve('@rspack/core');
+    try {
+        return nodeRequire(entry);
+    }
+    catch (error) {
+        if (!isRequireEsmError(error))
+            throw error;
+        return importByUrl((0, url_1.pathToFileURL)(entry).href);
+    }
+});
+let loading;
+/**
+ * Loads @rspack/core, which ships as ES modules only, from CommonJS code that may be
+ * bundled and running on a lambda with rspack on a layer: resolve the entry with Node's
+ * require (NODE_PATH aware), require it where Node allows that, otherwise import it by
+ * file URL. Loaded once per process.
+ */
+const loadRspackModule = () => {
+    if (!loading) {
+        loading = requireOrImport();
+    }
+    return loading;
+};
+exports.loadRspackModule = loadRspackModule;
+//# sourceMappingURL=loadRspackModule.js.map

package/lib/commonjs/build/loadRspackModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadRspackModule.js","sourceRoot":"","sources":["../../../src/build/loadRspackModule.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,mCAAuC;AACvC,6BAAoC;AAOpC,sFAAsF;AACtF,+DAA+D;AAC/D,MAAM,uBAAuB,GAAG,CAAC,iBAAiB,EAAE,0BAA0B,CAAC,CAAC;AAEhF,0FAA0F;AAC1F,wFAAwF;AACxF,MAAM,cAAc,GAAG,GAAgB,EAAE,CAAC,CAAC,OAAO,uBAAuB,KAAK,UAAU,CAAC,CAAC,CAAC,uBAAuB,CAAC,CAAC,CAAC,IAAA,sBAAa,EAAC,UAAU,CAAC,CAAC,CAAC;AAEhJ,sFAAsF;AACtF,+DAA+D;AAC/D,MAAM,WAAW,GAAG,IAAI,QAAQ,CAAC,KAAK,EAAE,oBAAoB,CAA2C,CAAC;AAExG,MAAM,iBAAiB,GAAG,CAAC,KAAc,EAAW,EAAE,WAAC,OAAA,uBAAuB,CAAC,QAAQ,CAAC,MAAC,KAA2B,aAA3B,KAAK,uBAAL,KAAK,CAAwB,IAAI,mCAAI,EAAE,CAAC,CAAA,EAAA,CAAC;AAElI,MAAM,eAAe,GAAG,GAAgC,EAAE;IACxD,MAAM,WAAW,GAAG,cAAc,EAAE,CAAC;IACrC,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;IAElD,IAAI,CAAC;QACH,OAAO,WAAW,CAAC,KAAK,CAAiB,CAAC;IAC5C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC;YAAE,MAAM,KAAK,CAAC;QAC3C,OAAO,WAAW,CAAC,IAAA,mBAAa,EAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;IAChD,CAAC;AACH,CAAC,CAAA,CAAC;AAEF,IAAI,OAA0C,CAAC;AAE/C;;;;;GAKG;AACI,MAAM,gBAAgB,GAAG,GAA0B,EAAE;IAC1D,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,GAAG,eAAe,EAAE,CAAC;IAC9B,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AALW,QAAA,gBAAgB,oBAK3B","sourcesContent":["import { createRequire } from 'module';\nimport { pathToFileURL } from 'url';\n\nexport type RspackModule = typeof import('@rspack/core');\n\n// The bundler's escape hatch for the host's real `require`; undefined outside a bundle.\ndeclare const __non_webpack_require__: NodeRequire | undefined;\n\n// Node refuses require() of an ES module on versions before 22.12, or when the module\n// graph awaits at top level; both mean \"use import() instead\".\nconst REQUIRE_ESM_ERROR_CODES = ['ERR_REQUIRE_ESM', 'ERR_REQUIRE_ASYNC_MODULE'];\n\n// Inside a bundle `require` is the bundler's own and cannot see a layer-provided package;\n// Node's real require can, and honours NODE_PATH, which is how a lambda layer is found.\nconst getNodeRequire = (): NodeRequire => (typeof __non_webpack_require__ === 'function' ? __non_webpack_require__ : createRequire(__filename));\n\n// Built at run time so neither tsc (which rewrites a literal import() to require() in\n// CommonJS output) nor the bundler can turn it into a require.\nconst importByUrl = new Function('url', 'return import(url)') as (url: string) => Promise<RspackModule>;\n\nconst isRequireEsmError = (error: unknown): boolean => REQUIRE_ESM_ERROR_CODES.includes((error as { code?: string })?.code ?? '');\n\nconst requireOrImport = async (): Promise<RspackModule> => {\n  const nodeRequire = getNodeRequire();\n  const entry = nodeRequire.resolve('@rspack/core');\n\n  try {\n    return nodeRequire(entry) as RspackModule;\n  } catch (error) {\n    if (!isRequireEsmError(error)) throw error;\n    return importByUrl(pathToFileURL(entry).href);\n  }\n};\n\nlet loading: Promise<RspackModule> | undefined;\n\n/**\n * Loads @rspack/core, which ships as ES modules only, from CommonJS code that may be\n * bundled and running on a lambda with rspack on a layer: resolve the entry with Node's\n * require (NODE_PATH aware), require it where Node allows that, otherwise import it by\n * file URL. Loaded once per process.\n */\nexport const loadRspackModule = (): Promise<RspackModule> => {\n  if (!loading) {\n    loading = requireOrImport();\n  }\n  return loading;\n};\n"]}

package/lib/commonjs/build/resolveUserScriptEntry.d.ts

@@ -0,0 +1,2 @@
+/** The absolute entry path of a script project, or a NoEntry error naming what was looked for. */
+export declare const resolveUserScriptEntry: (projectDir: string) => string;

package/lib/commonjs/build/resolveUserScriptEntry.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveUserScriptEntry = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const USER_SCRIPT_ENTRY_CANDIDATES_1 = require("./USER_SCRIPT_ENTRY_CANDIDATES");
+const UserScriptBuildError_1 = require("./UserScriptBuildError");
+/** The absolute entry path of a script project, or a NoEntry error naming what was looked for. */
+const resolveUserScriptEntry = (projectDir) => {
+    const found = USER_SCRIPT_ENTRY_CANDIDATES_1.USER_SCRIPT_ENTRY_CANDIDATES.map((candidate) => path_1.default.join(projectDir, candidate)).find((candidate) => fs_1.default.existsSync(candidate));
+    if (!found) {
+        throw new UserScriptBuildError_1.UserScriptBuildError(UserScriptBuildError_1.UserScriptBuildErrorCode.NoEntry, `No script entry in [${projectDir}]: expected one of ${USER_SCRIPT_ENTRY_CANDIDATES_1.USER_SCRIPT_ENTRY_CANDIDATES.join(', ')}`);
+    }
+    return found;
+};
+exports.resolveUserScriptEntry = resolveUserScriptEntry;
+//# sourceMappingURL=resolveUserScriptEntry.js.map

package/lib/commonjs/build/resolveUserScriptEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveUserScriptEntry.js","sourceRoot":"","sources":["../../../src/build/resolveUserScriptEntry.ts"],"names":[],"mappings":";;;;;;AAAA,4CAAoB;AACpB,gDAAwB;AAExB,iFAA8E;AAC9E,iEAAwF;AAExF,kGAAkG;AAC3F,MAAM,sBAAsB,GAAG,CAAC,UAAkB,EAAU,EAAE;IACnE,MAAM,KAAK,GAAG,2DAA4B,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,cAAI,CAAC,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,YAAE,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC;IAE9I,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,2CAAoB,CAC5B,+CAAwB,CAAC,OAAO,EAChC,uBAAuB,UAAU,sBAAsB,2DAA4B,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACjG,CAAC;IACJ,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAXW,QAAA,sBAAsB,0BAWjC","sourcesContent":["import fs from 'fs';\nimport path from 'path';\n\nimport { USER_SCRIPT_ENTRY_CANDIDATES } from './USER_SCRIPT_ENTRY_CANDIDATES';\nimport { UserScriptBuildError, UserScriptBuildErrorCode } from './UserScriptBuildError';\n\n/** The absolute entry path of a script project, or a NoEntry error naming what was looked for. */\nexport const resolveUserScriptEntry = (projectDir: string): string => {\n  const found = USER_SCRIPT_ENTRY_CANDIDATES.map((candidate) => path.join(projectDir, candidate)).find((candidate) => fs.existsSync(candidate));\n\n  if (!found) {\n    throw new UserScriptBuildError(\n      UserScriptBuildErrorCode.NoEntry,\n      `No script entry in [${projectDir}]: expected one of ${USER_SCRIPT_ENTRY_CANDIDATES.join(', ')}`,\n    );\n  }\n\n  return found;\n};\n"]}

package/lib/commonjs/build/runUserScriptRspack.d.ts

@@ -0,0 +1,7 @@
+import type { Configuration } from '@rspack/core';
+/**
+ * One-shot rspack build as a promise; rejects on a compiler error or on stats errors.
+ * Kept here rather than imported from @qpqjs/deploy-rspack because this package is
+ * bundled into lambdas and must not pull that package's deploy-time dependencies in.
+ */
+export declare const runUserScriptRspack: (config: Configuration) => Promise<void>;

package/lib/commonjs/build/runUserScriptRspack.js

@@ -0,0 +1,32 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUserScriptRspack = void 0;
+const loadRspackModule_1 = require("./loadRspackModule");
+/**
+ * One-shot rspack build as a promise; rejects on a compiler error or on stats errors.
+ * Kept here rather than imported from @qpqjs/deploy-rspack because this package is
+ * bundled into lambdas and must not pull that package's deploy-time dependencies in.
+ */
+const runUserScriptRspack = (config) => __awaiter(void 0, void 0, void 0, function* () {
+    const { rspack } = yield (0, loadRspackModule_1.loadRspackModule)();
+    return new Promise((resolve, reject) => {
+        rspack(config, (error, stats) => {
+            if (error)
+                return reject(error);
+            if (stats === null || stats === void 0 ? void 0 : stats.hasErrors())
+                return reject(new Error(stats.toString({ errors: true, colors: false })));
+            return resolve();
+        });
+    });
+});
+exports.runUserScriptRspack = runUserScriptRspack;
+//# sourceMappingURL=runUserScriptRspack.js.map

package/lib/commonjs/build/runUserScriptRspack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runUserScriptRspack.js","sourceRoot":"","sources":["../../../src/build/runUserScriptRspack.ts"],"names":[],"mappings":";;;;;;;;;;;;AAEA,yDAAsD;AAEtD;;;;GAIG;AACI,MAAM,mBAAmB,GAAG,CAAO,MAAqB,EAAiB,EAAE;IAChF,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,IAAA,mCAAgB,GAAE,CAAC;IAE5C,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;YAC9B,IAAI,KAAK;gBAAE,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;YAChC,IAAI,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,SAAS,EAAE;gBAAE,OAAO,MAAM,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;YAClG,OAAO,OAAO,EAAE,CAAC;QACnB,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAA,CAAC;AAVW,QAAA,mBAAmB,uBAU9B","sourcesContent":["import type { Configuration } from '@rspack/core';\n\nimport { loadRspackModule } from './loadRspackModule';\n\n/**\n * One-shot rspack build as a promise; rejects on a compiler error or on stats errors.\n * Kept here rather than imported from @qpqjs/deploy-rspack because this package is\n * bundled into lambdas and must not pull that package's deploy-time dependencies in.\n */\nexport const runUserScriptRspack = async (config: Configuration): Promise<void> => {\n  const { rspack } = await loadRspackModule();\n\n  return new Promise((resolve, reject) => {\n    rspack(config, (error, stats) => {\n      if (error) return reject(error);\n      if (stats?.hasErrors()) return reject(new Error(stats.toString({ errors: true, colors: false })));\n      return resolve();\n    });\n  });\n};\n"]}

package/lib/commonjs/build/userScriptTsRule.d.ts

@@ -0,0 +1,6 @@
+import type { RuleSetRule } from '@rspack/core';
+/**
+ * TypeScript through rspack's builtin swc loader, no type check. The same options as a
+ * service build's rule, kept here so this package does not depend on deploy-rspack.
+ */
+export declare const userScriptTsRule: () => RuleSetRule;

package/lib/commonjs/build/userScriptTsRule.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userScriptTsRule = void 0;
+/**
+ * TypeScript through rspack's builtin swc loader, no type check. The same options as a
+ * service build's rule, kept here so this package does not depend on deploy-rspack.
+ */
+const userScriptTsRule = () => ({
+    test: /\.ts$/,
+    exclude: /node_modules/,
+    loader: 'builtin:swc-loader',
+    options: {
+        jsc: {
+            parser: { syntax: 'typescript', tsx: false, decorators: true },
+            transform: { legacyDecorator: true, decoratorMetadata: true },
+            target: 'es2021',
+        },
+    },
+});
+exports.userScriptTsRule = userScriptTsRule;
+//# sourceMappingURL=userScriptTsRule.js.map

package/lib/commonjs/build/userScriptTsRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"userScriptTsRule.js","sourceRoot":"","sources":["../../../src/build/userScriptTsRule.ts"],"names":[],"mappings":";;;AAEA;;;GAGG;AACI,MAAM,gBAAgB,GAAG,GAAgB,EAAE,CAAC,CAAC;IAClD,IAAI,EAAE,OAAO;IACb,OAAO,EAAE,cAAc;IACvB,MAAM,EAAE,oBAAoB;IAC5B,OAAO,EAAE;QACP,GAAG,EAAE;YACH,MAAM,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE;YAC9D,SAAS,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE;YAC7D,MAAM,EAAE,QAAQ;SACjB;KACF;CACF,CAAC,CAAC;AAXU,QAAA,gBAAgB,oBAW1B","sourcesContent":["import type { RuleSetRule } from '@rspack/core';\n\n/**\n * TypeScript through rspack's builtin swc loader, no type check. The same options as a\n * service build's rule, kept here so this package does not depend on deploy-rspack.\n */\nexport const userScriptTsRule = (): RuleSetRule => ({\n  test: /\\.ts$/,\n  exclude: /node_modules/,\n  loader: 'builtin:swc-loader',\n  options: {\n    jsc: {\n      parser: { syntax: 'typescript', tsx: false, decorators: true },\n      transform: { legacyDecorator: true, decoratorMetadata: true },\n      target: 'es2021',\n    },\n  },\n});\n"]}

package/lib/commonjs/config/USER_SCRIPT_BUILDER_LAYER_MODULES.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The packages the builder layer provides at run time. They stay external in the lambda
+ * bundle (rspack's binding is native and cannot be bundled) and resolve from the layer.
+ */
+export declare const USER_SCRIPT_BUILDER_LAYER_MODULES: readonly ["@rspack/core", "@rspack/binding"];

package/lib/commonjs/config/USER_SCRIPT_BUILDER_LAYER_MODULES.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USER_SCRIPT_BUILDER_LAYER_MODULES = void 0;
+/**
+ * The packages the builder layer provides at run time. They stay external in the lambda
+ * bundle (rspack's binding is native and cannot be bundled) and resolve from the layer.
+ */
+exports.USER_SCRIPT_BUILDER_LAYER_MODULES = ['@rspack/core', '@rspack/binding'];
+//# sourceMappingURL=USER_SCRIPT_BUILDER_LAYER_MODULES.js.map

package/lib/commonjs/config/USER_SCRIPT_BUILDER_LAYER_MODULES.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"USER_SCRIPT_BUILDER_LAYER_MODULES.js","sourceRoot":"","sources":["../../../src/config/USER_SCRIPT_BUILDER_LAYER_MODULES.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACU,QAAA,iCAAiC,GAAG,CAAC,cAAc,EAAE,iBAAiB,CAAU,CAAC","sourcesContent":["/**\n * The packages the builder layer provides at run time. They stay external in the lambda\n * bundle (rspack's binding is native and cannot be bundled) and resolve from the layer.\n */\nexport const USER_SCRIPT_BUILDER_LAYER_MODULES = ['@rspack/core', '@rspack/binding'] as const;\n"]}

package/lib/commonjs/config/USER_SCRIPT_BUILDER_LAYER_NAME.d.ts

@@ -0,0 +1,2 @@
+/** The lambda layer that carries rspack for services that build user scripts. */
+export declare const USER_SCRIPT_BUILDER_LAYER_NAME = "user-script-builder";

package/lib/commonjs/config/USER_SCRIPT_BUILDER_LAYER_NAME.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USER_SCRIPT_BUILDER_LAYER_NAME = void 0;
+/** The lambda layer that carries rspack for services that build user scripts. */
+exports.USER_SCRIPT_BUILDER_LAYER_NAME = 'user-script-builder';
+//# sourceMappingURL=USER_SCRIPT_BUILDER_LAYER_NAME.js.map

package/lib/commonjs/config/USER_SCRIPT_BUILDER_LAYER_NAME.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"USER_SCRIPT_BUILDER_LAYER_NAME.js","sourceRoot":"","sources":["../../../src/config/USER_SCRIPT_BUILDER_LAYER_NAME.ts"],"names":[],"mappings":";;;AAAA,iFAAiF;AACpE,QAAA,8BAA8B,GAAG,qBAAqB,CAAC","sourcesContent":["/** The lambda layer that carries rspack for services that build user scripts. */\nexport const USER_SCRIPT_BUILDER_LAYER_NAME = 'user-script-builder';\n"]}

package/lib/commonjs/config/defineUserScriptBuilder.d.ts

@@ -0,0 +1,7 @@
+import { ActionProcessorsQPQConfigSetting } from '@qpqjs/core';
+/**
+ * Registers the askUserScriptBuild processor on a service. Only services that call this
+ * can build user scripts, and only they load rspack; on lambda they also need the layer
+ * from getUserScriptBuilderApiLayer.
+ */
+export declare const defineUserScriptBuilder: () => ActionProcessorsQPQConfigSetting;

package/lib/commonjs/config/defineUserScriptBuilder.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineUserScriptBuilder = void 0;
+const core_1 = require("@qpqjs/core");
+/**
+ * Registers the askUserScriptBuild processor on a service. Only services that call this
+ * can build user scripts, and only they load rspack; on lambda they also need the layer
+ * from getUserScriptBuilderApiLayer.
+ */
+const defineUserScriptBuilder = () => (0, core_1.defineActionProcessors)({
+    basePath: __dirname,
+    relativePath: '../actionProcessor/getUserScriptBuildActionProcessors',
+    functionName: 'getUserScriptBuildActionProcessors',
+});
+exports.defineUserScriptBuilder = defineUserScriptBuilder;
+//# sourceMappingURL=defineUserScriptBuilder.js.map

package/lib/commonjs/config/defineUserScriptBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineUserScriptBuilder.js","sourceRoot":"","sources":["../../../src/config/defineUserScriptBuilder.ts"],"names":[],"mappings":";;;AAAA,sCAAuF;AAEvF;;;;GAIG;AACI,MAAM,uBAAuB,GAAG,GAAqC,EAAE,CAC5E,IAAA,6BAAsB,EAAC;IACrB,QAAQ,EAAE,SAAS;IACnB,YAAY,EAAE,uDAAuD;IACrE,YAAY,EAAE,oCAAoC;CACnD,CAAC,CAAC;AALQ,QAAA,uBAAuB,2BAK/B","sourcesContent":["import { ActionProcessorsQPQConfigSetting, defineActionProcessors } from '@qpqjs/core';\n\n/**\n * Registers the askUserScriptBuild processor on a service. Only services that call this\n * can build user scripts, and only they load rspack; on lambda they also need the layer\n * from getUserScriptBuilderApiLayer.\n */\nexport const defineUserScriptBuilder = (): ActionProcessorsQPQConfigSetting =>\n  defineActionProcessors({\n    basePath: __dirname,\n    relativePath: '../actionProcessor/getUserScriptBuildActionProcessors',\n    functionName: 'getUserScriptBuildActionProcessors',\n  });\n"]}

package/lib/commonjs/config/getUserScriptBuilderApiLayer.d.ts

@@ -0,0 +1,7 @@
+import { ApiLayer } from '@qpqjs/config-aws';
+/**
+ * The api layer entry that gives a service's lambdas rspack, for the service that
+ * registered defineUserScriptBuilder. Points at the directory `qpq script:builder-layer`
+ * produces, so the app's predeploy hook must run that command before a deploy.
+ */
+export declare const getUserScriptBuilderApiLayer: () => ApiLayer;

package/lib/commonjs/config/getUserScriptBuilderApiLayer.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserScriptBuilderApiLayer = void 0;
+const getUserScriptBuilderLayerDir_1 = require("./getUserScriptBuilderLayerDir");
+const USER_SCRIPT_BUILDER_LAYER_MODULES_1 = require("./USER_SCRIPT_BUILDER_LAYER_MODULES");
+const USER_SCRIPT_BUILDER_LAYER_NAME_1 = require("./USER_SCRIPT_BUILDER_LAYER_NAME");
+/**
+ * The api layer entry that gives a service's lambdas rspack, for the service that
+ * registered defineUserScriptBuilder. Points at the directory `qpq script:builder-layer`
+ * produces, so the app's predeploy hook must run that command before a deploy.
+ */
+const getUserScriptBuilderApiLayer = () => ({
+    name: USER_SCRIPT_BUILDER_LAYER_NAME_1.USER_SCRIPT_BUILDER_LAYER_NAME,
+    buildPath: (0, getUserScriptBuilderLayerDir_1.getUserScriptBuilderLayerDir)(),
+    modules: [...USER_SCRIPT_BUILDER_LAYER_MODULES_1.USER_SCRIPT_BUILDER_LAYER_MODULES],
+});
+exports.getUserScriptBuilderApiLayer = getUserScriptBuilderApiLayer;
+//# sourceMappingURL=getUserScriptBuilderApiLayer.js.map

package/lib/commonjs/config/getUserScriptBuilderApiLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getUserScriptBuilderApiLayer.js","sourceRoot":"","sources":["../../../src/config/getUserScriptBuilderApiLayer.ts"],"names":[],"mappings":";;;AAEA,iFAA8E;AAC9E,2FAAwF;AACxF,qFAAkF;AAElF;;;;GAIG;AACI,MAAM,4BAA4B,GAAG,GAAa,EAAE,CAAC,CAAC;IAC3D,IAAI,EAAE,+DAA8B;IACpC,SAAS,EAAE,IAAA,2DAA4B,GAAE;IACzC,OAAO,EAAE,CAAC,GAAG,qEAAiC,CAAC;CAChD,CAAC,CAAC;AAJU,QAAA,4BAA4B,gCAItC","sourcesContent":["import { ApiLayer } from '@qpqjs/config-aws';\n\nimport { getUserScriptBuilderLayerDir } from './getUserScriptBuilderLayerDir';\nimport { USER_SCRIPT_BUILDER_LAYER_MODULES } from './USER_SCRIPT_BUILDER_LAYER_MODULES';\nimport { USER_SCRIPT_BUILDER_LAYER_NAME } from './USER_SCRIPT_BUILDER_LAYER_NAME';\n\n/**\n * The api layer entry that gives a service's lambdas rspack, for the service that\n * registered defineUserScriptBuilder. Points at the directory `qpq script:builder-layer`\n * produces, so the app's predeploy hook must run that command before a deploy.\n */\nexport const getUserScriptBuilderApiLayer = (): ApiLayer => ({\n  name: USER_SCRIPT_BUILDER_LAYER_NAME,\n  buildPath: getUserScriptBuilderLayerDir(),\n  modules: [...USER_SCRIPT_BUILDER_LAYER_MODULES],\n});\n"]}

package/lib/commonjs/config/getUserScriptBuilderLayerDir.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The one directory the builder layer lives in: `<this package>/layer`. The api layer
+ * entry reads it and `qpq script:builder-layer` writes it, so neither side is told a
+ * path. Absolute, which is why the CDK resolves layer paths rather than joining them.
+ */
+export declare const getUserScriptBuilderLayerDir: () => string;