@atlaspack/utils 2.17.3-typescript-e99c742e9.0 → 2.17.3-typescript-bc4459c37.0

package/lib/getModuleParts.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getModuleParts;
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+var _path2 = require("./path");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Returns the package name and the optional subpath
+ */
+function getModuleParts(_name) {
+  let name = _path().default.normalize(_name);
+  let splitOn = name.indexOf(_path().default.sep);
+  if (name.charAt(0) === '@') {
+    splitOn = name.indexOf(_path().default.sep, splitOn + 1);
+  }
+  if (splitOn < 0) {
+    return [(0, _path2.normalizeSeparators)(name), undefined];
+  } else {
+    return [(0, _path2.normalizeSeparators)(name.substring(0, splitOn)), name.substring(splitOn + 1) || undefined];
+  }
+}

package/lib/getRootDir.d.ts

@@ -0,0 +1,2 @@
+import type { FilePath } from '@atlaspack/types';
+export default function getRootDir(files: Array<FilePath>): FilePath;

package/lib/getRootDir.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getRootDir;
+var _glob = require("./glob");
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function getRootDir(files) {
+  let cur = null;
+  for (let file of files) {
+    let parsed = _path().default.parse(file);
+    parsed.dir = findGlobRoot(parsed.dir);
+    if (!cur) {
+      cur = parsed;
+    } else if (parsed.root !== cur.root) {
+      // bail out. there is no common root.
+      // this can happen on windows, e.g. C:\foo\bar vs. D:\foo\bar
+      return process.cwd();
+    } else {
+      // find the common path parts.
+      let curParts = cur.dir.split(_path().default.sep);
+      let newParts = parsed.dir.split(_path().default.sep);
+      let len = Math.min(curParts.length, newParts.length);
+      let i = 0;
+      while (i < len && curParts[i] === newParts[i]) {
+        i++;
+      }
+      cur.dir = i > 1 ? curParts.slice(0, i).join(_path().default.sep) : cur.root;
+    }
+  }
+  return cur ? cur.dir : process.cwd();
+}
+
+// Transforms a path like `packages/*/src/index.js` to the root of the glob, `packages/`
+function findGlobRoot(dir) {
+  let parts = dir.split(_path().default.sep);
+  let last = parts.length;
+  for (let i = parts.length - 1; i >= 0; i--) {
+    if ((0, _glob.isGlob)(parts[i])) {
+      last = i;
+    }
+  }
+  return parts.slice(0, last).join(_path().default.sep);
+}

package/lib/glob.d.ts

@@ -0,0 +1,10 @@
+import type { FilePath, Glob } from '@atlaspack/types';
+import type { FileSystem } from '@atlaspack/fs';
+import { FastGlobOptions } from 'fast-glob';
+import { type Options } from 'micromatch';
+export declare function isGlob(p: FilePath): any;
+export declare function isGlobMatch(filePath: FilePath, glob: Glob | Array<Glob>, opts?: Options): any;
+export declare function globMatch(values: Array<string>, glob: Glob | Array<Glob>, opts?: Options): Array<string>;
+export declare function globToRegex(glob: Glob, opts?: Options): RegExp;
+export declare function globSync(p: FilePath, fs: FileSystem, options?: FastGlobOptions<FilePath>): Array<FilePath>;
+export declare function glob(p: FilePath, fs: FileSystem, options: FastGlobOptions<FilePath>): Promise<Array<FilePath>>;

