@atlassian/webresource-webpack-plugin 7.0.2 → 7.0.4-efd4a11

package/dist/shims/runtime-load-shim.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ Method signature is:
+ ```
+ var inProgress[url] = [done];
+ var dataWebpackPrefix = "...";
+ // loadScript function to load a script via script tag
+ __webpack_require__.l = (url, done, key) => {
+    ```
+ The variables are:
+ 'done' - callback function
+ 'key' - should be in the form "chunk-" + chunkId
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtimeLoadShim = (pluginKey, watchMode, publicPath) => {
+    const watchModeShim = watchMode
+        ? `
+function waitForScriptsLoaded(done) {
+   // scripts that are showing up in the performance stats are already loaded, not including scripts in the dom that still load
+   const loadedScriptsSrc = performance.getEntriesByType('resource')
+      .filter(r => r.initiatorType === 'script' && r.name.startsWith('${publicPath}'))
+      .map(r => r.name);
+   const domScripts = Array.from(document.querySelectorAll('script')).filter(s => s.src.startsWith('${publicPath}'));
+   const deltaScripts = domScripts.filter(s => !loadedScriptsSrc.includes(s.src));
+   const promises = deltaScripts.map(deltaScript => {
+      return new Promise(res => {
+         deltaScript.addEventListener('load', res);
+         deltaScript.addEventListener('error', res);
+         deltaScript.addEventListener('abort', res);
+      });
+   });
+   Promise.all(promises).then(done);
+}
+`
+        : '';
+    return `
+// the raw chunkId is used as a web-resource key.
+// webpack5's jsonp loader will call the load function with a prefixed chunkId.
+// see https://github.com/webpack/webpack/blob/master/lib/web/JsonpChunkLoadingRuntimeModule.js#L181
+const chunkId = (key || '').replace(/^chunk-/,'');
+// use WRM.require instead of webpack's url-based lookup.
+// since WRM.require can handle in-progress loads itself, we don't need to worry about
+// registering the 'done' callback in the inProgress array; we just call it after WRM does its thing.
+// ------
+// WATCHMODE - In watch mode a batch file is loaded that contains a script that loads the actual contents from a webpack dev server.
+// This means we cant execute the "done" callback for webpack before the second script is loaded.
+// The solution is to check for all scripts to the dev-server in "performance" as this will only contain already fully loaded scripts and
+// calculate the diff to all scripts in the body. Any script that is not showing up in "performance" will be listened to for a load event.
+// Only once all those load events are successfully returned do we call the "done" callback to webpack and prevent a range of errors that
+// would be triggered otherwise.
+${watchModeShim}
+WRM.require('wrc!${pluginKey}:' + chunkId).then(() => ${watchMode ? 'waitForScriptsLoaded(done)' : 'done()'}, (data) => {
+    var e = new Event('missing');
+    e.data = data;
+    done(e);
+});
+// we don't want the rest of the normal load function to run.
+return;
+`;
+};
+exports.default = runtimeLoadShim;
+//# sourceMappingURL=runtime-load-shim.js.map

package/dist/shims/runtime-load-shim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-load-shim.js","sourceRoot":"","sources":["../../src/shims/runtime-load-shim.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;AAEH,MAAM,eAAe,GAAG,CAAC,SAAiB,EAAE,SAAkB,EAAE,UAAkB,EAAE,EAAE;IACpF,MAAM,aAAa,GAAG,SAAS;QAC7B,CAAC,CAAC;;;;wEAIkE,UAAU;;sGAEoB,UAAU;;;;;;;;;;;CAW/G;QACG,CAAC,CAAC,EAAE,CAAC;IAEP,OAAO;;;;;;;;;;;;;;;EAeP,aAAa;mBACI,SAAS,4BACxB,SAAS,CAAC,CAAC,CAAC,4BAA4B,CAAC,CAAC,CAAC,QAC7C;;;;;;;CAOD,CAAC;AACF,CAAC,CAAC;AAEF,kBAAe,eAAe,CAAC"}

package/dist/types/extracted-webpack-types.d.ts

