@atlaspack/core 2.16.2-canary.183 → 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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.16.2-canary.183+8604d2a49",
+  "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.251+8604d2a49",
-    "@atlaspack/cache": "3.1.1-canary.183+8604d2a49",
-    "@atlaspack/diagnostic": "2.14.1-canary.251+8604d2a49",
-    "@atlaspack/events": "2.14.1-canary.251+8604d2a49",
-    "@atlaspack/feature-flags": "2.14.1-canary.251+8604d2a49",
-    "@atlaspack/fs": "2.14.5-canary.183+8604d2a49",
-    "@atlaspack/graph": "3.4.1-canary.251+8604d2a49",
-    "@atlaspack/logger": "2.14.5-canary.183+8604d2a49",
-    "@atlaspack/package-manager": "2.14.5-canary.183+8604d2a49",
-    "@atlaspack/plugin": "2.14.5-canary.183+8604d2a49",
-    "@atlaspack/profiler": "2.14.1-canary.251+8604d2a49",
-    "@atlaspack/rust": "3.2.1-canary.183+8604d2a49",
-    "@atlaspack/types": "2.14.5-canary.183+8604d2a49",
-    "@atlaspack/utils": "2.14.5-canary.183+8604d2a49",
-    "@atlaspack/workers": "2.14.5-canary.183+8604d2a49",
+    "@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": "8604d2a49ace5e9194ec4f76e71f06b93610f6b4"
+  "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/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;