@atlassian/webresource-webpack-plugin 4.10.2-64a2ef2

package/src/defaults/builtInProvidedDependencies.js

@@ -0,0 +1,22 @@
+const { buildProvidedDependency } = require('../helpers/provided-dependencies');
+
+const webresourcePluginName = 'com.atlassian.plugins.atlassian-plugins-webresource-plugin';
+const webresourceDep = buildProvidedDependency.bind(undefined, webresourcePluginName);
+
+const builtInProvidedDependencies = new Map()
+    .set(
+        'wrm/require',
+        buildProvidedDependency(
+            'com.atlassian.plugins.atlassian-plugins-webresource-rest',
+            'web-resource-manager',
+            'WRM.require',
+            'wrm/require'
+        )
+    )
+    .set('wrm/context-path', webresourceDep('context-path', 'WRM.contextPath', 'wrm/context-path'))
+    .set('wrm/data', webresourceDep('data', 'WRM.data', 'wrm/data'))
+    .set('wrm/format', webresourceDep('format', 'WRM.format', 'wrm/format'));
+
+module.exports = {
+    builtInProvidedDependencies,
+};

package/src/flattenReduce.js

@@ -0,0 +1 @@
+module.exports = (a, b) => a.concat(b);

package/src/helpers/options-parser.js

@@ -0,0 +1,32 @@
+const path = require('path');
+
+const pathSeparatorRegex = new RegExp(`^\\${path.sep}|\\${path.sep}$`, 'g');
+
+/**
+ * Converts an object in to a Map.
+ * @param {Object} original
+ * @returns {Map} a map with key-value pairs from the object.
+ * returns an empty map if the original value was falsy or not an object.
+ */
+function toMap(original) {
+    if (original instanceof Map) {
+        return original;
+    }
+    return original && typeof original === 'object' ? new Map(Object.entries(original)) : new Map();
+}
+
+function extractPathPrefixForXml(pathPrefix) {
+    if (!pathPrefix || pathPrefix === '' || pathPrefix === '/') {
+        return '';
+    }
+
+    // remove leading/trailing path separator
+    const withoutLeadingTrailingSeparators = pathPrefix.replace(pathSeparatorRegex, '');
+    // readd trailing slash - this time OS independent always a "/"
+    return withoutLeadingTrailingSeparators + '/';
+}
+
+module.exports = {
+    toMap,
+    extractPathPrefixForXml,
+};

package/src/helpers/provided-dependencies.js

@@ -0,0 +1,21 @@
+/**
+ *
+ * @param {String} pluginKey
+ * @param {String} resourceKey
+ * @param {String} importVar
+ * @param {String} importAmd
+ * @return {{dependency: string, import: {var: *, amd: *}}}
+ */
+function buildProvidedDependency(pluginKey, resourceKey, importVar, importAmd) {
+    return {
+        dependency: `${pluginKey}:${resourceKey}`,
+        import: {
+            var: importVar,
+            amd: importAmd,
+        },
+    };
+}
+
+module.exports = {
+    buildProvidedDependency,
+};

package/src/helpers/string.js

@@ -0,0 +1,12 @@
+/**
+ * @param {*} val - the initial value of varying type
+ * @returns {string} a trimmed string value
+ */
+function parseString(val) {
+    let maybeStr = val && val.length ? String(val) : '';
+    return maybeStr.trim();
+}
+
+module.exports = {
+    parseString,
+};

package/src/helpers/web-resource-entrypoints.js

