@atlaspack/core 2.12.1-canary.3354

package/lib/CommittedAsset.js

@@ -0,0 +1,133 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _stream() {
+  const data = require("stream");
+  _stream = function () {
+    return data;
+  };
+  return data;
+}
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@parcel/source-map"));
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+var _assetUtils = require("./assetUtils");
+var _serializer = require("./serializer");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class CommittedAsset {
+  constructor(value, options) {
+    this.value = value;
+    this.key = this.value.contentKey;
+    this.options = options;
+  }
+  getContent() {
+    if (this.content == null) {
+      if (this.key != null) {
+        if (this.value.isLargeBlob) {
+          return this.options.cache.getStream(this.key);
+        } else {
+          return this.options.cache.getBlob(this.key);
+        }
+      } else if (this.value.astKey != null) {
+        return (0, _utils().streamFromPromise)((0, _assetUtils.generateFromAST)(this).then(({
+          content
+        }) => {
+          if (!(content instanceof _stream().Readable)) {
+            this.content = Promise.resolve(content);
+          }
+          return content;
+        }));
+      } else {
+        throw new Error('Asset has no content');
+      }
+    }
+    return this.content;
+  }
+  async getCode() {
+    let content;
+    if (this.content == null && this.key != null) {
+      this.content = this.options.cache.getBlob(this.key);
+      content = await this.content;
+    } else {
+      content = await this.getContent();
+    }
+    if (typeof content === 'string' || content instanceof Buffer) {
+      return content.toString();
+    } else if (content != null) {
+      this.content = (0, _utils().bufferStream)(content);
+      return (await this.content).toString();
+    }
+    return '';
+  }
+  async getBuffer() {
+    let content = await this.getContent();
+    if (content == null) {
+      return Buffer.alloc(0);
+    } else if (typeof content === 'string' || content instanceof Buffer) {
+      return Buffer.from(content);
+    }
+    this.content = (0, _utils().bufferStream)(content);
+    return this.content;
+  }
+  getStream() {
+    let content = this.getContent();
+    return content instanceof Promise ? (0, _utils().streamFromPromise)(content) : (0, _utils().blobToStream)(content);
+  }
+  getMapBuffer() {
+    let mapKey = this.value.mapKey;
+    if (mapKey != null && this.mapBuffer == null) {
+      this.mapBuffer = (async () => {
+        try {
+          return await this.options.cache.getBlob(mapKey);
+        } catch (err) {
+          if (err.code === 'ENOENT' && this.value.astKey != null) {
+            var _await$generateFromAS;
+            return (_await$generateFromAS = (await (0, _assetUtils.generateFromAST)(this)).map) === null || _await$generateFromAS === void 0 ? void 0 : _await$generateFromAS.toBuffer();
+          } else {
+            throw err;
+          }
+        }
+      })();
+    }
+    return this.mapBuffer ?? Promise.resolve();
+  }
+  getMap() {
+    if (this.map == null) {
+      this.map = (async () => {
+        let mapBuffer = await this.getMapBuffer();
+        if (mapBuffer) {
+          // Get sourcemap from flatbuffer
+          return new (_sourceMap().default)(this.options.projectRoot, mapBuffer);
+        }
+      })();
+    }
+    return this.map;
+  }
+  getAST() {
+    if (this.value.astKey == null) {
+      return Promise.resolve(null);
+    }
+    if (this.ast == null) {
+      this.ast = this.options.cache.getBlob(this.value.astKey).then(serializedAst => (0, _serializer.deserializeRaw)(serializedAst));
+    }
+    return this.ast;
+  }
+  getDependencies() {
+    return Array.from(this.value.dependencies.values());
+  }
+}
+exports.default = CommittedAsset;

