@atlaspack/utils 2.19.3 → 3.0.0

package/dist/schema.js

@@ -0,0 +1,389 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fuzzySearch = fuzzySearch;
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const levenshtein = __importStar(require("fastest-levenshtein"));
+function validateSchema(schema, data) {
+    function walk(
+    // @ts-expect-error TS7006
+    schemaAncestors, dataNode, dataPath) {
+        let [schemaNode] = schemaAncestors;
+        if (schemaNode.type) {
+            let type = Array.isArray(dataNode) ? 'array' : typeof dataNode;
+            if (schemaNode.type !== type) {
+                return {
+                    type: 'type',
+                    dataType: 'value',
+                    dataPath,
+                    expectedTypes: [schemaNode.type],
+                    ancestors: schemaAncestors,
+                    prettyType: schemaNode.__type,
+                };
+            }
+            else {
+                switch (schemaNode.type) {
+                    case 'array': {
+                        if (schemaNode.items) {
+                            let results = [];
+                            // @ts-expect-error TS18046
+                            for (let i = 0; i < dataNode.length; i++) {
+                                let result = walk([schemaNode.items].concat(schemaAncestors), 
+                                // @ts-expect-error TS18046
+                                dataNode[i], dataPath + '/' + i);
+                                if (result)
+                                    results.push(result);
+                            }
+                            if (results.length)
+                                return results.reduce((acc, v) => acc.concat(v), []);
+                        }
+                        break;
+                    }
+                    case 'string': {
+                        // @ts-expect-error TS2322
+                        let value = dataNode;
+                        if (schemaNode.enum) {
+                            if (!schemaNode.enum.includes(value)) {
+                                return {
+                                    type: 'enum',
+                                    dataType: 'value',
+                                    dataPath,
+                                    expectedValues: schemaNode.enum,
+                                    actualValue: value,
+                                    ancestors: schemaAncestors,
+                                };
+                            }
+                        }
+                        else if (schemaNode.__validate) {
+                            let validationError = schemaNode.__validate(value);
+                            if (typeof validationError == 'string') {
+                                return {
+                                    type: 'other',
+                                    dataType: 'value',
+                                    dataPath,
+                                    message: validationError,
+                                    actualValue: value,
+                                    ancestors: schemaAncestors,
+                                };
+                            }
+                        }
+                        break;
+                    }
+                    case 'number': {
+                        // @ts-expect-error TS2322
+                        let value = dataNode;
+                        if (schemaNode.enum) {
+                            if (!schemaNode.enum.includes(value)) {
+                                return {
+                                    type: 'enum',
+                                    dataType: 'value',
+                                    dataPath,
+                                    expectedValues: schemaNode.enum,
+                                    actualValue: value,
+                                    ancestors: schemaAncestors,
+                                };
+                            }
+                        }
+                        break;
+                    }
+                    case 'object': {
+                        let results = [];
+                        let invalidProps;
+                        if (schemaNode.__forbiddenProperties) {
+                            // @ts-expect-error TS2769
+                            let keys = Object.keys(dataNode);
+                            // @ts-expect-error TS7006
+                            invalidProps = schemaNode.__forbiddenProperties.filter((val) => keys.includes(val));
+                            results.push(...invalidProps.map(
+                            // @ts-expect-error TS7006
+                            (k) => ({
+                                type: 'forbidden-prop',
+                                dataPath: dataPath + '/' + (0, diagnostic_1.encodeJSONKeyComponent)(k),
+                                dataType: 'key',
+                                prop: k,
+                                expectedProps: Object.keys(schemaNode.properties),
+                                actualProps: keys,
+                                ancestors: schemaAncestors,
+                            })));
+                        }
+                        if (schemaNode.required) {
+                            // @ts-expect-error TS2769
+                            let keys = Object.keys(dataNode);
+                            let missingKeys = schemaNode.required.filter(
+                            // @ts-expect-error TS7006
+                            (val) => !keys.includes(val));
+                            results.push(...missingKeys.map(
+                            // @ts-expect-error TS7006
+                            (k) => ({
+                                type: 'missing-prop',
+                                dataPath,
+                                dataType: 'value',
+                                prop: k,
+                                expectedProps: schemaNode.required,
+                                actualProps: keys,
+                                ancestors: schemaAncestors,
+                            })));
+                        }
+                        if (schemaNode.properties) {
+                            let { additionalProperties = true } = schemaNode;
+                            // @ts-expect-error TS2407
+                            for (let k in dataNode) {
+                                if (invalidProps && invalidProps.includes(k)) {
+                                    // Don't check type on forbidden props
+                                    continue;
+                                }
+                                else if (k in schemaNode.properties) {
+                                    let result = walk([schemaNode.properties[k]].concat(schemaAncestors), 
+                                    // @ts-expect-error TS18046
+                                    dataNode[k], dataPath + '/' + (0, diagnostic_1.encodeJSONKeyComponent)(k));
+                                    if (result)
+                                        results.push(result);
+                                }
+                                else {
+                                    if (typeof additionalProperties === 'boolean') {
+                                        if (!additionalProperties) {
+                                            results.push({
+                                                type: 'enum',
+                                                dataType: 'key',
+                                                dataPath: dataPath + '/' + (0, diagnostic_1.encodeJSONKeyComponent)(k),
+                                                expectedValues: Object.keys(schemaNode.properties).filter((p) => !(p in dataNode)),
+                                                actualValue: k,
+                                                ancestors: schemaAncestors,
+                                                prettyType: schemaNode.__type,
+                                            });
+                                        }
+                                    }
+                                    else {
+                                        let result = walk([additionalProperties].concat(schemaAncestors), 
+                                        // @ts-expect-error TS18046
+                                        dataNode[k], dataPath + '/' + (0, diagnostic_1.encodeJSONKeyComponent)(k));
+                                        if (result)
+                                            results.push(result);
+                                    }
+                                }
+                            }
+                        }
+                        if (results.length)
+                            return results.reduce((acc, v) => acc.concat(v), []);
+                        break;
+                    }
+                    case 'boolean':
+                        // NOOP, type was checked already
+                        break;
+                    default:
+                        throw new Error(`Unimplemented schema type ${type}?`);
+                }
+            }
+        }
+        else {
+            if (schemaNode.enum && !schemaNode.enum.includes(dataNode)) {
+                return {
+                    type: 'enum',
+                    dataType: 'value',
+                    dataPath: dataPath,
+                    expectedValues: schemaNode.enum,
+                    actualValue: schemaNode,
+                    ancestors: schemaAncestors,
+                };
+            }
+            if (schemaNode.oneOf || schemaNode.allOf) {
+                let list = schemaNode.oneOf || schemaNode.allOf;
+                let results = [];
+                for (let f of list) {
+                    let result = walk([f].concat(schemaAncestors), dataNode, dataPath);
+                    if (result)
+                        results.push(result);
+                }
+                if (schemaNode.oneOf
+                    ? results.length == schemaNode.oneOf.length
+                    : results.length > 0) {
+                    // return the result with more values / longer key
+                    results.sort((a, b) => Array.isArray(a) || Array.isArray(b)
+                        ? Array.isArray(a) && !Array.isArray(b)
+                            ? -1
+                            : !Array.isArray(a) && Array.isArray(b)
+                                ? 1
+                                : Array.isArray(a) && Array.isArray(b)
+                                    ? b.length - a.length
+                                    : 0
+                        : b.dataPath.length - a.dataPath.length);
+                    return results[0];
+                }
+            }
+            else if (schemaNode.not) {
+                let result = walk([schemaNode.not].concat(schemaAncestors), dataNode, dataPath);
+                // @ts-expect-error TS2339
+                if (!result || result.length == 0) {
+                    return {
+                        type: 'other',
+                        dataPath,
+                        dataType: null,
+                        message: schemaNode.__message,
+                        actualValue: dataNode,
+                        ancestors: schemaAncestors,
+                    };
+                }
+            }
+        }
+        return undefined;
+    }
+    let result = walk([schema], data, '');
+    return Array.isArray(result) ? result : result ? [result] : [];
+}
+exports.default = validateSchema;
+function fuzzySearch(expectedValues, actualValue) {
+    let result = expectedValues
+        .map((exp) => [exp, levenshtein.distance(exp, actualValue)])
+        .filter(
+    // Remove if more than half of the string would need to be changed
+    // @ts-expect-error TS2769
+    ([, d]) => d * 2 < actualValue.length);
+    // @ts-expect-error TS2345
+    result.sort(([, a], [, b]) => a - b);
+    // @ts-expect-error TS2345
+    return result.map(([v]) => v);
+}
+validateSchema.diagnostic = function (schema, data, origin, message) {
+    if ('source' in data &&
+        'data' in data &&
+        typeof data.source !== 'string' &&
+        !data) {
+        throw new Error('At least one of data.source and data.data must be defined!');
+    }
+    // @ts-expect-error TS2339
+    let object = data.map
+        ? // @ts-expect-error TS2339
+            data.map.data
+        : // @ts-expect-error TS2339
+            (data.data ?? JSON.parse(data.source));
+    let errors = validateSchema(schema, object);
+    if (errors.length) {
+        let keys = errors.map((e) => {
+            let message;
+            if (e.type === 'enum') {
+                let { actualValue } = e;
+                let expectedValues = e.expectedValues.map(String);
+                let likely = actualValue != null
+                    ? fuzzySearch(expectedValues, String(actualValue))
+                    : [];
+                if (likely.length > 0) {
+                    message = `Did you mean ${likely
+                        .map((v) => JSON.stringify(v))
+                        .join(', ')}?`;
+                }
+                else if (expectedValues.length > 0) {
+                    message = `Possible values: ${expectedValues
+                        .map((v) => JSON.stringify(v))
+                        .join(', ')}`;
+                }
+                else {
+                    message = 'Unexpected value';
+                }
+            }
+            else if (e.type === 'forbidden-prop') {
+                let { prop, expectedProps, actualProps } = e;
+                let likely = fuzzySearch(expectedProps, prop).filter((v) => !actualProps.includes(v));
+                if (likely.length > 0) {
+                    message = `Did you mean ${likely
+                        .map((v) => JSON.stringify(v))
+                        .join(', ')}?`;
+                }
+                else {
+                    message = 'Unexpected property';
+                }
+            }
+            else if (e.type === 'missing-prop') {
+                let { prop, actualProps } = e;
+                let likely = fuzzySearch(actualProps, prop);
+                if (likely.length > 0) {
+                    message = `Did you mean ${JSON.stringify(prop)}?`;
+                    e.dataPath += '/' + likely[0];
+                    e.dataType = 'key';
+                }
+                else {
+                    message = `Missing property ${prop}`;
+                }
+            }
+            else if (e.type === 'type') {
+                if (e.prettyType != null) {
+                    message = `Expected ${e.prettyType}`;
+                }
+                else {
+                    message = `Expected type ${e.expectedTypes.join(', ')}`;
+                }
+            }
+            else {
+                message = e.message;
+            }
+            return { key: e.dataPath, type: e.dataType, message };
+        });
+        let map, code;
+        // @ts-expect-error TS2339
+        if (data.map) {
+            // @ts-expect-error TS2339
+            map = data.map;
+            code = data.source;
+        }
+        else {
+            // @ts-expect-error TS2339
+            map = data.source ?? JSON.stringify((0, nullthrows_1.default)(data.data), 0, '\t');
+            code = map;
+        }
+        let codeFrames = [
+            {
+                filePath: data.filePath ?? undefined,
+                language: 'json',
+                code,
+                codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(map, keys.map(({ key, type, message }) => ({
+                    key: (data.prependKey ?? '') + key,
+                    type: type,
+                    message: message != null ? (0, diagnostic_1.escapeMarkdown)(message) : message,
+                }))),
+            },
+        ];
+        throw new diagnostic_1.default({
+            diagnostic: {
+                message: message,
+                origin,
+                // @ts-expect-error TS2322
+                codeFrames,
+            },
+        });
+    }
+};

