webpack-assets-manifest 5.2.1 → 6.0.1

package/dist/cjs/helpers.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asArray = asArray;
+exports.getSRIHash = getSRIHash;
+exports.getSortedObject = getSortedObject;
+exports.findMapKeysByValue = findMapKeysByValue;
+exports.group = group;
+exports.getLockFilename = getLockFilename;
+exports.lock = lock;
+exports.unlock = unlock;
+const node_crypto_1 = require("node:crypto");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const lockfile_1 = require("lockfile");
+const type_predicate_js_1 = require("./type-predicate.js");
+function asArray(data) {
+    return Array.isArray(data) ? data : [data];
+}
+function getSRIHash(algorithm, content) {
+    return `${algorithm}-${(0, node_crypto_1.createHash)(algorithm).update(content, 'utf8').digest('base64')}`;
+}
+function getSortedObject(object, compareFunction) {
+    return Object.fromEntries(Object.entries(object).sort(compareFunction ? (left, right) => compareFunction(left[0], right[0]) : undefined));
+}
+function findMapKeysByValue(map) {
+    const entries = [...map.entries()];
+    return (searchValue) => entries.filter(([, value]) => value === searchValue).map(([name]) => name);
+}
+function group(data, getGroup, mapper) {
+    return data.reduce((obj, item) => {
+        const group = getGroup(item);
+        if ((0, type_predicate_js_1.isPropertyKey)(group)) {
+            (obj[group] ??= []).push(mapper ? mapper(item, group) : item);
+        }
+        return obj;
+    }, Object.create(null));
+}
+function getLockFilename(filename) {
+    const name = filename.replace(/[^\w]+/g, '-');
+    return (0, node_path_1.join)((0, node_os_1.tmpdir)(), `${name}.lock`);
+}
+function lock(filename) {
+    return new Promise((resolve, reject) => {
+        (0, lockfile_1.lock)(getLockFilename(filename), {
+            wait: 10000,
+            stale: 20000,
+            retries: 100,
+            retryWait: 100,
+        }, (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+function unlock(filename) {
+    return new Promise((resolve, reject) => {
+        (0, lockfile_1.unlock)(getLockFilename(filename), (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}

package/dist/cjs/index.js

@@ -0,0 +1,18 @@
+"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("./types.js"), exports);
+__exportStar(require("./plugin.js"), exports);

package/dist/cjs/options-schema.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionsSchema = void 0;
+const node_crypto_1 = require("node:crypto");
+exports.optionsSchema = {
+    title: 'Webpack Assets Manifest options schema',
+    description: 'Webpack Assets Manifest options',
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        enabled: {
+            type: 'boolean',
+            default: true,
+        },
+        assets: {
+            type: 'object',
+            default: {},
+        },
+        output: {
+            type: 'string',
+            default: 'assets-manifest.json',
+        },
+        replacer: {
+            default: null,
+            oneOf: [
+                {
+                    $ref: '#/definitions/functionOrNull',
+                },
+                {
+                    type: 'array',
+                },
+            ],
+        },
+        space: {
+            oneOf: [
+                {
+                    type: 'integer',
+                    multipleOf: 1.0,
+                    minimum: 0,
+                },
+                {
+                    type: 'string',
+                    minLength: 1,
+                },
+            ],
+            default: 2,
+        },
+        writeToDisk: {
+            oneOf: [
+                {
+                    type: 'boolean',
+                },
+                {
+                    const: 'auto',
+                },
+            ],
+            default: 'auto',
+        },
+        fileExtRegex: {
+            oneOf: [
+                {
+                    instanceof: 'RegExp',
+                },
+                {
+                    type: 'null',
+                },
+                {
+                    const: false,
+                },
+            ],
+        },
+        sortManifest: {
+            default: true,
+            oneOf: [
+                {
+                    type: 'boolean',
+                },
+                {
+                    instanceof: 'Function',
+                },
+            ],
+        },
+        merge: {
+            default: false,
+            oneOf: [
+                {
+                    type: 'boolean',
+                },
+                {
+                    const: 'customize',
+                },
+            ],
+        },
+        publicPath: {
+            default: null,
+            oneOf: [
+                {
+                    type: 'string',
+                },
+                {
+                    type: 'boolean',
+                },
+                {
+                    type: 'null',
+                },
+                {
+                    instanceof: 'Function',
+                },
+            ],
+        },
+        contextRelativeKeys: {
+            type: 'boolean',
+            default: false,
+        },
+        apply: {
+            $ref: '#/definitions/functionOrNull',
+        },
+        customize: {
+            $ref: '#/definitions/functionOrNull',
+        },
+        transform: {
+            $ref: '#/definitions/functionOrNull',
+        },
+        done: {
+            $ref: '#/definitions/functionOrNull',
+        },
+        entrypoints: {
+            type: 'boolean',
+            default: false,
+        },
+        entrypointsKey: {
+            default: 'entrypoints',
+            oneOf: [
+                {
+                    type: 'string',
+                },
+                {
+                    const: false,
+                },
+            ],
+        },
+        entrypointsUseAssets: {
+            type: 'boolean',
+            default: false,
+        },
+        integrity: {
+            type: 'boolean',
+            default: 'a',
+        },
+        integrityHashes: {
+            type: 'array',
+            items: {
+                type: 'string',
+                enum: (0, node_crypto_1.getHashes)(),
+            },
+            default: ['sha256', 'sha384', 'sha512'],
+        },
+        integrityPropertyName: {
+            description: 'The `asset.info` property name where the SRI hash is stored',
+            type: 'string',
+            minLength: 1,
+            default: 'integrity',
+        },
+        extra: {
+            description: 'A place to put your arbitrary data',
+            type: 'object',
+            default: {},
+        },
+    },
+    definitions: {
+        functionOrNull: {
+            default: null,
+            oneOf: [
+                {
+                    instanceof: 'Function',
+                },
+                {
+                    type: 'null',
+                },
+            ],
+        },
+    },
+};

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}