@@ -0,0 +1,66 @@
+const { parseWebResourceAttributes } = require('./web-resource-parser');
+
+/**
+ * @param {String} entry
+ * @param {Map<String, Array<String>>} contextMap
+ * @param {Boolean} addEntrypointNameAsContext
+ * @returns {Array<String>}
+ */
+function getContextForEntry(entry, contextMap, addEntrypointNameAsContext) {
+    const contexts = [].concat(contextMap.get(entry));
+    if (addEntrypointNameAsContext) {
+        contexts.unshift(entry);
+    }
+    return contexts.filter(context => context && typeof context === 'string');
+}
+
+/**
+ * @param {String} entry
+ * @param {Map<String, String>} webresourceKeyMap
+ * @returns {WebResourceAttributes}
+ */
+function getWebresourceAttributesForEntry(entry, webresourceKeyMap) {
+    const wrKey = webresourceKeyMap.get(entry);
+
+    // Create the default attribute values
+    let attrs = { key: `entrypoint-${entry}`, moduleId: entry };
+
+    // Extend the attributes with parsed, valid values
+    if (typeof wrKey === 'object') {
+        attrs = Object.assign(attrs, parseWebResourceAttributes(wrKey));
+    }
+
+    // Override the key if a non-empty string is provided
+    if (typeof wrKey === 'string') {
+        attrs = Object.assign(attrs, parseWebResourceAttributes({ key: wrKey }));
+    }
+
+    return attrs;
+}
+
+/**
+ * @param {String} entry
+ * @param {Map<String, Object>} conditionMap
+ * @returns {*}
+ */
+function getConditionForEntry(entry, conditionMap) {
+    return conditionMap.get(entry);
+}
+
+/**
+ * Retrieves the list of data providers for given entrypoint
+ *
+ * @param {String} entrypoint - webpack entrypoint key
+ * @param {Map<String, DataProvider[]>} dataProvidersMap - All data providers from plugin options
+ * @return {DataProvider[]} - List of data providers for given entry point
+ */
+function getDataProvidersForEntry(entrypoint, dataProvidersMap) {
+    return dataProvidersMap.get(entrypoint) || [];
+}
+
+module.exports = {
+    getContextForEntry,
+    getConditionForEntry,
+    getWebresourceAttributesForEntry,
+    getDataProvidersForEntry,
+};

package/src/helpers/web-resource-generator.js

@@ -0,0 +1,138 @@
+const path = require('path');
+const { renderElement } = require('./xml');
+const { parseWebResourceAttributes } = require('./web-resource-parser');
+const renderCondition = require('../renderCondition');
+const renderTransformation = require('../renderTransformation');
+
+/**
+ * Renders list of data providers {@see DataProvider} as <data key="provider-key" class="data.provider.Class" /> elements
+ *
+ * @param {DataProvider[]} dataProviders
+ * @return {string[]}
+ */
+const renderDataProviders = dataProviders => {
+    if (!Array.isArray(dataProviders) || !dataProviders.length < 0) {
+        return [];
+    }
+
+    return dataProviders.map(dataProvider =>
+        renderElement('data', {
+            key: dataProvider.key,
+            class: dataProvider.class,
+        })
+    );
+};
+
+function generateContext(contexts) {
+    return contexts ? contexts.map(context => `<context>${context}</context>`).join('') : '';
+}
+
+function generateDependencies(dependencies) {
+    return dependencies ? dependencies.map(dependency => `<dependency>${dependency}</dependency>`).join('\n') : '';
+}
+
+/**
+ * @param {Resource} resource
+ * @param {Map<String, Array<Object>>} parameterMap
+ * @returns {string} an XML representation of a {@link Resource}.
+ */
+function generateResourceElement(resource, parameterMap) {
+    const { name, location } = resource;
+    const assetContentType = path.extname(location).substr(1);
+    const parameters = parameterMap.get(assetContentType) || [];
+    const children = [];
+    const renderParameters = attributes => children.push(renderElement('param', attributes));
+    parameters.forEach(renderParameters);
+
+    return renderElement(
+        'resource',
+        {
+            type: 'download',
+            name,
+            location,
+        },
+        children
+    );
+}
+
+/**
+ * Generates a <resource> descriptor that will glue the source code for a file to the qunit test runner.
+ * @param {filepath} filepath
+ * @returns {string} an XML representation of a {@link Resource}.
+ */
+function generateQunitResourceElement(filepath) {
+    return renderElement('resource', { type: 'qunit', name: filepath, location: filepath });
+}
+
+/**
+ * @param {Map<String, Array<Object>>} parameterMap
+ * @param {Resource[]} resources
+ * @returns {string} an XML string of all {@link Resource} elements
+ */
+function generateResources(parameterMap, resources) {
+    return resources
+        .filter(r => !!r)
+        .map(resource => generateResourceElement(resource, parameterMap))
+        .join('\n');
+}
+
+/**
+ * @param {WrmEntrypoint} webresource
+ * @param {Map<String, Array<String>>} transformations
+ * @param {String} pathPrefix
+ * @param {Map<String, Array<Object>>} parameterMap
+ * @param standalone
+ * @returns {string} an XML representation of the {@link WrmEntrypoint}.
+ */
+function createWebResource(webresource, transformations, pathPrefix = '', parameterMap = new Map(), standalone) {
+    const { resources = [], externalResources = [], contexts, dependencies, conditions, dataProviders } = webresource;
+    const attributes = parseWebResourceAttributes(webresource.attributes);
+    const allResources = [];
+    const children = [];
+
+    /** convert filepaths in to {@link Resource}s. */
+    const convertFilePaths = location => pathPrefix + location;
+
+    // add resources for direct dependencies (e.g., JS and CSS files)
+    allResources.push(...resources.map(res => ({ name: res, location: convertFilePaths(res) })));
+
+    if (standalone) {
+        children.push(generateResources(parameterMap, allResources));
+    } else {
+        // add resources for indirect dependencies (e.g., images extracted from CSS)
+        allResources.push(...externalResources.map(wr => ({ name: wr.name, location: convertFilePaths(wr.location) })));
+
+        children.push(
+            renderTransformation(transformations, allResources),
+            generateContext(contexts),
+            generateDependencies(dependencies),
+            generateResources(parameterMap, allResources),
+            renderCondition(conditions),
+            ...renderDataProviders(dataProviders)
+        );
+    }
+
+    return renderElement('web-resource', attributes, children);
+}
+
+function createResourceDescriptors(jsonDescriptors, transformations, pathPrefix, parameterMap, standalone) {
+    const descriptors = jsonDescriptors.map(descriptor =>
+        createWebResource(descriptor, transformations, pathPrefix, parameterMap, standalone)
+    );
+    return descriptors.join('');
+}
+
+function createTestResourceDescriptors(jsonTestDescriptors, transformations) {
+    const testDescriptors = jsonTestDescriptors.map(descriptor => createWebResource(descriptor, transformations));
+    return testDescriptors.join('');
+}
+
+function createQUnitResourceDescriptors(qUnitTestFiles) {
+    return qUnitTestFiles.map(generateQunitResourceElement).join('');
+}
+
+module.exports = {
+    createResourceDescriptors,
+    createTestResourceDescriptors,
+    createQUnitResourceDescriptors,
+};