package/lib/glob.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.glob = glob;
+exports.globMatch = globMatch;
+exports.globSync = globSync;
+exports.globToRegex = globToRegex;
+exports.isGlob = isGlob;
+exports.isGlobMatch = isGlobMatch;
+function _isGlob2() {
+  const data = _interopRequireDefault(require("is-glob"));
+  _isGlob2 = function () {
+    return data;
+  };
+  return data;
+}
+function _fastGlob() {
+  const data = _interopRequireDefault(require("fast-glob"));
+  _fastGlob = function () {
+    return data;
+  };
+  return data;
+}
+function _micromatch() {
+  const data = _interopRequireWildcard(require("micromatch"));
+  _micromatch = function () {
+    return data;
+  };
+  return data;
+}
+var _path = require("./path");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// @ts-expect-error TS7016
+
+// @ts-expect-error TS2305
+
+function isGlob(p) {
+  return (0, _isGlob2().default)((0, _path.normalizeSeparators)(p));
+}
+function isGlobMatch(filePath, glob, opts) {
+  glob = Array.isArray(glob) ? glob.map(_path.normalizeSeparators) : (0, _path.normalizeSeparators)(glob);
+  return (0, _micromatch().isMatch)(filePath, glob, opts);
+}
+function globMatch(values, glob, opts) {
+  glob = Array.isArray(glob) ? glob.map(_path.normalizeSeparators) : (0, _path.normalizeSeparators)(glob);
+  return (0, _micromatch().default)(values, glob, opts);
+}
+function globToRegex(glob, opts) {
+  return (0, _micromatch().makeRe)(glob, opts);
+}
+function globSync(p, fs, options) {
+  options = {
+    ...options,
+    fs: {
+      // @ts-expect-error TS7006
+      statSync: p => {
+        return fs.statSync(p);
+      },
+      // @ts-expect-error TS7006
+      lstatSync: p => {
+        // Our FileSystem interface doesn't have lstat support at the moment,
+        // but this is fine for our purposes since we follow symlinks by default.
+        return fs.statSync(p);
+      },
+      // @ts-expect-error TS7006
+      readdirSync: (p, opts) => {
+        return fs.readdirSync(p, opts);
+      }
+    }
+  };
+
+  // @ts-expect-error TS2322
+  return _fastGlob().default.sync((0, _path.normalizeSeparators)(p), options);
+}
+function glob(p, fs, options) {
+  options = {
+    ...options,
+    fs: {
+      // @ts-expect-error TS7006
+      stat: async (p, cb) => {
+        try {
+          cb(null, await fs.stat(p));
+        } catch (err) {
+          cb(err);
+        }
+      },
+      // @ts-expect-error TS7006
+      lstat: async (p, cb) => {
+        // Our FileSystem interface doesn't have lstat support at the moment,
+        // but this is fine for our purposes since we follow symlinks by default.
+        try {
+          cb(null, await fs.stat(p));
+        } catch (err) {
+          cb(err);
+        }
+      },
+      // @ts-expect-error TS7006
+      readdir: async (p, opts, cb) => {
+        if (typeof opts === 'function') {
+          cb = opts;
+          opts = null;
+        }
+        try {
+          cb(null, await fs.readdir(p, opts));
+        } catch (err) {
+          cb(err);
+        }
+      }
+    }
+  };
+
+  // @ts-expect-error TS2322
+  return (0, _fastGlob().default)((0, _path.normalizeSeparators)(p), options);
+}

package/lib/hash.d.ts

@@ -0,0 +1,7 @@
+import type { Readable } from 'stream';
+import type { FileSystem } from '@atlaspack/fs';
+export declare function hashStream(stream: Readable): Promise<string>;
+export declare function hashObject(obj: {
+    readonly [key: string]: unknown;
+}): string;
+export declare function hashFile(fs: FileSystem, filePath: string): Promise<string>;

package/lib/hash.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hashFile = hashFile;
+exports.hashObject = hashObject;
+exports.hashStream = hashStream;
+var _collection = require("./collection");
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+function hashStream(stream) {
+  let hash = new (_rust().Hash)();
+  return new Promise((resolve, reject) => {
+    stream.on('error', err => {
+      reject(err);
+    });
+    stream.on('data', chunk => {
+      hash.writeBuffer(chunk);
+    }).on('end', function () {
+      resolve(hash.finish());
+    }).on('error', err => {
+      reject(err);
+    });
+  });
+}
+function hashObject(obj) {
+  return (0, _rust().hashString)(JSON.stringify((0, _collection.objectSortedEntriesDeep)(obj)));
+}
+let testCache = {
+  /*:: ...null */
+};
+function hashFile(fs, filePath) {
+  if (process.env.ATLASPACK_BUILD_ENV === 'test') {
+    // Development builds of these native modules are especially big and slow to hash.
+    if (/parcel-swc\.[^\\/]+\.node$|lightningcss.[^\\/]+.node$/.test(filePath)) {
+      let cacheEntry = testCache[filePath];
+      if (cacheEntry) return cacheEntry;
+      let v = hashStream(fs.createReadStream(filePath));
+      testCache[filePath] = v;
+      return v;
+    }
+  }
+  return hashStream(fs.createReadStream(filePath));
+}

package/lib/http-server.d.ts

@@ -0,0 +1,19 @@
+import type { Server as HTTPOnlyServer, IncomingMessage as HTTPRequest, ServerResponse as HTTPResponse } from 'http';
+import type { Server as HTTPSServer } from 'https';
+import type { FilePath, HTTPSOptions } from '@atlaspack/types';
+import type { FileSystem } from '@atlaspack/fs';
+type CreateHTTPServerOpts = {
+    listener?: (arg1: HTTPRequest, arg2: HTTPResponse) => void;
+    host?: string;
+} & ({
+    https: HTTPSOptions | boolean | null | undefined;
+    inputFS: FileSystem;
+    outputFS: FileSystem;
+    cacheDir: FilePath;
+} | Record<any, any>);
+export type HTTPServer = HTTPOnlyServer | HTTPSServer;
+export declare function createHTTPServer(options: CreateHTTPServerOpts): Promise<{
+    stop: () => Promise<void>;
+    server: HTTPServer;
+}>;
+export {};