package/dist/shared-buffer.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedBuffer = void 0;
+// @ts-expect-error process.browser is a browser-specific property
+if (process.browser) {
+    exports.SharedBuffer = ArrayBuffer;
+    // Safari has removed the constructor
+    if (typeof SharedArrayBuffer !== 'undefined') {
+        let channel = new MessageChannel();
+        try {
+            // Firefox might throw when sending the Buffer over a MessagePort
+            channel.port1.postMessage(new SharedArrayBuffer(0));
+            exports.SharedBuffer = SharedArrayBuffer;
+        }
+        catch (_) {
+            // NOOP
+        }
+        channel.port1.close();
+        channel.port2.close();
+    }
+}
+else {
+    exports.SharedBuffer = SharedArrayBuffer;
+}

package/dist/sourcemap.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOURCEMAP_EXTENSIONS = exports.SOURCEMAP_RE = void 0;
+exports.matchSourceMappingURL = matchSourceMappingURL;
+exports.loadSourceMapUrl = loadSourceMapUrl;
+exports.loadSourceMap = loadSourceMap;
+exports.remapSourceLocation = remapSourceLocation;
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const source_map_1 = __importDefault(require("@parcel/source-map"));
+const path_1 = __importDefault(require("path"));
+const path_2 = require("./path");
+exports.SOURCEMAP_RE = /(?:\/\*|\/\/)\s*[@#]\s*sourceMappingURL\s*=\s*([^\s*]+)(?:\s*\*\/)?\s*$/;
+const DATA_URL_RE = /^data:[^;]+(?:;charset=[^;]+)?;base64,(.*)/;
+exports.SOURCEMAP_EXTENSIONS = new Set([
+    'css',
+    'es',
+    'es6',
+    'js',
+    'jsx',
+    'mjs',
+    'ts',
+    'tsx',
+]);
+function matchSourceMappingURL(contents) {
+    return contents.match(exports.SOURCEMAP_RE);
+}
+async function loadSourceMapUrl(fs, filename, contents) {
+    let match = matchSourceMappingURL(contents);
+    if (match) {
+        let url = match[1].trim();
+        let dataURLMatch = url.match(DATA_URL_RE);
+        let mapFilePath;
+        if (dataURLMatch) {
+            mapFilePath = filename;
+        }
+        else {
+            mapFilePath = url.replace(/^file:\/\//, '');
+            mapFilePath = (0, path_2.isAbsolute)(mapFilePath)
+                ? mapFilePath
+                : path_1.default.join(path_1.default.dirname(filename), mapFilePath);
+        }
+        return {
+            url,
+            filename: mapFilePath,
+            map: JSON.parse(dataURLMatch
+                ? Buffer.from(dataURLMatch[1], 'base64').toString()
+                : await fs.readFile(mapFilePath, 'utf8')),
+        };
+    }
+}
+async function loadSourceMap(filename, contents, options) {
+    let foundMap = await loadSourceMapUrl(options.fs, filename, contents);
+    if (foundMap) {
+        let mapSourceRoot = path_1.default.dirname(filename);
+        if (foundMap.map.sourceRoot &&
+            !(0, path_2.normalizeSeparators)(foundMap.map.sourceRoot).startsWith('/')) {
+            mapSourceRoot = path_1.default.join(mapSourceRoot, foundMap.map.sourceRoot);
+        }
+        let sourcemapInstance = new source_map_1.default(options.projectRoot);
+        sourcemapInstance.addVLQMap({
+            ...foundMap.map,
+            sources: foundMap.map.sources.map((s) => {
+                return path_1.default.join(mapSourceRoot, s);
+            }),
+        });
+        return sourcemapInstance;
+    }
+}
+function remapSourceLocation(loc, originalMap, projectRoot) {
+    let { filePath, start: { line: startLine, column: startCol }, end: { line: endLine, column: endCol }, } = loc;
+    let lineDiff = endLine - startLine;
+    let colDiff = endCol - startCol;
+    let start = originalMap.findClosestMapping(startLine, startCol - 1);
+    let end = originalMap.findClosestMapping(endLine, endCol - 1);
+    if (start?.original) {
+        if (start.source) {
+            if ((0, feature_flags_1.getFeatureFlag)('symbolLocationFix') &&
+                !path_1.default.isAbsolute(start.source)) {
+                filePath = path_1.default.join(projectRoot, start.source);
+            }
+            else {
+                filePath = start.source;
+            }
+        }
+        ({ line: startLine, column: startCol } = start.original);
+        startCol++; // source map columns are 0-based
+    }
+    if (end?.original) {
+        ({ line: endLine, column: endCol } = end.original);
+        endCol++; // source map columns are 0-based
+        if (endLine < startLine) {
+            endLine = startLine;
+            endCol = startCol;
+        }
+        else if (endLine === startLine && endCol < startCol && lineDiff === 0) {
+            endCol = startCol + colDiff;
+        }
+        else if (endLine === startLine && startCol === endCol && lineDiff === 0) {
+            // Prevent 0-length ranges
+            endCol = startCol + 1;
+        }
+    }
+    else {
+        endLine = startLine;
+        endCol = startCol;
+    }
+    return {
+        filePath,
+        start: {
+            line: startLine,
+            column: startCol,
+        },
+        end: {
+            line: endLine,
+            column: endCol,
+        },
+    };
+}

package/dist/stream.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureStreamLength = measureStreamLength;
+exports.readableFromStringOrBuffer = readableFromStringOrBuffer;
+exports.bufferStream = bufferStream;
+exports.blobToStream = blobToStream;
+exports.streamFromPromise = streamFromPromise;
+exports.fallbackStream = fallbackStream;
+const stream_1 = require("stream");
+function measureStreamLength(stream) {
+    return new Promise((resolve, reject) => {
+        let length = 0;
+        stream.on('data', (chunk) => {
+            length += chunk;
+        });
+        stream.on('end', () => resolve(length));
+        stream.on('error', reject);
+    });
+}
+function readableFromStringOrBuffer(str) {
+    // https://stackoverflow.com/questions/12755997/how-to-create-streams-from-string-in-node-js
+    const stream = new stream_1.Readable();
+    stream.push(str);
+    stream.push(null);
+    return stream;
+}
+function bufferStream(stream) {
+    return new Promise((resolve, reject) => {
+        let buf = Buffer.from([]);
+        stream.on('data', (data) => {
+            buf = Buffer.concat([buf, data]);
+        });
+        stream.on('end', () => {
+            resolve(buf);
+        });
+        stream.on('error', reject);
+    });
+}
+function blobToStream(blob) {
+    if (blob instanceof stream_1.Readable) {
+        return blob;
+    }
+    return readableFromStringOrBuffer(blob);
+}
+function streamFromPromise(promise) {
+    const stream = new stream_1.PassThrough();
+    promise.then((blob) => {
+        if (blob instanceof stream_1.Readable) {
+            blob.pipe(stream);
+        }
+        else {
+            stream.end(blob);
+        }
+    });
+    return stream;
+}
+function fallbackStream(stream, fallback) {
+    const res = new stream_1.PassThrough();
+    stream.on('error', (err) => {
+        if (err.code === 'ENOENT') {
+            fallback().pipe(res);
+        }
+        else {
+            res.emit('error', err);
+        }
+    });
+    stream.pipe(res);
+    return res;
+}

package/dist/throttle.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = throttle;
+function throttle(fn, delay) {
+    let lastCalled;
+    return function throttled(...args) {
+        if (lastCalled == null || lastCalled + delay <= Date.now()) {
+            fn.call(this, ...args);
+            lastCalled = Date.now();
+        }
+    };
+}

package/dist/urlJoin.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = urlJoin;
+const url_1 = __importDefault(require("url"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Joins a path onto a URL, and normalizes Windows paths
+ * e.g. from \path\to\res.js to /path/to/res.js.
+ */
+function urlJoin(publicURL, assetPath) {
+    const url = url_1.default.parse(publicURL, false, true);
+    // Leading / ensures that paths with colons are not parsed as a protocol.
+    let p = assetPath.startsWith('/') ? assetPath : '/' + assetPath;
+    const assetUrl = url_1.default.parse(p);
+    url.pathname = path_1.default.posix.join(url.pathname ?? '', assetUrl.pathname ?? '');
+    url.search = assetUrl.search;
+    url.hash = assetUrl.hash;
+    return url_1.default.format(url);
+}

package/lib/prettyDiagnostic.js

@@ -11,6 +11,13 @@ function _codeframe() {
   };
   return data;
 }
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
 function _markdownAnsi() {
   const data = _interopRequireDefault(require("@atlaspack/markdown-ansi"));
   _markdownAnsi = function () {
@@ -87,7 +94,16 @@ async function prettyDiagnostic(diagnostic, options, terminalWidth, format = 'an
       let highlights = codeFrame.codeHighlights;
       let code = codeFrame.code;
       if (code == null && options && filePath != null) {
-        code = await options.inputFS.readFile(filePath, 'utf8');
+        try {
+          code = await options.inputFS.readFile(filePath, 'utf8');
+        } catch (e) {
+          // In strange cases this can fail and hide the underlying error.
+          _logger().default.warn({
+            origin: '@atlaspack/utils',
+            message: `Failed to read file for generating codeframe: "${filePath}"`,
+            skipFormatting: true
+          });
+        }
       }
       let formattedCodeFrame = '';
       if (code != null) {