package/src/helpers/web-resource-parser.js

@@ -0,0 +1,44 @@
+const { parseString } = require('./string');
+
+/**
+ * @param {Object} data - key value pairs of potentially invalid metadata for a web-resource.
+ * @returns {WebResourceAttributes} a valid set of metadata for a web-resource.
+ */
+function parseWebResourceAttributes(data = {}) {
+    const attributes = {};
+    // Only parse objects.
+    if (data && data.hasOwnProperty) {
+        // define the key if a non-empty string was provided
+        if (data.hasOwnProperty('key')) {
+            let customKey = parseString(data.key);
+            if (customKey) {
+                attributes.key = customKey;
+            }
+        }
+
+        // define the state as either enabled or disabled
+        if (data.hasOwnProperty('state')) {
+            let isEnabled = true;
+            if (typeof data.state === 'boolean') {
+                isEnabled = data.state;
+            } else if (typeof data.state === 'string') {
+                isEnabled = !(data.state === 'disabled');
+            }
+            attributes.state = isEnabled ? 'enabled' : 'disabled';
+        }
+
+        // define the name if a non-empty string was provided
+        if (data.hasOwnProperty('name')) {
+            let customName = parseString(data.name);
+            if (customName) {
+                attributes.name = customName;
+            }
+        }
+    }
+
+    return attributes;
+}
+
+module.exports = {
+    parseWebResourceAttributes,
+};

package/src/helpers/xml.js

@@ -0,0 +1,44 @@
+/**
+ * @param {Object} attributes
+ * @returns {string}
+ */
+function stringifyAttributes(attributes) {
+    if (!attributes) {
+        return '';
+    }
+
+    return (
+        ' ' +
+        Object.keys(attributes)
+            .map(key => {
+                const val = typeof attributes[key] === 'undefined' ? '' : String(attributes[key]);
+                return `${key}="${val}"`;
+            })
+            .join(' ')
+    );
+}
+
+function renderElement(name, attributes, children) {
+    if (typeof attributes === 'object') {
+        attributes = stringifyAttributes(attributes);
+    }
+    // avoid outputting 'undefined' when attributes aren't present.
+    if (!attributes) {
+        attributes = '';
+    }
+    // convert children array in to a string.
+    // assume they are string values already. (todo: refactor for nested rendering?)
+    if (Array.isArray(children)) {
+        children = children.join('\n');
+    }
+    // render self-closing tags based on whether there is no child input.
+    if (!children) {
+        return `<${name}${attributes}/>`;
+    }
+    return `<${name}${attributes}>${children}</${name}>`;
+}
+
+module.exports = {
+    renderElement,
+    stringifyAttributes,
+};