@@ -0,0 +1,12 @@
+import type { Compilation, Compiler } from 'webpack';
+import type { ArrayBaseType } from './types';
+export type Entrypoint = Compilation['entrypoints'] extends Map<string, infer U> ? U : never;
+export type PathData = Parameters<Compilation['getAssetPath']>[1];
+type NormalModuleFactory = Parameters<Parameters<InstanceType<typeof Compiler>['hooks']['normalModuleFactory']['tap']>[1]>[0];
+type FactorizeHandlerParameters = Parameters<Parameters<NormalModuleFactory['hooks']['factorize']['tapAsync']>[1]>;
+type FactorizeHandlerCallback = FactorizeHandlerParameters[1];
+type ResolveData = FactorizeHandlerParameters[0];
+export type ResolveDataHandler = (data: ResolveData, cb: FactorizeHandlerCallback) => void;
+export type FactoryHandler = (fn: ResolveDataHandler) => ResolveDataHandler;
+export type ChunkGroup = ArrayBaseType<Compilation['chunkGroups']>;
+export {};

package/dist/types/extracted-webpack-types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=extracted-webpack-types.js.map

package/dist/types/extracted-webpack-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extracted-webpack-types.js","sourceRoot":"","sources":["../../src/types/extracted-webpack-types.ts"],"names":[],"mappings":""}

package/dist/types/types.d.ts

