@atlaspack/core 2.12.1-canary.3354

package/lib/utils.js

@@ -0,0 +1,160 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BuildAbortError = void 0;
+exports.assertSignalNotAborted = assertSignalNotAborted;
+exports.createInvalidations = createInvalidations;
+exports.fromInternalSourceLocation = fromInternalSourceLocation;
+exports.getBundleGroupId = getBundleGroupId;
+exports.getPublicId = getPublicId;
+exports.hashFromOption = hashFromOption;
+exports.invalidateOnFileCreateToInternal = invalidateOnFileCreateToInternal;
+exports.optionsProxy = optionsProxy;
+exports.toInternalSourceLocation = toInternalSourceLocation;
+exports.toInternalSymbols = toInternalSymbols;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _baseX() {
+  const data = _interopRequireDefault(require("base-x"));
+  _baseX = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+var _projectPath = require("./projectPath");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const base62 = (0, _baseX().default)('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');
+function getBundleGroupId(bundleGroup) {
+  return 'bundle_group:' + bundleGroup.target.name + bundleGroup.entryAssetId;
+}
+function assertSignalNotAborted(signal) {
+  if (signal && signal.aborted) {
+    throw new BuildAbortError();
+  }
+}
+class BuildAbortError extends Error {
+  name = 'BuildAbortError';
+}
+exports.BuildAbortError = BuildAbortError;
+function getPublicId(id, alreadyExists) {
+  let encoded = base62.encode(Buffer.from(id, 'hex'));
+  for (let end = 5; end <= encoded.length; end++) {
+    let candidate = encoded.slice(0, end);
+    if (!alreadyExists(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error('Original id was not unique');
+}
+
+// These options don't affect compilation and should cause invalidations
+const ignoreOptions = new Set(['env',
+// handled by separate invalidateOnEnvChange
+'inputFS', 'outputFS', 'workerFarm', 'packageManager', 'detailedReport', 'shouldDisableCache', 'cacheDir', 'shouldAutoInstall', 'logLevel', 'shouldProfile', 'shouldTrace', 'shouldPatchConsole', 'projectRoot', 'additionalReporters']);
+function optionsProxy(options, invalidateOnOptionChange, addDevDependency) {
+  let packageManager = addDevDependency ? proxyPackageManager(options.projectRoot, options.packageManager, addDevDependency) : options.packageManager;
+  return new Proxy(options, {
+    get(target, prop) {
+      if (prop === 'packageManager') {
+        return packageManager;
+      }
+      if (!ignoreOptions.has(prop)) {
+        invalidateOnOptionChange(prop);
+      }
+      return target[prop];
+    }
+  });
+}
+function proxyPackageManager(projectRoot, packageManager, addDevDependency) {
+  let require = (id, from, opts) => {
+    addDevDependency({
+      specifier: id,
+      resolveFrom: (0, _projectPath.toProjectPath)(projectRoot, from),
+      range: opts === null || opts === void 0 ? void 0 : opts.range
+    });
+    return packageManager.require(id, from, opts);
+  };
+  return new Proxy(packageManager, {
+    get(target, prop) {
+      if (prop === 'require') {
+        return require;
+      }
+
+      // $FlowFixMe
+      return target[prop];
+    }
+  });
+}
+function hashFromOption(value) {
+  if (typeof value === 'object' && value != null) {
+    return (0, _utils().hashObject)(value);
+  }
+  return String(value);
+}
+function invalidateOnFileCreateToInternal(projectRoot, invalidation) {
+  if (invalidation.glob != null) {
+    return {
+      glob: (0, _projectPath.toProjectPath)(projectRoot, invalidation.glob)
+    };
+  } else if (invalidation.filePath != null) {
+    return {
+      filePath: (0, _projectPath.toProjectPath)(projectRoot, invalidation.filePath)
+    };
+  } else {
+    (0, _assert().default)(invalidation.aboveFilePath != null && invalidation.fileName != null);
+    return {
+      fileName: invalidation.fileName,
+      aboveFilePath: (0, _projectPath.toProjectPath)(projectRoot, invalidation.aboveFilePath)
+    };
+  }
+}
+function createInvalidations() {
+  return {
+    invalidateOnBuild: false,
+    invalidateOnStartup: false,
+    invalidateOnOptionChange: new Set(),
+    invalidateOnEnvChange: new Set(),
+    invalidateOnFileChange: new Set(),
+    invalidateOnFileCreate: []
+  };
+}
+function fromInternalSourceLocation(projectRoot, loc) {
+  if (!loc) return loc;
+  return {
+    filePath: (0, _projectPath.fromProjectPath)(projectRoot, loc.filePath),
+    start: loc.start,
+    end: loc.end
+  };
+}
+function toInternalSourceLocation(projectRoot, loc) {
+  if (!loc) return loc;
+  return {
+    filePath: (0, _projectPath.toProjectPath)(projectRoot, loc.filePath),
+    start: loc.start,
+    end: loc.end
+  };
+}
+function toInternalSymbols(projectRoot, symbols) {
+  if (!symbols) return symbols;
+  return new Map([...symbols].map(([k, {
+    loc,
+    ...v
+  }]) => [k, {
+    ...v,
+    loc: toInternalSourceLocation(projectRoot, loc)
+  }]));
+}

package/lib/worker.js

@@ -0,0 +1,170 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.childInit = childInit;
+exports.clearConfigCache = clearConfigCache;
+exports.invalidateRequireCache = invalidateRequireCache;
+exports.runPackage = runPackage;
+exports.runTransform = runTransform;
+exports.runValidate = runValidate;
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+var _BundleGraph = _interopRequireDefault(require("./BundleGraph"));
+var _Transformation = _interopRequireDefault(require("./Transformation"));
+var _ReporterRunner = require("./ReporterRunner");
+var _PackagerRunner = _interopRequireDefault(require("./PackagerRunner"));
+var _Validation = _interopRequireDefault(require("./Validation"));
+var _AtlaspackConfig = _interopRequireDefault(require("./AtlaspackConfig"));
+var _registerCoreWithSerializer = require("./registerCoreWithSerializer");
+var _buildCache = require("./buildCache");
+function _sourceMap() {
+  const data = require("@parcel/source-map");
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+function _workers() {
+  const data = _interopRequireDefault(require("@atlaspack/workers"));
+  _workers = function () {
+    return data;
+  };
+  return data;
+}
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+require("@atlaspack/cache");
+require("@atlaspack/package-manager");
+require("@atlaspack/fs");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// register with serializer
+// $FlowFixMe
+if (process.env.ATLASPACK_BUILD_REPL && process.browser) {
+  /* eslint-disable import/no-extraneous-dependencies, monorepo/no-internal-import */
+  require('@atlaspack/repl/src/atlaspack/BrowserPackageManager.js');
+  // $FlowFixMe
+  require('@atlaspack/repl/src/atlaspack/ExtendedMemoryFS.js');
+  /* eslint-enable import/no-extraneous-dependencies, monorepo/no-internal-import */
+}
+
+(0, _registerCoreWithSerializer.registerCoreWithSerializer)();
+
+// Remove the workerApi type from the TransformationOpts and ValidationOpts types:
+// https://github.com/facebook/flow/issues/2835
+// TODO: this should eventually be replaced by an in memory cache layer
+let atlaspackConfigCache = new Map();
+function loadOptions(ref, workerApi) {
+  return (0, _nullthrows().default)(workerApi.getSharedReference(ref
+  // $FlowFixMe
+  ));
+}
+
+async function loadConfig(cachePath, options) {
+  let config = atlaspackConfigCache.get(cachePath);
+  if (config && config.options === options) {
+    return config;
+  }
+  let processedConfig = (0, _nullthrows().default)(await options.cache.get(cachePath));
+  config = new _AtlaspackConfig.default(processedConfig, options);
+  atlaspackConfigCache.set(cachePath, config);
+  (0, _featureFlags().setFeatureFlags)(options.featureFlags);
+  return config;
+}
+function clearConfigCache() {
+  _utils().loadConfig.clear();
+  (0, _buildCache.clearBuildCaches)();
+}
+async function runTransform(workerApi, opts) {
+  let {
+    optionsRef,
+    configCachePath,
+    ...rest
+  } = opts;
+  let options = loadOptions(optionsRef, workerApi);
+  let config = await loadConfig(configCachePath, options);
+  return new _Transformation.default({
+    workerApi,
+    options,
+    config,
+    ...rest
+  }).run();
+}
+async function runValidate(workerApi, opts) {
+  let {
+    optionsRef,
+    configCachePath,
+    ...rest
+  } = opts;
+  let options = loadOptions(optionsRef, workerApi);
+  let config = await loadConfig(configCachePath, options);
+  return new _Validation.default({
+    workerApi,
+    report: _ReporterRunner.reportWorker.bind(null, workerApi),
+    options,
+    config,
+    ...rest
+  }).run();
+}
+async function runPackage(workerApi, {
+  bundle,
+  bundleGraphReference,
+  configCachePath,
+  optionsRef,
+  previousDevDeps,
+  invalidDevDeps,
+  previousInvalidations
+}) {
+  let bundleGraph = workerApi.getSharedReference(bundleGraphReference);
+  (0, _assert().default)(bundleGraph instanceof _BundleGraph.default);
+  let options = loadOptions(optionsRef, workerApi);
+  let atlaspackConfig = await loadConfig(configCachePath, options);
+  let runner = new _PackagerRunner.default({
+    config: atlaspackConfig,
+    options,
+    report: _workers().default.isWorker() ? _ReporterRunner.reportWorker.bind(null, workerApi) : _ReporterRunner.report,
+    previousDevDeps,
+    previousInvalidations
+  });
+  return runner.run(bundleGraph, bundle, invalidDevDeps);
+}
+async function childInit() {
+  await _sourceMap().init;
+  await (_rust().init === null || _rust().init === void 0 ? void 0 : (0, _rust().init)());
+}
+const PKG_RE = /node_modules[/\\]((?:@[^/\\]+[/\\][^/\\]+)|[^/\\]+)(?!.*[/\\]node_modules[/\\])/;
+function invalidateRequireCache() {
+  throw new Error('invalidateRequireCache is only for tests');
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@atlaspack/core",
+  "version": "2.12.1-canary.3354+7bb54d46a",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/atlassian-labs/atlaspack.git"
+  },
+  "main": "lib/index.js",
+  "source": "src/index.js",
+  "engines": {
+    "node": ">= 16.0.0"
+  },
+  "scripts": {
+    "test": "mocha",
+    "test-ci": "mocha",
+    "check-ts": "tsc --noEmit index.d.ts"
+  },
+  "dependencies": {
+    "@atlaspack/cache": "2.12.1-canary.3354+7bb54d46a",
+    "@atlaspack/diagnostic": "2.12.1-canary.3354+7bb54d46a",
+    "@atlaspack/events": "2.12.1-canary.3354+7bb54d46a",
+    "@atlaspack/feature-flags": "2.12.1-canary.3354+7bb54d46a",
+    "@atlaspack/fs": "2.12.1-canary.3354+7bb54d46a",
+    "@atlaspack/graph": "3.2.1-canary.3354+7bb54d46a",
+    "@atlaspack/logger": "2.12.1-canary.3354+7bb54d46a",
+    "@atlaspack/package-manager": "2.12.1-canary.3354+7bb54d46a",
+    "@atlaspack/plugin": "2.12.1-canary.3354+7bb54d46a",
+    "@atlaspack/profiler": "2.12.1-canary.3354+7bb54d46a",
+    "@atlaspack/rust": "2.12.1-canary.3354+7bb54d46a",
+    "@atlaspack/types": "2.12.1-canary.3354+7bb54d46a",
+    "@atlaspack/utils": "2.12.1-canary.3354+7bb54d46a",
+    "@atlaspack/workers": "2.12.1-canary.3354+7bb54d46a",
+    "@mischnic/json-sourcemap": "^0.1.0",
+    "@parcel/source-map": "^2.1.1",
+    "base-x": "^3.0.8",
+    "browserslist": "^4.6.6",
+    "clone": "^2.1.1",
+    "dotenv": "^7.0.0",
+    "dotenv-expand": "^5.1.0",
+    "json5": "^2.2.0",
+    "msgpackr": "^1.9.9",
+    "nullthrows": "^1.1.1",
+    "semver": "^7.5.2"
+  },
+  "devDependencies": {
+    "@atlaspack/babel-register": "2.12.0",
+    "@types/node": ">= 18",
+    "graphviz": "^0.0.9",
+    "tempy": "^0.2.1"
+  },
+  "browser": {
+    "./src/serializerCore.js": "./src/serializerCore.browser.js"
+  },
+  "gitHead": "7bb54d46a00c5ba9cdbc2ee426dcbe82c8d79a3e"
+}