package/src/logger.js

@@ -0,0 +1,28 @@
+/* eslint-disable no-console */
+let verbose = false;
+const setVerbose = arg => (verbose = arg);
+
+function log(...args) {
+    if (verbose) {
+        console.log(...args);
+    }
+}
+
+function warn(...args) {
+    if (verbose) {
+        console.warn(...args);
+    }
+}
+
+function error(...args) {
+    if (verbose) {
+        console.error(...args);
+    }
+}
+
+module.exports = {
+    log,
+    warn,
+    error,
+    setVerbose,
+};

package/src/mergeMaps.js

@@ -0,0 +1,32 @@
+const defaultMerger = (v, k, map) => map.set(k, v);
+
+/**
+ * Combines multiple maps in to a single map, allowing control over how
+ * the values for keys are stored in the new map.
+ *
+ * The default behaviour is the value from the last map wins.
+ *
+ * @example
+ * const a = new Map([['first', 1], ['second', 2]]);
+ * const b = new Map(['first', 100], ['third', 300]);
+ * mergeMaps(a, b) // Map(3) {'first' => 100, 'second' => 2, 'third' => 300}
+ *
+ * @example
+ * const a = new Map([['one', [1,2,3]]]);
+ * const b = new Map([['one', [4,5,6]]]);
+ * const merger = (map, k, newVal) => {
+ *   const oldVal = map.get(k);
+ *   map.set(k, [].concat(oldVal).concat(newVal));
+ * }
+ * mergeMaps(a, b, merger) // Map(1) {'one' => [1,2,3,4,5,6]}
+ */
+const mergeMaps = (...maps) => {
+    const source = new Map();
+    const merger = typeof maps[maps.length - 1] === 'function' ? maps.pop() : defaultMerger;
+    maps.forEach(map => {
+        Array.from(map.entries()).reduce((m, [k, v]) => merger(v, k, m), source);
+    });
+    return source;
+};
+
+module.exports = mergeMaps;

package/src/renderCondition.js

@@ -0,0 +1,29 @@
+const { renderElement } = require('./helpers/xml');
+
+function renderParams(params) {
+    if (!params) {
+        return '';
+    }
+    return params.map(param => renderElement('param', param.attributes, param.value)).join('');
+}
+
+module.exports = function renderCondition(condition) {
+    if (!condition) {
+        return '';
+    }
+
+    // we have actual conditions
+    if (Array.isArray(condition)) {
+        return condition.map(renderCondition).join('');
+    }
+    // we have a "conditions"-joiner for multiple sub conditions
+    if (condition.type) {
+        return renderElement('conditions', { type: condition.type }, renderCondition(condition.conditions));
+    }
+
+    return renderElement(
+        'condition',
+        ` class="${condition.class}" ${condition.invert ? `invert="true"` : ''}`,
+        renderParams(condition.params)
+    );
+};

package/src/renderTransformation.js

@@ -0,0 +1,44 @@
+const path = require('path');
+const { renderElement } = require('./helpers/xml');
+const { toMap } = require('./helpers/options-parser');
+
+function renderTransformer(transformers) {
+    if (transformers && transformers.length) {
+        return transformers.map(transformer => renderElement('transformer', { key: transformer })).join('');
+    }
+    return '';
+}
+
+/**
+ * Generates the appropriate function to be used when filtering a transform map down to only those required.
+ * @param {Resource[]} resources
+ * @returns {function}
+ */
+function transformFilterFactory(resources) {
+    if (resources && resources.length) {
+        const resourceFiletypes = resources.map(resource => path.extname(resource.location).substr(1));
+        return ext => resourceFiletypes.includes(ext);
+    }
+    return () => true;
+}
+
+/**
+ * Converts a map of filetype-to-transformer entries in to the set of XML transform elements
+ * required for a given set of resources. Renders every transform if no resources are provided.
+ * @param {Map<String, Array<String>>} transformations
+ * @param {Resource[]} resources
+ * @returns {string} the rendered XML for each necessary transform.
+ */
+module.exports = function renderTransformation(transformations, resources = []) {
+    const transMap = toMap(transformations);
+    return Array.from(transMap.keys())
+        .filter(transformFilterFactory(resources))
+        .map(fileExtension =>
+            renderElement(
+                'transformation',
+                { extension: fileExtension },
+                renderTransformer(transMap.get(fileExtension))
+            )
+        )
+        .join('');
+};

package/src/settings/base-dependencies.js