@@ -0,0 +1,132 @@
+export type ArrayBaseType<T> = T extends Array<infer U> ? U : never;
+export type Callable = (...args: any[]) => any;
+export type ObjectOrMap = Record<string, unknown> | Map<string, unknown>;
+export type ConditionParam = {
+    attributes?: {
+        [key: string]: string;
+    };
+    value?: string;
+};
+export type ConditionClass = {
+    class: string;
+    invert?: boolean;
+    params?: ConditionParam[];
+};
+export type Conditions = {
+    type: string;
+    conditions: Array<Conditions | ConditionClass>;
+};
+export type Condition = Conditions | ConditionClass | Array<Conditions | Condition>;
+export type DeprecationInfo = {
+    sinceVersion?: string;
+    removeInVersion?: string;
+    alternative?: string;
+    extraInfo?: string;
+} | true;
+export type ProvidedDependency = {
+    dependency: string;
+    import: {
+        var: string;
+        amd?: string;
+    } | string;
+};
+export type DataProvider = {
+    key: string;
+    class: string;
+};
+export type ResourceParam = {
+    name: string;
+    value: string;
+};
+export type WebresourceObject = {
+    key?: string;
+    name?: string;
+    state?: string | boolean;
+};
+export type WebresourceType = string | WebresourceObject;
+type MapOrObject<T> = Map<string, T> | {
+    [key: string]: T;
+};
+export type ContextMap = Map<string, string[]>;
+export type TransformationMap = Map<string, string[]>;
+export type ProvidedDependenciesMap = Map<string, ProvidedDependency>;
+export type ConditionsMap = Map<string, Condition>;
+export type DataProvidersMap = Map<string, DataProvider[]>;
+export type DeprecationMap = Map<string, DeprecationInfo>;
+export type ResourceParamMap = Map<string, ResourceParam[]>;
+export type WebresourceMap = Map<string, WebresourceType>;
+export type Options = {
+    /** @property pluginKey - The fully qualified plugin key. e.g.: com.atlassian.jira.plugins.my-jira-plugin */
+    pluginKey: string;
+    /** @property xmlDescriptors - Path to the directory where this plugin stores the descriptors about this plugin, used by the WRM to load your frontend code. */
+    xmlDescriptors: string;
+    /** @property packageName - Name of frontend package to associate all output JS files with. */
+    packageName?: string;
+    /** @property devAssetsHash - Custom hash used in development environment resources name. */
+    devAssetsHash?: string;
+    /** @property locationPrefix - Specify the sub-directory for all web-resource location values. */
+    locationPrefix?: string;
+    /** @property wrmManifestPath - Path to the WRM manifest file where this plugin stores the mapping of modules to generated web-resources. e.g.: `{"my-entry": "com.example.app:entrypoint-my-entry"}`. Useful if you set { output: { library, libraryTarget } } in your webpack config, to use your build result as provided dependencies for other builds. */
+    wrmManifestPath?: string;
+    /** @property singleRuntimeWebResourceKey - Ensure all web-resources depend on a single runtime shared amongst them */
+    singleRuntimeWebResourceKey?: string;
+    /** @property conditionMap - Conditions to be applied to the specified entry-point */
+    conditionMap?: MapOrObject<Condition>;
+    /** @property contextMap - One or more "context"s to which an entrypoint will be added. e.g.: `{"my-entry": ["my-plugin-context", "another-context"]}` */
+    contextMap?: MapOrObject<string[]>;
+    /** @property dataProvidersMap - A list of data providers that will be added to the entry point e.g.: `{"my-entry": [{ key: "data-provider-key", class: "my.data.provider.JavaClass" }]}` */
+    dataProvidersMap?: MapOrObject<DataProvider[]>;
+    /** @property deprecatedEntrypoints - Map of entrypoints that are deprecated to more detailed information about the deprecation including the affected versions, alternatives and reason. e.g.: `{"outdated-entrypoint": { sinceVersion: "2.0.0", removeInVersion: "3.0.0", alternative: "rewritten-endpoint", extraInfo: "outdated-endpoint does not support dark mode" }}` */
+    deprecatedEntrypoints?: MapOrObject<DeprecationInfo>;
+    /** @property providedDependencies - Map of ES6/AMD module identifiers to their related WRM module keys and JavaScript import values (read: webpack external dependency definition). If this module identifier is imported or required somewhere in the compiled code, it will not be bundled, but instead replaced with the specified external dependency placeholder. */
+    providedDependencies?: MapOrObject<ProvidedDependency>;
+    /** @property resourceParamMap - Parameters to be added to specific file types. */
+    resourceParamMap?: MapOrObject<ResourceParam[]>;
+    /** @property transformationMap - Transformations to be applied to the specified file-types. */
+    transformationMap?: MapOrObject<string[]> | false;
+    /** @property webresourceKeyMap - An explicit name for the web-resource generated per entry point. e.g.: `{"my-entry": "legacy-webresource-name"}`. */
+    webresourceKeyMap?: MapOrObject<WebresourceType>;
+    /** @property addAsyncNameAsContext - Adds the name of the async chunk as a context prefixed by `async-chunk-`. Will only do so if a webpackChunkName is set. */
+    addAsyncNameAsContext?: boolean;
+    /** @property addEntrypointNameAsContext - Guarantees each entrypoint will be given a context matching its name. Use with caution; this can adversely affect page weight and may conflict with other plugins and feature code. */
+    addEntrypointNameAsContext?: boolean;
+    /** @property noWRM - Do not add any WRM specifics to the webpack runtime to allow development on a greenfield. */
+    noWRM?: boolean;
+    /** @property useDocumentWriteInWatchMode - Use document.write when possible in "watch-mode" to ensure scripts are loaded "blocking" as they would be in a production environment */
+    useDocumentWriteInWatchMode?: boolean;
+    /** @property verbose - Indicate if log output should be verbose. */
+    verbose?: boolean;
+    /** @property watch - Trigger watch mode - this requires webpack-dev-server and will redirect requests to the entrypoints to the dev-server that must be running under webpack's `options.output.publicPath`. */
+    watch?: boolean;
+    /** @property watchPrepare - In conjunction with watch mode - indicates that only "redirects" to a webserver should be build in this run. */
+    watchPrepare?: boolean;
+};
+export type ConsolidatedOptions = Options & Required<Omit<Options, 'wrmManifestPath' | 'singleRuntimeWebResourceKey' | 'packageName'>> & {
+    conditionMap: ConditionsMap;
+    contextMap: ContextMap;
+    dataProvidersMap: DataProvidersMap;
+    deprecatedEntrypoints: DeprecationMap;
+    providedDependencies: ProvidedDependenciesMap;
+    resourceParamMap: ResourceParamMap;
+    transformationMap: TransformationMap;
+    webresourceKeyMap: WebresourceMap;
+};
+export type WrmResource = {
+    name: string;
+    location: string;
+};
+export type ChunkResourceDescriptor = {
+    attributes: {
+        key: string;
+        moduleId?: string;
+    };
+    resources: string[];
+    dependencies?: string[];
+    deprecationInfo?: DeprecationInfo;
+    contexts?: string[];
+    conditions?: Condition;
+    dataProviders?: DataProvider[];
+    externalResources?: WrmResource[];
+};
+export type AssetNames = Map<string, string>;
+export {};

package/dist/types/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/types/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types/types.ts"],"names":[],"mappings":""}

package/dist/webpack-modules/EmptyExportsModule.d.ts

@@ -0,0 +1,14 @@
+import type { sources } from 'webpack';
+import DllModule from 'webpack/lib/DllModule';
+/**
+ * This module type allows inclusion of special dependencies in the webpack compilation process
+ * that ultimately output nothing in the compiled bundles.
+ *
+ * This is of use when including certain file types with no associated loader in the compilation process,
+ * as is the case with things like Atlassian Soy templates.
+ */
+export default class EmptyExportsModule extends DllModule {
+    constructor(dependency: string, type: string);
+    chunkCondition(): boolean;
+    source(): sources.RawSource;
+}

