@atlaspack/core 2.16.2-canary.182 → 2.16.2-canary.184

package/lib/requests/TargetRequest.js

@@ -70,6 +70,13 @@ var _utils2 = require("../utils");
 var _projectPath = require("../projectPath");
 var _RequestTracker = require("../RequestTracker");
 var _EnvironmentManager = require("../EnvironmentManager");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 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; }
@@ -115,8 +122,6 @@ function skipTarget(targetName, exclusiveTarget, descriptorSource) {
 
   return exclusiveTarget == null ? descriptorSource != null : targetName !== exclusiveTarget;
 }
-
-// @ts-expect-error TS7031
 async function run({
   input,
   api,
@@ -124,10 +129,35 @@ async function run({
 }) {
   let targetResolver = new TargetResolver(api, (0, _utils2.optionsProxy)(options, api.invalidateOnOptionChange));
   let targets = await targetResolver.resolve((0, _projectPath.fromProjectPath)(options.projectRoot, input.packagePath), input.target);
+
+  // Filter targets based on allowExplicitTargetEntries feature flag
+  if ((0, _featureFlags().getFeatureFlag)('allowExplicitTargetEntries') && options.targets &&
+  // Only explicit targets are allowed (i.e. an object of targets)
+  !Array.isArray(options.targets)) {
+    // Check if ALL targets have sources - only apply new behavior if they do
+    const allTargetsHaveSources = targets.every(t => t.source);
+    if (allTargetsHaveSources) {
+      // Get the current entry file path relative to project root
+      const currentEntryPath = input.filePath;
+
+      // Filter targets to only include those whose source matches the current entry
+      targets = targets.filter(target => {
+        // Handle both string and array sources
+        const sources = Array.isArray(target.source) ? target.source : [target.source];
+
+        // Check if current entry matches any of the target sources
+        return sources.some(source => {
+          const targetSourcePath = (0, _projectPath.toProjectPath)(options.projectRoot, _path().default.resolve((0, _projectPath.fromProjectPath)(options.projectRoot, input.packagePath), (0, _nullthrows().default)(source, 'Source must be not be undefined when specified')));
+          return targetSourcePath === currentEntryPath;
+        });
+      });
+    } else {
+      // If not all targets have sources, fall back to old behavior (skip targets with sources)
+      targets = targets.filter(target => !target.source);
+    }
+  }
   assertTargetsAreNotEntries(targets, input, options);
-  let configResult = (0, _nullthrows().default)(
-  // @ts-expect-error TS2347
-  await api.runRequest((0, _AtlaspackConfigRequest.default)()));
+  let configResult = (0, _nullthrows().default)(await api.runRequest((0, _AtlaspackConfigRequest.default)()));
   let atlaspackConfig = (0, _AtlaspackConfigRequest.getCachedAtlaspackConfig)(configResult, options);
 
   // Find named pipelines for each target.
@@ -236,7 +266,17 @@ class TargetResolver {
             target.source = descriptor.source;
           }
           return target;
-        }).filter(target => !skipTarget(target.name, exclusiveTarget, target.source));
+        }).filter(target => (0, _featureFlags().getFeatureFlag)('allowExplicitTargetEntries') && this.options.entries.length !== 0 || !skipTarget(target.name, exclusiveTarget, target.source));
+
+        // Apply allowExplicitTargetEntries filtering logic
+        if ((0, _featureFlags().getFeatureFlag)('allowExplicitTargetEntries')) {
+          // Check if ALL targets have sources - only apply new behavior if they do
+          const allTargetsHaveSources = targets.every(t => t.source);
+          if (!allTargetsHaveSources) {
+            // If not all targets have sources, fall back to old behavior (skip targets with sources)
+            targets = targets.filter(target => !target.source);
+          }
+        }
       }
       let serve = this.options.serveOptions;
       if (serve && targets.length > 0) {

package/lib/requests/WriteBundlesRequest.js

@@ -12,6 +12,7 @@ function _featureFlags() {
   return data;
 }
 var _RequestTracker = require("../RequestTracker");
+var _types = require("../types");
 var _ReporterRunner = require("../ReporterRunner");
 var _constants = require("../constants");
 var _projectPath = require("../projectPath");
@@ -55,8 +56,6 @@ function createWriteBundlesRequest(input) {
     input
   };
 }