package/lib/Dependency.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDependency = createDependency;
+exports.mergeDependencies = mergeDependencies;
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+var _types = require("./types");
+var _utils = require("./utils");
+var _projectPath = require("./projectPath");
+function createDependency(projectRoot, opts) {
+  let id = opts.id || (0, _rust().hashString)((opts.sourceAssetId ?? '') + opts.specifier + opts.env.id + (opts.target ? JSON.stringify(opts.target) : '') + (opts.pipeline ?? '') + opts.specifierType + (opts.bundleBehavior ?? '') + (opts.priority ?? 'sync') + (opts.packageConditions ? JSON.stringify(opts.packageConditions) : ''));
+  let dep = {
+    id,
+    specifier: opts.specifier,
+    specifierType: _types.SpecifierType[opts.specifierType],
+    priority: _types.Priority[opts.priority ?? 'sync'],
+    needsStableName: opts.needsStableName ?? false,
+    bundleBehavior: opts.bundleBehavior ? _types.BundleBehavior[opts.bundleBehavior] : null,
+    isEntry: opts.isEntry ?? false,
+    isOptional: opts.isOptional ?? false,
+    loc: (0, _utils.toInternalSourceLocation)(projectRoot, opts.loc),
+    env: opts.env,
+    meta: opts.meta || {},
+    target: opts.target,
+    sourceAssetId: opts.sourceAssetId,
+    sourcePath: (0, _projectPath.toProjectPath)(projectRoot, opts.sourcePath),
+    resolveFrom: (0, _projectPath.toProjectPath)(projectRoot, opts.resolveFrom),
+    range: opts.range,
+    symbols: opts.symbols && new Map([...opts.symbols].map(([k, v]) => [k, {
+      local: v.local,
+      meta: v.meta,
+      isWeak: v.isWeak,
+      loc: (0, _utils.toInternalSourceLocation)(projectRoot, v.loc)
+    }])),
+    pipeline: opts.pipeline
+  };
+  if (opts.packageConditions) {
+    convertConditions(opts.packageConditions, dep);
+  }
+  return dep;
+}
+function mergeDependencies(a, b) {
+  let {
+    meta,
+    symbols,
+    needsStableName,
+    isEntry,
+    isOptional,
+    ...other
+  } = b;
+  Object.assign(a, other);
+  Object.assign(a.meta, meta);
+  if (a.symbols && symbols) {
+    for (let [k, v] of symbols) {
+      a.symbols.set(k, v);
+    }
+  }
+  if (needsStableName) a.needsStableName = true;
+  if (isEntry) a.isEntry = true;
+  if (!isOptional) a.isOptional = false;
+}
+function convertConditions(conditions, dep) {
+  // Store common package conditions as bit flags to reduce size.
+  // Custom conditions are stored as strings.
+  let packageConditions = 0;
+  let customConditions = [];
+  for (let condition of conditions) {
+    if (_types.ExportsCondition[condition]) {
+      packageConditions |= _types.ExportsCondition[condition];
+    } else {
+      customConditions.push(condition);
+    }
+  }
+  if (packageConditions) {
+    dep.packageConditions = packageConditions;
+  }
+  if (customConditions.length) {
+    dep.customPackageConditions = customConditions;
+  }
+}