package/dist/webpack-modules/EmptyExportsModule.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const DllModule_1 = __importDefault(require("webpack/lib/DllModule"));
+const webpack_sources_1 = require("webpack-sources");
+/**
+ * This module type allows inclusion of special dependencies in the webpack compilation process
+ * that ultimately output nothing in the compiled bundles.
+ *
+ * This is of use when including certain file types with no associated loader in the compilation process,
+ * as is the case with things like Atlassian Soy templates.
+ */
+class EmptyExportsModule extends DllModule_1.default {
+    constructor(dependency, type) {
+        super(null, [], dependency, type);
+    }
+    chunkCondition() {
+        return true;
+    }
+    source() {
+        // eslint-disable-next-line prettier/prettier
+        return new webpack_sources_1.RawSource('module.exports = undefined;');
+    }
+}
+exports.default = EmptyExportsModule;
+//# sourceMappingURL=EmptyExportsModule.js.map

package/dist/webpack-modules/EmptyExportsModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmptyExportsModule.js","sourceRoot":"","sources":["../../src/webpack-modules/EmptyExportsModule.ts"],"names":[],"mappings":";;;;;AACA,sEAA8C;AAC9C,qDAA4C;AAE5C;;;;;;GAMG;AACH,MAAqB,kBAAmB,SAAQ,mBAAS;IACvD,YAAY,UAAkB,EAAE,IAAY;QAC1C,KAAK,CAAC,IAAI,EAAE,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;IACpC,CAAC;IAED,cAAc;QACZ,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM;QACJ,6CAA6C;QAC7C,OAAO,IAAI,2BAAS,CAAC,6BAA6B,CAAiC,CAAC;IACtF,CAAC;CACF;AAbD,qCAaC"}

package/dist/webpack-modules/ProvidedExternalDependencyModule.d.ts

@@ -0,0 +1,20 @@
+import ExternalModule from 'webpack/lib/ExternalModule';
+import type { ProvidedDependency } from '../types/types';
+/**
+ * ProvidedExternalModule ensures that the `chunkCondition` is true to allow proper asyncChunk context handling
+ * ExternalModules can be defined in different ways. Some of them require the external module to be loaded in the entry point.
+ * This is generally not bad as it doesnt cost anything. However the WRM Plugin relies on ExternalModules to specify provided dependencies.
+ * These provided dependencies are then added to the context of the chunk in which they occur. Async chunks should therefore
+ * have their own dependencies to make the entrypoint as small as possible.
+ * ProvidedExternalModule ensures that.
+ */
+export default class ProvidedExternalDependencyModule extends ExternalModule {
+    private _wrmDependency;
+    private _request;
+    private _target;
+    constructor(request: ProvidedDependency['import'], dependency: string, target: 'var' | 'amd');
+    libIdent(): string;
+    chunkCondition(): boolean;
+    getDependency(): string;
+    getConcatenationBailoutReason(): string;
+}

package/dist/webpack-modules/ProvidedExternalDependencyModule.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ExternalModule_1 = __importDefault(require("webpack/lib/ExternalModule"));
+/**
+ * ProvidedExternalModule ensures that the `chunkCondition` is true to allow proper asyncChunk context handling
+ * ExternalModules can be defined in different ways. Some of them require the external module to be loaded in the entry point.
+ * This is generally not bad as it doesnt cost anything. However the WRM Plugin relies on ExternalModules to specify provided dependencies.
+ * These provided dependencies are then added to the context of the chunk in which they occur. Async chunks should therefore
+ * have their own dependencies to make the entrypoint as small as possible.
+ * ProvidedExternalModule ensures that.
+ */
+class ProvidedExternalDependencyModule extends ExternalModule_1.default {
+    constructor(request, dependency, target) {
+        super(request, target);
+        this._request = request;
+        this._wrmDependency = dependency;
+        this._target = target;
+    }
+    libIdent() {
+        return `${this._wrmDependency}/${typeof this._request === 'string' ? this._request : this._request[this._target]}`;
+    }
+    chunkCondition() {
+        return true;
+    }
+    getDependency() {
+        return this._wrmDependency;
+    }
+    getConcatenationBailoutReason() {
+        return `Provided external dependencies can't be concatenated`;
+    }
+}
+exports.default = ProvidedExternalDependencyModule;
+//# sourceMappingURL=ProvidedExternalDependencyModule.js.map