package/lib/http-server.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createHTTPServer = createHTTPServer;
+function _http() {
+  const data = _interopRequireDefault(require("http"));
+  _http = function () {
+    return data;
+  };
+  return data;
+}
+function _https() {
+  const data = _interopRequireDefault(require("https"));
+  _https = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+var _ = require("./");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// Creates either an http or https server with an awaitable dispose
+// that closes any connections
+async function createHTTPServer(options) {
+  let server;
+  if (!options.https) {
+    server = _http().default.createServer(options.listener);
+  } else if (options.https === true) {
+    let {
+      cert,
+      key
+    } = await (0, _.generateCertificate)(options.outputFS, options.cacheDir, options.host);
+    server = _https().default.createServer({
+      cert,
+      key
+    }, options.listener);
+  } else {
+    let {
+      cert,
+      key
+    } = await (0, _.getCertificate)(options.inputFS, options.https);
+    server = _https().default.createServer({
+      cert,
+      key
+    }, options.listener);
+  }
+
+  // HTTPServer#close only stops accepting new connections, and does not close existing ones.
+  // Before closing, destroy any active connections through their sockets. Additionally, remove sockets when they close:
+  // https://stackoverflow.com/questions/18874689/force-close-all-connections-in-a-node-js-http-server
+  // https://stackoverflow.com/questions/14626636/how-do-i-shutdown-a-node-js-https-server-immediately/14636625#14636625
+  let sockets = new Set();
+  server.on('connection', socket => {
+    (0, _nullthrows().default)(sockets).add(socket);
+    socket.on('close', () => {
+      (0, _nullthrows().default)(sockets).delete(socket);
+    });
+  });
+  return {
+    server,
+    stop() {
+      return new Promise((resolve, reject) => {
+        for (let socket of (0, _nullthrows().default)(sockets)) {
+          socket.destroy();
+        }
+        sockets = new Set();
+        server.close(err => {
+          if (err != null) {
+            reject(err);
+            return;
+          }
+          resolve();
+        });
+      });
+    }
+  };
+}

package/lib/index.d.ts

@@ -0,0 +1,48 @@
+export * from './config';
+export * from './Deferred';
+export * from './generateBuildMetrics';
+export * from './http-server';
+export * from './path';
+export * from './prettyDiagnostic';
+export * from './schema';
+export { default as countLines } from './countLines';
+export { default as generateBuildMetrics } from './generateBuildMetrics';
+export { default as generateCertificate } from './generateCertificate';
+export { default as getCertificate } from './getCertificate';
+export { default as getModuleParts } from './getModuleParts';
+export { default as getRootDir } from './getRootDir';
+export { default as isDirectoryInside } from './isDirectoryInside';
+export { default as isURL } from './is-url';
+export { default as objectHash } from './objectHash';
+export { default as prettifyTime } from './prettifyTime';
+export { default as prettyDiagnostic } from './prettyDiagnostic';
+export { default as PromiseQueue } from './PromiseQueue';
+export { default as validateSchema } from './schema';
+export { default as TapStream } from './TapStream';
+export { default as urlJoin } from './urlJoin';
+export { default as relativeUrl } from './relativeUrl';
+export { default as createDependencyLocation } from './dependency-location';
+export { default as debounce } from './debounce';
+export { default as throttle } from './throttle';
+export { default as openInBrowser } from './openInBrowser';
+export { findAlternativeNodeModules, findAlternativeFiles } from './alternatives';
+export { blobToBuffer, blobToString } from './blob';
+export { unique, objectSortedEntries, objectSortedEntriesDeep, setDifference, setSymmetricDifference, setEqual, setIntersect, setIntersectStatic, setUnion, } from './collection';
+export { resolveConfig, resolveConfigSync, loadConfig, readConfig, } from './config';
+export { debugTools } from './debug-tools';
+export { DefaultMap, DefaultWeakMap } from './DefaultMap';
+export { makeDeferredWithPromise } from './Deferred';
+export { getProgressMessage, getPackageProgressMessage, } from './progress-message';
+export { isGlob, isGlobMatch, globMatch, globSync, glob, globToRegex, } from './glob';
+export { hashStream, hashObject, hashFile } from './hash';
+export { SharedBuffer } from './shared-buffer';
+export { fuzzySearch } from './schema';
+export { createHTTPServer } from './http-server';
+export { normalizePath, normalizeSeparators, relativePath } from './path';
+export { replaceURLReferences, replaceInlineReferences, } from './replaceBundleReferences';
+export { measureStreamLength, readableFromStringOrBuffer, bufferStream, blobToStream, streamFromPromise, fallbackStream, } from './stream';
+export { relativeBundlePath } from './relativeBundlePath';
+export { ansiHtml } from './ansi-html';
+export { escapeHTML } from './escape-html';
+export { SOURCEMAP_RE, SOURCEMAP_EXTENSIONS, matchSourceMappingURL, loadSourceMapUrl, loadSourceMap, remapSourceLocation, } from './sourcemap';
+export { default as stripAnsi } from 'strip-ansi';