package/lib/Environment.js

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createEnvironment = createEnvironment;
+exports.mergeEnvironments = mergeEnvironments;
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+var _utils = require("./utils");
+var _Environment = _interopRequireWildcard(require("./public/Environment"));
+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; }
+const DEFAULT_ENGINES = {
+  browsers: ['> 0.25%'],
+  node: '>= 8.0.0'
+};
+function createEnvironment({
+  context,
+  engines,
+  includeNodeModules,
+  outputFormat,
+  sourceType = 'module',
+  shouldOptimize = false,
+  isLibrary = false,
+  shouldScopeHoist = false,
+  sourceMap,
+  loc
+} = {
+  /*::...null*/
+}) {
+  if (context == null) {
+    var _engines, _engines2;
+    if ((_engines = engines) !== null && _engines !== void 0 && _engines.node) {
+      context = 'node';
+    } else if ((_engines2 = engines) !== null && _engines2 !== void 0 && _engines2.browsers) {
+      context = 'browser';
+    } else {
+      context = 'browser';
+    }
+  }
+  if (engines == null) {
+    switch (context) {
+      case 'node':
+      case 'electron-main':
+        engines = {
+          node: DEFAULT_ENGINES.node
+        };
+        break;
+      case 'browser':
+      case 'web-worker':
+      case 'service-worker':
+      case 'electron-renderer':
+        engines = {
+          browsers: DEFAULT_ENGINES.browsers
+        };
+        break;
+      default:
+        engines = {};
+    }
+  }
+  if (includeNodeModules == null) {
+    switch (context) {
+      case 'node':
+      case 'electron-main':
+      case 'electron-renderer':
+        includeNodeModules = false;
+        break;
+      case 'browser':
+      case 'web-worker':
+      case 'service-worker':
+      default:
+        includeNodeModules = true;
+        break;
+    }
+  }
+  if (outputFormat == null) {
+    switch (context) {
+      case 'node':
+      case 'electron-main':
+      case 'electron-renderer':
+        outputFormat = 'commonjs';
+        break;
+      default:
+        outputFormat = 'global';
+        break;
+    }
+  }
+  let res = {
+    id: '',
+    context,
+    engines,
+    includeNodeModules,
+    outputFormat,
+    sourceType,
+    isLibrary,
+    shouldOptimize,
+    shouldScopeHoist,
+    sourceMap,
+    loc
+  };
+  res.id = getEnvironmentHash(res);
+  return res;
+}
+function mergeEnvironments(projectRoot, a, b) {
+  // If merging the same object, avoid copying.
+  if (a === b || !b) {
+    return a;
+  }
+  if (b instanceof _Environment.default) {
+    return (0, _Environment.environmentToInternalEnvironment)(b);
+  }
+
+  // $FlowFixMe - ignore the `id` that is already on a
+  return createEnvironment({
+    ...a,
+    ...b,
+    loc: b.loc ? (0, _utils.toInternalSourceLocation)(projectRoot, b.loc) : a.loc
+  });
+}
+function getEnvironmentHash(env) {
+  return (0, _rust().hashString)(JSON.stringify([env.context, env.engines, env.includeNodeModules, env.outputFormat, env.sourceType, env.isLibrary, env.shouldOptimize, env.shouldScopeHoist, env.sourceMap]));
+}

package/lib/InternalConfig.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createConfig = createConfig;
+var _projectPath = require("./projectPath");
+var _Environment = require("./Environment");
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+function createConfig({
+  plugin,
+  isSource,
+  searchPath,
+  env,
+  result,
+  invalidateOnFileChange,
+  invalidateOnConfigKeyChange,
+  invalidateOnFileCreate,
+  invalidateOnEnvChange,
+  invalidateOnOptionChange,
+  devDeps,
+  invalidateOnStartup,
+  invalidateOnBuild
+}) {
+  let environment = env ?? (0, _Environment.createEnvironment)();
+  return {
+    id: (0, _rust().hashString)(plugin + (0, _projectPath.fromProjectPathRelative)(searchPath) + environment.id + String(isSource)),
+    isSource: isSource ?? false,
+    searchPath,
+    env: environment,
+    result: result ?? null,
+    cacheKey: null,
+    invalidateOnFileChange: invalidateOnFileChange ?? new Set(),
+    invalidateOnConfigKeyChange: invalidateOnConfigKeyChange ?? [],
+    invalidateOnFileCreate: invalidateOnFileCreate ?? [],
+    invalidateOnEnvChange: invalidateOnEnvChange ?? new Set(),
+    invalidateOnOptionChange: invalidateOnOptionChange ?? new Set(),
+    devDeps: devDeps ?? [],
+    invalidateOnStartup: invalidateOnStartup ?? false,
+    invalidateOnBuild: invalidateOnBuild ?? false
+  };
+}