package/dist/webpack-modules/ProvidedExternalDependencyModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProvidedExternalDependencyModule.js","sourceRoot":"","sources":["../../src/webpack-modules/ProvidedExternalDependencyModule.ts"],"names":[],"mappings":";;;;;AAAA,gFAAwD;AAIxD;;;;;;;GAOG;AACH,MAAqB,gCAAiC,SAAQ,wBAAc;IAK1E,YAAY,OAAqC,EAAE,UAAkB,EAAE,MAAqB;QAC1F,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC;QACjC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IACxB,CAAC;IAED,QAAQ;QACN,OAAO,GAAG,IAAI,CAAC,cAAc,IAAI,OAAO,IAAI,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;IACrH,CAAC;IAED,cAAc;QACZ,OAAO,IAAI,CAAC;IACd,CAAC;IAED,aAAa;QACX,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAED,6BAA6B;QAC3B,OAAO,sDAAsD,CAAC;IAChE,CAAC;CACF;AA3BD,mDA2BC"}

package/dist/webpack-modules/WrmDependencyModule.d.ts

@@ -0,0 +1,6 @@
+import EmptyExportsModule from './EmptyExportsModule';
+export default class WrmDependencyModule extends EmptyExportsModule {
+    private _wrmDependency;
+    constructor(dependency: string, type: string, pluginKey: string);
+    getDependency(): string;
+}

package/dist/webpack-modules/WrmDependencyModule.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 });
+const EmptyExportsModule_1 = __importDefault(require("./EmptyExportsModule"));
+class WrmDependencyModule extends EmptyExportsModule_1.default {
+    constructor(dependency, type, pluginKey) {
+        super(dependency, type);
+        this._wrmDependency = dependency.includes(':') ? dependency : `${pluginKey}:${dependency}`;
+    }
+    getDependency() {
+        return this._wrmDependency;
+    }
+}
+exports.default = WrmDependencyModule;
+//# sourceMappingURL=WrmDependencyModule.js.map

package/dist/webpack-modules/WrmDependencyModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WrmDependencyModule.js","sourceRoot":"","sources":["../../src/webpack-modules/WrmDependencyModule.ts"],"names":[],"mappings":";;;;;AAAA,8EAAsD;AAEtD,MAAqB,mBAAoB,SAAQ,4BAAkB;IAGjE,YAAY,UAAkB,EAAE,IAAY,EAAE,SAAiB;QAC7D,KAAK,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;QACxB,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,IAAI,UAAU,EAAE,CAAC;IAC7F,CAAC;IAED,aAAa;QACX,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;CACF;AAXD,sCAWC"}

package/dist/webpack-modules/WrmResourceModule.d.ts

@@ -0,0 +1,10 @@
+import EmptyExportsModule from './EmptyExportsModule';
+export default class WrmResourceModule extends EmptyExportsModule {
+    private _resource;
+    constructor(resourceNameAndLocationPair: string, target: string, requestContext: string, rootContext: string);
+    getResourcePair(): [string, string];
+    getResource(): {
+        name: string;
+        location: string;
+    };
+}

package/dist/webpack-modules/WrmResourceModule.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const EmptyExportsModule_1 = __importDefault(require("./EmptyExportsModule"));
+class WrmResourceModule extends EmptyExportsModule_1.default {
+    constructor(resourceNameAndLocationPair, target, requestContext, rootContext) {
+        super(resourceNameAndLocationPair, target);
+        const resourcePair = resourceNameAndLocationPair.split('!');
+        let resPath = resourcePair[1];
+        // enable relative resource-paths. Still requires that this resource is correctly copied to the right location in target.
+        if (resPath.startsWith('./') || resPath.startsWith('../')) {
+            const fullResourcePath = path_1.default.join(requestContext, resPath);
+            resPath = path_1.default.relative(rootContext, fullResourcePath);
+        }
+        this._resource = [resourcePair[0], resPath];
+    }
+    getResourcePair() {
+        return this._resource;
+    }
+    getResource() {
+        const [name, location] = this._resource;
+        return { name, location };
+    }
+}
+exports.default = WrmResourceModule;
+//# sourceMappingURL=WrmResourceModule.js.map