-
-// @ts-expect-error TS7031
 async function run({
   input,
   api,
@@ -82,11 +81,7 @@ async function run({
   const allBundles = bundleGraph.getBundles({
     includeInline: (0, _featureFlags().getFeatureFlag)('inlineBundlesSourceMapFixes')
   });
-  const bundles = allBundles.filter(
-  // @ts-expect-error TS7006
-  bundle => bundle.bundleBehavior !== 'inline' && bundle.bundleBehavior !== 'inline-isolated')
-  // @ts-expect-error TS7006
-  .filter(bundle => {
+  const bundles = allBundles.filter(bundle => bundle.bundleBehavior !== _types.BundleBehavior.inline && bundle.bundleBehavior !== _types.BundleBehavior.inlineIsolated).filter(bundle => {
     // Do not package and write placeholder bundles to disk. We just
     // need to update the name so other bundles can reference it.
     if (bundle.isPlaceholder) {
@@ -107,9 +102,7 @@ async function run({
     }
     return true;
   });
-  let cachedBundles = new Set(
-  // @ts-expect-error TS7006
-  bundles.filter(b => api.canSkipSubrequest(bundleGraph.getHash(b))));
+  let cachedBundles = new Set(bundles.filter(b => api.canSkipSubrequest(bundleGraph.getHash(b))));
 
   // Package on the main thread if there is only one bundle to package.
   // This avoids the cost of serializing the bundle graph for single file change builds.
@@ -117,9 +110,7 @@ async function run({
   try {
     let completeBundles = cachedBundles.size;
     reportPackagingProgress(completeBundles, bundles.length);
-    await Promise.all(
-    // @ts-expect-error TS7006
-    bundles.map(async bundle => {
+    await Promise.all(bundles.map(async bundle => {
       let request = (0, _PackageRequest.createPackageRequest)({
         bundle,
         bundleGraph,
@@ -159,17 +150,13 @@ async function run({
       }
     }));
     assignComplexNameHashes(hashRefToNameHash, bundles, bundleInfoMap, options);
-    await Promise.all(
-    // @ts-expect-error TS7006
-    bundles.map(bundle => {
+    await Promise.all(bundles.map(bundle => {
       let promise = writeEarlyPromises[bundle.id] ?? api.runRequest((0, _WriteBundleRequest.default)({
         bundle,
         info: bundleInfoMap[bundle.id],
         hashRefToNameHash,
         bundleGraph
       }));
-
-      // @ts-expect-error TS7006
       return promise.then(r => res.set(bundle.id, r));
     }));
     api.storeResult(res);
@@ -178,18 +165,12 @@ async function run({
     await dispose();
   }
 }
-function assignComplexNameHashes(hashRefToNameHash,
-// @ts-expect-error TS2304
-bundles, bundleInfoMap,
-// @ts-expect-error TS2304
-options) {
+function assignComplexNameHashes(hashRefToNameHash, bundles, bundleInfoMap, options) {
   for (let bundle of bundles) {
     if (hashRefToNameHash.get(bundle.hashReference) != null) {
       continue;
     }
-    hashRefToNameHash.set(bundle.hashReference, options.shouldContentHash ? (0, _rust().hashString)([...getBundlesIncludedInHash(bundle.id, bundleInfoMap)]
-    // @ts-expect-error TS2538
-    .map(bundleId => bundleInfoMap[bundleId].hash).join(':')).slice(-8) : bundle.id.slice(-8));
+    hashRefToNameHash.set(bundle.hashReference, options.shouldContentHash ? (0, _rust().hashString)([...getBundlesIncludedInHash(bundle.id, bundleInfoMap)].map(bundleId => bundleInfoMap[bundleId].hash).join(':')).slice(-8) : bundle.id.slice(-8));
   }
 }
 function getBundlesIncludedInHash(bundleId, bundleInfoMap, included = new Set()) {

package/lib/resolveOptions.js

@@ -106,6 +106,21 @@ async function resolveOptions(initialOptions) {
   } else {
     entries = [_path().default.resolve(inputCwd, initialOptions.entries)];
   }
+
+  // When allowExplicitTargetEntries is enabled and no entries are provided,
+  // automatically derive entries from target sources
+  if ((0, _featureFlags().getFeatureFlag)('allowExplicitTargetEntries') && initialOptions.targets && !Array.isArray(initialOptions.targets) && entries.length === 0) {
+    const targetSources = new Set();
+    for (const [, target] of Object.entries(initialOptions.targets)) {
+      if (target.source) {
+        const sources = Array.isArray(target.source) ? target.source : [target.source];
+        for (const source of sources) {
+          targetSources.add(source);
+        }
+      }
+    }
+    entries = Array.from(targetSources);
+  }
   let shouldMakeEntryReferFolder = false;
   if (entries.length === 1 && !(0, _utils().isGlob)(entries[0])) {
     let [entry] = entries;

package/lib/types/requests/WriteBundlesRequest.d.ts

@@ -3,7 +3,7 @@ import type { Async } from '@atlaspack/types';
 import type { SharedReference } from '@atlaspack/workers';
 import type { StaticRunOpts } from '../RequestTracker';
 import { requestTypes } from '../RequestTracker';
-import type { PackagedBundleInfo } from '../types';
+import { type PackagedBundleInfo } from '../types';
 import type BundleGraph from '../BundleGraph';
 type WriteBundlesRequestInput = {
     bundleGraph: BundleGraph;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.16.2-canary.182+36b78a2f6",
+  "version": "2.16.2-canary.184+038e87a78",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -23,21 +23,21 @@
     "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3-canary.250+36b78a2f6",
-    "@atlaspack/cache": "3.1.1-canary.182+36b78a2f6",
-    "@atlaspack/diagnostic": "2.14.1-canary.250+36b78a2f6",
-    "@atlaspack/events": "2.14.1-canary.250+36b78a2f6",
-    "@atlaspack/feature-flags": "2.14.1-canary.250+36b78a2f6",
-    "@atlaspack/fs": "2.14.5-canary.182+36b78a2f6",
-    "@atlaspack/graph": "3.4.1-canary.250+36b78a2f6",
-    "@atlaspack/logger": "2.14.5-canary.182+36b78a2f6",
-    "@atlaspack/package-manager": "2.14.5-canary.182+36b78a2f6",
-    "@atlaspack/plugin": "2.14.5-canary.182+36b78a2f6",
-    "@atlaspack/profiler": "2.14.1-canary.250+36b78a2f6",
-    "@atlaspack/rust": "3.2.1-canary.182+36b78a2f6",
-    "@atlaspack/types": "2.14.5-canary.182+36b78a2f6",
-    "@atlaspack/utils": "2.14.5-canary.182+36b78a2f6",
-    "@atlaspack/workers": "2.14.5-canary.182+36b78a2f6",
+    "@atlaspack/build-cache": "2.13.3-canary.252+038e87a78",
+    "@atlaspack/cache": "3.1.1-canary.184+038e87a78",
+    "@atlaspack/diagnostic": "2.14.1-canary.252+038e87a78",
+    "@atlaspack/events": "2.14.1-canary.252+038e87a78",
+    "@atlaspack/feature-flags": "2.14.1-canary.252+038e87a78",
+    "@atlaspack/fs": "2.14.5-canary.184+038e87a78",
+    "@atlaspack/graph": "3.4.1-canary.252+038e87a78",
+    "@atlaspack/logger": "2.14.5-canary.184+038e87a78",
+    "@atlaspack/package-manager": "2.14.5-canary.184+038e87a78",
+    "@atlaspack/plugin": "2.14.5-canary.184+038e87a78",
+    "@atlaspack/profiler": "2.14.1-canary.252+038e87a78",
+    "@atlaspack/rust": "3.2.1-canary.184+038e87a78",
+    "@atlaspack/types": "2.14.5-canary.184+038e87a78",
+    "@atlaspack/utils": "2.14.5-canary.184+038e87a78",
+    "@atlaspack/workers": "2.14.5-canary.184+038e87a78",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -62,5 +62,5 @@
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
   "type": "commonjs",
-  "gitHead": "36b78a2f6c36f02273ee9cabfe5935cd6cf0a725"
+  "gitHead": "038e87a7858d39556d59d3a2d17db534d45f62c6"
 }

package/src/requests/TargetRequest.ts

@@ -47,6 +47,7 @@ import {optionsProxy, toInternalSourceLocation} from '../utils';
 import {fromProjectPath, toProjectPath, joinProjectPath} from '../projectPath';
 import {requestTypes} from '../RequestTracker';
 import {fromEnvironmentId} from '../EnvironmentManager';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 type RunOpts<TResult> = {
   input: Entry;
@@ -119,8 +120,7 @@ export function skipTarget(
     : targetName !== exclusiveTarget;
 }
 
-// @ts-expect-error TS7031
-async function run({input, api, options}) {
+async function run({input, api, options}: RunOpts<TargetRequestResult>) {
   let targetResolver = new TargetResolver(
     api,
     optionsProxy(options, api.invalidateOnOptionChange),
@@ -130,10 +130,50 @@ async function run({input, api, options}) {
     input.target,
   );
 
+  // Filter targets based on allowExplicitTargetEntries feature flag
+  if (
+    getFeatureFlag('allowExplicitTargetEntries') &&
+    options.targets &&
+    // Only explicit targets are allowed (i.e. an object of targets)
+    !Array.isArray(options.targets)
+  ) {
+    // Check if ALL targets have sources - only apply new behavior if they do
+    const allTargetsHaveSources = targets.every((t) => t.source);
+    if (allTargetsHaveSources) {
+      // Get the current entry file path relative to project root
+      const currentEntryPath = input.filePath;
+
+      // Filter targets to only include those whose source matches the current entry
+      targets = targets.filter((target) => {
+        // Handle both string and array sources
+        const sources = Array.isArray(target.source)
+          ? target.source
+          : [target.source];
+
+        // Check if current entry matches any of the target sources
+        return sources.some((source) => {
+          const targetSourcePath = toProjectPath(
+            options.projectRoot,
+            path.resolve(
+              fromProjectPath(options.projectRoot, input.packagePath),
+              nullthrows(
+                source,
+                'Source must be not be undefined when specified',
+              ),
+            ),
+          );
+          return targetSourcePath === currentEntryPath;
+        });
+      });
+    } else {
+      // If not all targets have sources, fall back to old behavior (skip targets with sources)
+      targets = targets.filter((target) => !target.source);
+    }
+  }
+
   assertTargetsAreNotEntries(targets, input, options);
 
   let configResult = nullthrows(
-    // @ts-expect-error TS2347
     await api.runRequest<null, ConfigAndCachePath>(
       createAtlaspackConfigRequest(),
     ),
@@ -329,8 +369,21 @@ export class TargetResolver {
           })
           .filter(
             (target) =>
+              (getFeatureFlag('allowExplicitTargetEntries') &&
+                this.options.entries.length !== 0) ||
               !skipTarget(target.name, exclusiveTarget, target.source),
           );
+
+        // Apply allowExplicitTargetEntries filtering logic
+        if (getFeatureFlag('allowExplicitTargetEntries')) {
+          // Check if ALL targets have sources - only apply new behavior if they do
+          const allTargetsHaveSources = targets.every((t) => t.source);
+
+          if (!allTargetsHaveSources) {
+            // If not all targets have sources, fall back to old behavior (skip targets with sources)
+            targets = targets.filter((target) => !target.source);
+          }
+        }
       }
 
       let serve = this.options.serveOptions;

package/src/requests/WriteBundlesRequest.ts

@@ -4,7 +4,12 @@ import {getFeatureFlag} from '@atlaspack/feature-flags';
 import type {SharedReference} from '@atlaspack/workers';
 import type {StaticRunOpts} from '../RequestTracker';
 import {requestTypes} from '../RequestTracker';
-import type {PackagedBundleInfo} from '../types';
+import {
+  BundleBehavior,
+  type PackagedBundleInfo,
+  type Bundle,
+  type AtlaspackOptions,
+} from '../types';
 import type BundleGraph from '../BundleGraph';
 import type {BundleInfo} from '../PackagerRunner';
 import {report} from '../ReporterRunner';
@@ -66,8 +71,12 @@ export default function createWriteBundlesRequest(
   };
 }
 
-// @ts-expect-error TS7031
-async function run({input, api, farm, options}) {
+async function run({
+  input,
+  api,
+  farm,
+  options,
+}: RunInput<WriteBundlesRequestResult>) {
   let {bundleGraph, optionsRef} = input;
   let {ref, dispose} = await farm.createSharedReference(bundleGraph);
 
@@ -77,7 +86,7 @@ async function run({input, api, farm, options}) {
   let bundleInfoMap: {
     [key: string]: BundleInfo;
   } = {};
-  let writeEarlyPromises: Record<string, any> = {};
+  let writeEarlyPromises: Record<string, Promise<PackagedBundleInfo>> = {};
   let hashRefToNameHash = new Map();
 
   // Include inline bundles so that non-inline bundles referenced from inline bundles are written to
@@ -87,12 +96,10 @@ async function run({input, api, farm, options}) {
   });
   const bundles = allBundles
     .filter(
-      // @ts-expect-error TS7006
       (bundle) =>
-        bundle.bundleBehavior !== 'inline' &&
-        bundle.bundleBehavior !== 'inline-isolated',
+        bundle.bundleBehavior !== BundleBehavior.inline &&
+        bundle.bundleBehavior !== BundleBehavior.inlineIsolated,
     )
-    // @ts-expect-error TS7006
     .filter((bundle) => {
       // Do not package and write placeholder bundles to disk. We just
       // need to update the name so other bundles can reference it.
@@ -119,7 +126,6 @@ async function run({input, api, farm, options}) {
     });
 
   let cachedBundles = new Set(
-    // @ts-expect-error TS7006
     bundles.filter((b) => api.canSkipSubrequest(bundleGraph.getHash(b))),
   );
 
@@ -133,7 +139,6 @@ async function run({input, api, farm, options}) {
     reportPackagingProgress(completeBundles, bundles.length);
 
     await Promise.all(
-      // @ts-expect-error TS7006
       bundles.map(async (bundle) => {
         let request = createPackageRequest({
           bundle,
@@ -185,7 +190,6 @@ async function run({input, api, farm, options}) {
     );
     assignComplexNameHashes(hashRefToNameHash, bundles, bundleInfoMap, options);
     await Promise.all(
-      // @ts-expect-error TS7006
       bundles.map((bundle) => {
         let promise =
           writeEarlyPromises[bundle.id] ??
@@ -198,7 +202,6 @@ async function run({input, api, farm, options}) {
             }),
           );
 
-        // @ts-expect-error TS7006
         return promise.then((r) => res.set(bundle.id, r));
       }),
     );
@@ -212,12 +215,10 @@ async function run({input, api, farm, options}) {
 
 function assignComplexNameHashes(
   hashRefToNameHash: Map<string, string>,
-  // @ts-expect-error TS2304
   bundles: Array<Bundle>,
   bundleInfoMap: {
     [key: string]: BundleInfo;
   },
-  // @ts-expect-error TS2304
   options: AtlaspackOptions,
 ) {
   for (let bundle of bundles) {
@@ -229,7 +230,6 @@ function assignComplexNameHashes(
       options.shouldContentHash
         ? hashString(
             [...getBundlesIncludedInHash(bundle.id, bundleInfoMap)]
-              // @ts-expect-error TS2538
               .map((bundleId) => bundleInfoMap[bundleId].hash)
               .join(':'),
           ).slice(-8)
@@ -243,7 +243,7 @@ function getBundlesIncludedInHash(
   bundleInfoMap: {
     [key: string]: BundleInfo;
   },
-  included = new Set(),
+  included = new Set<string>(),
 ) {
   included.add(bundleId);
   for (let hashRef of bundleInfoMap[bundleId]?.hashReferences ?? []) {

package/src/resolveOptions.ts

@@ -91,6 +91,29 @@ export default async function resolveOptions(
     entries = [path.resolve(inputCwd, initialOptions.entries)];
   }
 
+  // When allowExplicitTargetEntries is enabled and no entries are provided,
+  // automatically derive entries from target sources
+  if (
+    getFeatureFlag('allowExplicitTargetEntries') &&
+    initialOptions.targets &&
+    !Array.isArray(initialOptions.targets) &&
+    entries.length === 0
+  ) {
+    const targetSources = new Set<string>();
+
+    for (const [, target] of Object.entries(initialOptions.targets)) {
+      if (target.source) {
+        const sources = Array.isArray(target.source)
+          ? target.source
+          : [target.source];
+        for (const source of sources) {
+          targetSources.add(source);
+        }
+      }
+    }
+    entries = Array.from(targetSources);
+  }
+
   let shouldMakeEntryReferFolder = false;
   if (entries.length === 1 && !isGlob(entries[0])) {
     let [entry] = entries;