@@ -0,0 +1,42 @@
+/**
+ * @fileOverview
+ * Collects a set of web-resource dependencies that should be added
+ * to all the web-resources generated during compilation.
+ */
+const _ = require('lodash');
+const CROSS_PLATFORM_BASE_DEPS = [];
+
+function process(arr) {
+    return _.chain([].concat(CROSS_PLATFORM_BASE_DEPS, arr))
+        .filter(val => !!val)
+        .uniq()
+        .value();
+}
+
+let configuredContexts = [];
+
+function getBaseDependencies() {
+    // defensively cloning so consumers can't accidentally add anything
+    return [...configuredContexts];
+}
+
+function setBaseDependencies(val) {
+    const contexts = [];
+    if (val instanceof Array) {
+        contexts.push(...val);
+    } else if (typeof val === 'string') {
+        contexts.push(val);
+    }
+
+    configuredContexts = process(contexts);
+}
+
+function addBaseDependency(val) {
+    configuredContexts = process([...configuredContexts, val]);
+}
+
+module.exports = {
+    addBaseDependency,
+    getBaseDependencies,
+    setBaseDependencies,
+};

package/src/shims/qunit-require-shim.js

@@ -0,0 +1,19 @@
+/**
+ * Used for qunit-tests to prevent them from failing if "resources"/"dependencies" are required.
+ * This injects a window.require to capture and ignore require-requests to "wr-dependency!/wr-resource!",
+ * while forwarding everything else
+ */
+module.exports = `
+!function(){
+    var old_require = window.require;
+    window.require = function(modRequest){
+        if(modRequest.indexOf('wr-dependency!') === 0) {
+            return null;
+        }
+        if(modRequest.indexOf('wr-resource!') === 0) {
+            return null;
+        }
+        return old_require.apply(this, arguments);
+    }
+}();
+`;

package/src/types/typedefs.js

@@ -0,0 +1,50 @@
+/**
+ * @typedef {String} filepath - a relative filepath in unix format.
+ */
+
+/**
+ * @typedef {String} filename
+ */
+
+/**
+ * @typedef {String} wrKey
+ */
+
+/**
+ * @typedef {String} wrDep - a composite string in the format "maven.groupId.artifactId:webresource-key"
+ */
+
+/**
+ * @typedef {Object} Resource
+ * @property {filepath} location - the relative path for the resource,
+ *   starting from the root of the plugin's classpath (the JAR file).
+ * @property {filename} name - the asset's filename as it appears in the browser at runtime.
+ */
+
+/**
+ * @typedef {Object} WebResourceAttributes
+ * @property {wrKey} key - the unique identifier for this web-resource.
+ * @property {string} [name] - the human-readable name of the web-resource.
+ * @property {true|false} [state] - whether this web-resource should output its resources at runtime or not.
+ *   If absent, a web-resource is assumed to be enabled.
+ */
+
+/**
+ * @typedef {Object} WrmEntrypoint
+ * @description wraps a set of related resources with metadata the WRM can understand and reason about as a discrete unit.
+ * @property {WebResourceAttributes} attributes - the metadata for this web-resource.
+ * @property {filepath[]} resources - the locations of all resources directly referenced by this entrypoint's graph.
+ * @property {Resource[]} externalResources - a filename and filepath pair for resources
+ *   discovered by the WRM plugin's loaders.
+ * @property {wrDep[]} [dependencies] - a list of other web-resources this one should depend upon.
+ * @property {string[]} [contexts] - a list of contexts the web-resource should be loaded in to.
+ * @property {object[]} [conditions] - a list of conditions to apply to the web-resource to determine whether
+ *   it should output its resources at runtime or not.
+ */
+
+/**
+ * @typedef {Object} DataProvider
+ * @description Data provider shape used by `dataProvidersMap` option.
+ * @property {String} key - Data provider key e.g. `my-data-provider`
+ * @property {String} class - Data provider Java class e.g. `my.data.provider.JavaClass`
+ */

package/src/webpack-modules/EmptyExportsModule.js

@@ -0,0 +1,26 @@
+const DllModule = require('webpack/lib/DllModule');
+const RawSource = require('webpack-sources').RawSource;
+
+/**
+ * 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 {
+    constructor(dependency, type) {
+        super(null, [], dependency, type);
+        this._dependency = dependency;
+    }
+
+    chunkCondition() {
+        return true;
+    }
+
+    source() {
+        return new RawSource('module.exports = undefined;');
+    }
+}
+
+module.exports = EmptyExportsModule;