package/dist/webpack-modules/WrmResourceModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WrmResourceModule.js","sourceRoot":"","sources":["../../src/webpack-modules/WrmResourceModule.ts"],"names":[],"mappings":";;;;;AAAA,gDAAwB;AAExB,8EAAsD;AAEtD,MAAqB,iBAAkB,SAAQ,4BAAkB;IAG/D,YAAY,2BAAmC,EAAE,MAAc,EAAE,cAAsB,EAAE,WAAmB;QAC1G,KAAK,CAAC,2BAA2B,EAAE,MAAM,CAAC,CAAC;QAC3C,MAAM,YAAY,GAAG,2BAA2B,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC5D,IAAI,OAAO,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;QAE9B,yHAAyH;QACzH,IAAI,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1D,MAAM,gBAAgB,GAAG,cAAI,CAAC,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;YAC5D,OAAO,GAAG,cAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC;QACzD,CAAC;QAED,IAAI,CAAC,SAAS,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAC9C,CAAC;IAED,eAAe;QACb,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,WAAW;QACT,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC;QACxC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;IAC5B,CAAC;CACF;AAzBD,oCAyBC"}

package/jest.config.js

@@ -1,8 +1,23 @@
 const pkg = require('./package.json');
 const baseConfig = require('../../jest.config.js');
 
+/**
+ * @type {import('jest').Config}
+ */
 module.exports = {
   ...baseConfig,
-  projects: ['.'],
+  projects: [
+    {
+      preset: 'ts-jest',
+      displayName: 'webpack',
+      transform: baseConfig.transform,
+    },
+    {
+      preset: 'ts-jest',
+      displayName: 'rspack',
+      transform: baseConfig.transform,
+      setupFilesAfterEnv: ['./test/util/setup-rspack.ts'],
+    },
+  ],
   displayName: pkg.name,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlassian/webresource-webpack-plugin",
-  "version": "7.0.2",
+  "version": "7.0.4-efd4a11",
   "description": "Auto-generates web-resource definitions from your webpacked code, for usage in an Atlassian product or plugin.",
   "main": "dist/WrmPlugin.js",
   "types": "dist/WrmPlugin.d.ts",
@@ -60,7 +60,7 @@
   "dependencies": {
     "lodash": "4.17.21",
     "pretty-data": "0.40.0",
-    "tapable": "2.2.1",
+    "tapable": "2.2.2",
     "url-join": "4.0.1",
     "uuid": "8.3.2"
   },
@@ -69,29 +69,30 @@
     "webpack-sources": "^1 || ^2"
   },
   "devDependencies": {
+    "@rspack/core": "^1.4.11",
     "@types/glob": "7.2.0",
-    "@types/lodash": "4.14.177",
-    "@types/node": "16.11.11",
+    "@types/lodash": "4.14.202",
+    "@types/node": "22.17.2",
     "@types/pretty-data": "0.40.3",
-    "@types/url-join": "4.0.1",
-    "@types/uuid": "8.3.3",
-    "@types/webpack-sources": "3.2.0",
-    "@types/xml-parser": "1.2.30",
+    "@types/url-join": "4.0.3",
+    "@types/uuid": "8.3.4",
+    "@types/webpack-sources": "3.2.3",
+    "@types/xml-parser": "1.2.33",
     "css-loader": "5.2.7",
-    "del": "6.0.0",
-    "esbuild": "0.14.1",
-    "esbuild-register": "3.2.0",
+    "del": "6.1.1",
+    "esbuild": "0.25.9",
+    "esbuild-register": "3.6.0",
     "file-loader": "6.2.0",
-    "glob": "7.2.0",
-    "jest": "27.4.3",
+    "glob": "7.2.3",
+    "jest": "29.7.0",
     "jquery": "3.6.0",
     "mini-css-extract-plugin": "2.8.1",
     "style-loader": "2.0.0",
     "ts-node": "10.4.0",
-    "typescript": "4.5.2",
-    "underscore": "1.13.1",
+    "typescript": "5.9.2",
+    "underscore": "1.13.7",
     "webpack": "5.90.3",
-    "webpack-cli": "4.9.1",
+    "webpack-cli": "4.9.2",
     "webpack-sources": "2.3.1",
     "xml-parser": "1.2.1"
   },
@@ -114,7 +115,9 @@
     "build": "tsc -p tsconfig.json",
     "verify": "tsc -p tsconfig.json --noEmit",
     "test": "jest",
+    "test:webpack": "jest --selectProjects=webpack",
+    "test:rspack": "jest --selectProjects=rspack",
     "test:watch": "jest --watch"
   },
-  "gitHead": "622a7f318cc99f3760df5c1c90a5598b202526fd"
+  "gitHead": "fa43ff58de567f17ff53662043552e231a773c6d"
 }