@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/test/{BundleGraph.test.js → BundleGraph.test.ts}

@@ -1,13 +1,8 @@
-// @flow strict-local
-
 import assert from 'assert';
 import BundleGraph from '../src/BundleGraph';
 import {DEFAULT_ENV, DEFAULT_TARGETS} from './test-utils';
 import AssetGraph, {nodeFromAssetGroup} from '../src/AssetGraph';
-import {
-  createAsset as _createAsset,
-  type AssetOptions,
-} from '../src/assetUtils';
+import {createAsset as _createAsset, AssetOptions} from '../src/assetUtils';
 import {createDependency as _createDependency} from '../src/Dependency';
 import {toProjectPath} from '../src/projectPath';
 
@@ -15,7 +10,7 @@ function createAsset(opts: AssetOptions) {
   return _createAsset('/', opts);
 }
 
-function createDependency(opts) {
+function createDependency(opts: any) {
   return _createDependency('/', opts);
 }
 
@@ -29,7 +24,7 @@ describe('BundleGraph', () => {
       false,
     );
     assert.deepEqual(
-      getAssets(bundleGraph).map((a) => bundleGraph.getAssetPublicId(a)),
+      getAssets(bundleGraph).map((a: any) => bundleGraph.getAssetPublicId(a)),
       ['296TI', '4DGUq'],
     );
   });
@@ -40,15 +35,15 @@ describe('BundleGraph', () => {
       false,
     );
     assert.deepEqual(
-      getAssets(bundleGraph).map((a) => bundleGraph.getAssetPublicId(a)),
+      getAssets(bundleGraph).map((a: any) => bundleGraph.getAssetPublicId(a)),
       ['296TI', '296TII'],
     );
   });
 });
 
-function getAssets(bundleGraph) {
-  let assets = [];
-  bundleGraph.traverse((node) => {
+function getAssets(bundleGraph: any) {
+  let assets: Array<any> = [];
+  bundleGraph.traverse((node: any) => {
     if (node.type === 'asset') {
       assets.push(node.value);
     }
@@ -56,7 +51,7 @@ function getAssets(bundleGraph) {
   return assets;
 }
 
-const stats = {size: 0, time: 0};
+const stats = {size: 0, time: 0} as const;
 function createMockAssetGraph(ids: [string, string]) {
   let graph = new AssetGraph();
   graph.setRootConnections({entries: [toProjectPath('/', '/index')]});

package/test/{Dependency.test.js → Dependency.test.ts}

@@ -1,4 +1,3 @@
-// @flow
 import expect from 'expect';
 import {createDependencyId} from '../src/Dependency';
 import {createEnvironment} from '../src/Environment';
@@ -27,7 +26,7 @@ describe('Dependency', () => {
         specifierType: 'esm',
         target: {
           name: 'test-1234',
-          distDir: (('dist-dir': any): ProjectPath),
+          distDir: 'dist-dir' as ProjectPath,
           env: createEnvironment(),
           publicUrl: 'public-url',
           source: '1234',
@@ -39,7 +38,7 @@ describe('Dependency', () => {
         specifierType: 'esm',
         target: {
           name: 'test-1234',
-          distDir: (('dist-dir': any): ProjectPath),
+          distDir: 'dist-dir' as ProjectPath,
           env: createEnvironment(),
           publicUrl: 'public-url',
           source: '5678', // <- this is different

package/test/{EntryRequest.test.js → EntryRequest.test.ts}

@@ -1,4 +1,3 @@
-// @flow strict-local
 import assert from 'assert';
 import path from 'path';
 import {md} from '@atlaspack/diagnostic';
@@ -12,7 +11,7 @@ const DEFAULT_OPTIONS = {
     ..._DEFAULT_OPTIONS.defaultTargetOptions,
     sourceMaps: true,
   },
-};
+} as const;
 
 const INVALID_SOURCE_MISSING_FIXTURE_PATH = path.join(
   __dirname,
@@ -44,7 +43,6 @@ describe('EntryResolver', function () {
 
   it('rejects missing source in package.json', async function () {
     this.timeout(10000);
-    // $FlowFixMe assert.rejects is Node 10+
     await assert.rejects(
       () => entryResolver.resolveEntry(INVALID_SOURCE_MISSING_FIXTURE_PATH),
       {
@@ -84,7 +82,6 @@ describe('EntryResolver', function () {
   });
   it('rejects non-file source in package.json', async function () {
     this.timeout(10000);
-    // $FlowFixMe assert.rejects is Node 10+
     await assert.rejects(
       () => entryResolver.resolveEntry(INVALID_SOURCE_NOT_FILE_FIXTURE_PATH),
       {
@@ -123,7 +120,6 @@ describe('EntryResolver', function () {
   });
   it('rejects missing target source in package.json', async function () {
     this.timeout(10000);
-    // $FlowFixMe assert.rejects is Node 10+
     await assert.rejects(
       () =>
         entryResolver.resolveEntry(INVALID_TARGET_SOURCE_MISSING_FIXTURE_PATH),
@@ -167,7 +163,6 @@ describe('EntryResolver', function () {
   });
   it('rejects non-file target source in package.json', async function () {
     this.timeout(10000);
-    // $FlowFixMe assert.rejects is Node 10+
     await assert.rejects(
       () =>
         entryResolver.resolveEntry(INVALID_TARGET_SOURCE_NOT_FILE_FIXTURE_PATH),

package/test/Environment.test.ts

@@ -0,0 +1,153 @@
+import assert from 'assert';
+import expect from 'expect';
+import {createEnvironment} from '../src/Environment';
+import {initializeMonitoring} from '@atlaspack/rust';
+import {fromEnvironmentId} from '../src/EnvironmentManager';
+
+describe('Environment', () => {
+  it('assigns a default environment with nothing passed', () => {
+    assert.deepEqual(fromEnvironmentId(createEnvironment()), {
+      id: 'd821e85f6b50315e',
+      context: 'browser',
+      customEnv: undefined,
+      engines: {
+        browsers: ['> 0.25%'],
+      },
+      includeNodeModules: true,
+      outputFormat: 'global',
+      isLibrary: false,
+      shouldOptimize: false,
+      shouldScopeHoist: false,
+      sourceMap: undefined,
+      loc: undefined,
+      sourceType: 'module',
+      unstableSingleFileOutput: false,
+    });
+  });
+
+  it('assigns a node context if a node engine is given', () => {
+    assert.deepEqual(
+      fromEnvironmentId(createEnvironment({engines: {node: '>= 10.0.0'}})),
+      {
+        id: '2320af923a717577',
+        context: 'node',
+        customEnv: undefined,
+        engines: {
+          node: '>= 10.0.0',
+        },
+        includeNodeModules: false,
+        outputFormat: 'commonjs',
+        isLibrary: false,
+        shouldOptimize: false,
+        shouldScopeHoist: false,
+        sourceMap: undefined,
+        loc: undefined,
+        sourceType: 'module',
+        unstableSingleFileOutput: false,
+      },
+    );
+  });
+
+  it('assigns a browser context if browser engines are given', () => {
+    assert.deepEqual(
+      fromEnvironmentId(
+        createEnvironment({engines: {browsers: ['last 1 version']}}),
+      ),
+      {
+        id: '75603271034eff15',
+        context: 'browser',
+        customEnv: undefined,
+        engines: {
+          browsers: ['last 1 version'],
+        },
+        includeNodeModules: true,
+        outputFormat: 'global',
+        isLibrary: false,
+        shouldOptimize: false,
+        shouldScopeHoist: false,
+        sourceMap: undefined,
+        loc: undefined,
+        sourceType: 'module',
+        unstableSingleFileOutput: false,
+      },
+    );
+  });
+
+  it('assigns default engines for node', () => {
+    assert.deepEqual(fromEnvironmentId(createEnvironment({context: 'node'})), {
+      id: 'e45cc12216f7857d',
+      context: 'node',
+      customEnv: undefined,
+      engines: {
+        node: '>= 8.0.0',
+      },
+      includeNodeModules: false,
+      outputFormat: 'commonjs',
+      isLibrary: false,
+      shouldOptimize: false,
+      shouldScopeHoist: false,
+      sourceMap: undefined,
+      loc: undefined,
+      sourceType: 'module',
+      unstableSingleFileOutput: false,
+    });
+  });
+
+  it('assigns default engines for browsers', () => {
+    assert.deepEqual(
+      fromEnvironmentId(createEnvironment({context: 'browser'})),
+      {
+        id: 'd821e85f6b50315e',
+        context: 'browser',
+        customEnv: undefined,
+        engines: {
+          browsers: ['> 0.25%'],
+        },
+        includeNodeModules: true,
+        outputFormat: 'global',
+        isLibrary: false,
+        shouldOptimize: false,
+        shouldScopeHoist: false,
+        sourceMap: undefined,
+        loc: undefined,
+        sourceType: 'module',
+        unstableSingleFileOutput: false,
+      },
+    );
+  });
+
+  it('assigns default engines for tesseract (same as web-worker)', () => {
+    assert.deepEqual(
+      fromEnvironmentId(createEnvironment({context: 'tesseract'})),
+      {
+        id: '9917be65326c5de9',
+        context: 'tesseract',
+        customEnv: undefined,
+        engines: {
+          browsers: ['> 0.25%'],
+        },
+        includeNodeModules: true,
+        outputFormat: 'global',
+        isLibrary: false,
+        shouldOptimize: false,
+        shouldScopeHoist: false,
+        sourceMap: undefined,
+        loc: undefined,
+        sourceType: 'module',
+        unstableSingleFileOutput: false,
+      },
+    );
+  });
+});
+
+describe('createEnvironment', function () {
+  it('returns a stable hash', () => {
+    try {
+      initializeMonitoring();
+    } catch (_err: any) {
+      /* ignore */
+    }
+    const environment = createEnvironment({});
+    expect(fromEnvironmentId(environment).id).toEqual('d821e85f6b50315e');
+  });
+});

package/test/EnvironmentManager.test.ts

@@ -0,0 +1,188 @@
+import assert from 'assert';
+import nullthrows from 'nullthrows';
+import sinon from 'sinon';
+import {ATLASPACK_VERSION} from '../src/constants';
+import {DEFAULT_FEATURE_FLAGS, setFeatureFlags} from '@atlaspack/feature-flags';
+import {setAllEnvironments, getAllEnvironments} from '@atlaspack/rust';
+import {
+  loadEnvironmentsFromCache,
+  writeEnvironmentsToCache,
+} from '../src/EnvironmentManager';
+import {DEFAULT_OPTIONS} from './test-utils';
+import {LMDBLiteCache} from '@atlaspack/cache';
+import {getEnvironmentHash} from '../src/Environment';
+
+const options = {
+  ...DEFAULT_OPTIONS,
+  cache: new LMDBLiteCache(DEFAULT_OPTIONS.cacheDir),
+} as const;
+
+describe('EnvironmentManager', () => {
+  const envWithId = (env: any) => {
+    return {
+      ...env,
+      id: getEnvironmentHash(env),
+    };
+  };
+
+  const env1 = envWithId({
+    context: 'browser',
+    engines: {browsers: ['> 0.25%']},
+    includeNodeModules: true,
+    outputFormat: 'global',
+    isLibrary: false,
+    shouldOptimize: false,
+    shouldScopeHoist: false,
+    loc: undefined,
+    sourceMap: undefined,
+    sourceType: 'module',
+    unstableSingleFileOutput: false,
+  } as const);
+  const env2 = envWithId({
+    context: 'node',
+    engines: {
+      browsers: [],
+      node: '>= 8',
+    },
+    includeNodeModules: false,
+    outputFormat: 'commonjs',
+    isLibrary: true,
+    shouldOptimize: true,
+    shouldScopeHoist: true,
+    loc: null,
+    sourceMap: null,
+    sourceType: 'module',
+    unstableSingleFileOutput: false,
+  } as const);
+
+  beforeEach(async () => {
+    await options.cache.ensure();
+
+    for (const key of options.cache.keys()) {
+      await options.cache.getNativeRef().delete(key);
+    }
+    setAllEnvironments([]);
+
+    setFeatureFlags({
+      ...DEFAULT_FEATURE_FLAGS,
+      environmentDeduplication: true,
+    });
+  });
+
+  it('should store environments by ID in the cache', async () => {
+    setAllEnvironments([env1]);
+    await writeEnvironmentsToCache(options.cache);
+
+    const cachedEnv1 = await options.cache.get(
+      `Environment/${ATLASPACK_VERSION}/${env1.id}`,
+    );
+    assert.deepEqual(cachedEnv1, env1, 'Environment 1 should be cached');
+  });
+
+  it('should list all environment IDs in the environment manager', async () => {
+    const environmentIds = [env1.id, env2.id];
+    setAllEnvironments([env1, env2]);
+    await writeEnvironmentsToCache(options.cache);
+
+    const cachedEnvIds: string[] | null | undefined = await options.cache.get(
+      `EnvironmentManager/${ATLASPACK_VERSION}`,
+    );
+    const cachedIdsArray = nullthrows(cachedEnvIds);
+    assert.equal(
+      cachedIdsArray.length,
+      environmentIds.length,
+      'Should have same number of IDs',
+    );
+    assert(
+      environmentIds.every((id: any) => cachedIdsArray.includes(id)),
+      'All environment IDs should be present in cache',
+    );
+  });
+
+  it('should write all environments to cache using writeEnvironmentsToCache', async () => {
+    setAllEnvironments([env1, env2]);
+    await writeEnvironmentsToCache(options.cache);
+
+    // Verify each environment was stored individually
+    const cachedEnv1 = await options.cache.get(
+      `Environment/${ATLASPACK_VERSION}/${env1.id}`,
+    );
+    const cachedEnv2 = await options.cache.get(
+      `Environment/${ATLASPACK_VERSION}/${env2.id}`,
+    );
+    assert.deepEqual(cachedEnv1, env1);
+    assert.deepEqual(cachedEnv2, env2);
+
+    // Verify environment IDs were stored in manager
+    const cachedEnvIds: string[] | null | undefined = await options.cache.get(
+      `EnvironmentManager/${ATLASPACK_VERSION}`,
+    );
+    const cachedIdsArray = nullthrows(cachedEnvIds);
+    assert(
+      cachedIdsArray.length === 2 &&
+        [env1.id, env2.id].every((id: any) => cachedIdsArray.includes(id)),
+      'Environment IDs should be stored in manager',
+    );
+  });
+
+  it('should load environments from cache on loadRequestGraph on a subsequent build', async () => {
+    // Simulate cache written on a first build
+    setAllEnvironments([env1, env2]);
+    await writeEnvironmentsToCache(options.cache);
+
+    await loadEnvironmentsFromCache(options.cache);
+
+    const loadedEnvironments = getAllEnvironments();
+    assert.equal(
+      loadedEnvironments.length,
+      2,
+      'Should load 2 environments from cache',
+    );
+
+    const env1Loaded = loadedEnvironments.find((e: any) => e.id === env1.id);
+    const env2Loaded = loadedEnvironments.find((e: any) => e.id === env2.id);
+
+    assert.deepEqual(env1Loaded, env1);
+    assert.deepEqual(env2Loaded, env2);
+  });
+
+  it('should handle empty cache gracefully without calling setAllEnvironments', async () => {
+    const setAllEnvironmentsSpy = sinon.spy(setAllEnvironments);
+
+    await assert.doesNotReject(
+      loadEnvironmentsFromCache(options.cache),
+      'loadEnvironmentsFromCache should not throw when cache is empty',
+    );
+
+    assert.equal(
+      setAllEnvironmentsSpy.callCount,
+      0,
+      'setAllEnvironments should not be called when loading from empty cache',
+    );
+  });
+
+  it('should not load environments from a different version', async () => {
+    const setAllEnvironmentsSpy = sinon.spy(setAllEnvironments);
+    const differentVersion = '2.17.2'; // A different version than ATLASPACK_VERSION
+
+    // Store an environment with a different version
+    await options.cache.set(`Environment/${differentVersion}/${env1.id}`, env1);
+    await options.cache.set(`EnvironmentManager/${differentVersion}`, [
+      env1.id,
+    ]);
+
+    await loadEnvironmentsFromCache(options.cache);
+
+    assert.equal(
+      setAllEnvironmentsSpy.callCount,
+      0,
+      'setAllEnvironments should not be called when loading from different version',
+    );
+    const loadedEnvironments = getAllEnvironments();
+    assert.equal(
+      loadedEnvironments.length,
+      0,
+      'Should not load any environments from different version',
+    );
+  });
+});

package/test/{IdentifierRegistry.test.js → IdentifierRegistry.test.ts}

@@ -1,13 +1,11 @@
-// @flow strict-local
-
 import assert from 'assert';
 import fs from 'fs';
 import sinon from 'sinon';
 import {IdentifierRegistry} from '../src/IdentifierRegistry';
 
 describe('IdentifierRegistry', () => {
-  let mkdirSyncStub;
-  let fsStub;
+  let mkdirSyncStub: any;
+  let fsStub: any;
 
   beforeEach(() => {
     mkdirSyncStub = sinon.stub(fs, 'mkdirSync');

package/test/{InternalAsset.test.js → InternalAsset.test.ts}

@@ -1,11 +1,6 @@
-// @flow strict-local
-
 import assert from 'assert';
 import UncommittedAsset from '../src/UncommittedAsset';
-import {
-  createAsset as _createAsset,
-  type AssetOptions,
-} from '../src/assetUtils';
+import {createAsset as _createAsset, AssetOptions} from '../src/assetUtils';
 import {createEnvironment} from '../src/Environment';
 import {DEFAULT_OPTIONS} from './test-utils';
 import {toProjectPath} from '../src/projectPath';
@@ -14,7 +9,7 @@ function createAsset(opts: AssetOptions) {
   return _createAsset('/', opts);
 }
 
-const stats = {time: 0, size: 0};
+const stats = {time: 0, size: 0} as const;
 
 describe('InternalAsset', () => {
   it('only includes connected files once per filePath', () => {

package/test/{PublicAsset.test.js → PublicAsset.test.ts}

@@ -1,12 +1,7 @@
-// @flow strict-local
-
 import assert from 'assert';
 import {Asset, MutableAsset} from '../src/public/Asset';
 import UncommittedAsset from '../src/UncommittedAsset';
-import {
-  createAsset as _createAsset,
-  type AssetOptions,
-} from '../src/assetUtils';
+import {createAsset as _createAsset, AssetOptions} from '../src/assetUtils';
 import {createEnvironment} from '../src/Environment';
 import {DEFAULT_OPTIONS} from './test-utils';
 import {toProjectPath} from '../src/projectPath';
@@ -16,7 +11,7 @@ function createAsset(opts: AssetOptions) {
 }
 
 describe('Public Asset', () => {
-  let internalAsset;
+  let internalAsset: any;
   beforeEach(() => {
     internalAsset = new UncommittedAsset({
       options: DEFAULT_OPTIONS,

package/test/{PublicBundle.test.js → PublicBundle.test.ts}

@@ -1,4 +1,3 @@
-// @flow strict-local
 import type {Bundle as InternalBundle} from '../src/types';
 
 import assert from 'assert';
@@ -12,7 +11,7 @@ import {toProjectPath} from '../src/projectPath';
 
 describe('Public Bundle', () => {
   let internalBundle: InternalBundle;
-  let bundleGraph;
+  let bundleGraph: any;
   beforeEach(() => {
     let env = createEnvironment({});
     internalBundle = {

package/test/{PublicDependency.test.js → PublicDependency.test.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import assert from 'assert';
 import {createEnvironment} from '../src/Environment';
 import {createDependency} from '../src/Dependency';

package/test/PublicEnvironment.test.ts

@@ -0,0 +1,49 @@
+import assert from 'assert';
+import {createEnvironment} from '../src/Environment';
+import {fromEnvironmentId} from '../src/EnvironmentManager';
+import PublicEnvironment from '../src/public/Environment';
+import {DEFAULT_OPTIONS} from './test-utils';
+
+describe('Public Environment', () => {
+  it('has correct support data for ChromeAndroid', () => {
+    let env = new PublicEnvironment(
+      fromEnvironmentId(
+        createEnvironment({
+          context: 'browser',
+          engines: {
+            browsers: ['last 1 Chrome version', 'last 1 ChromeAndroid version'],
+          },
+          outputFormat: 'esmodule',
+        }),
+      ),
+      DEFAULT_OPTIONS,
+    );
+
+    assert(env.supports('esmodules'));
+    assert(env.supports('dynamic-import'));
+    assert(env.supports('worker-module'));
+    assert(env.supports('import-meta-url'));
+    assert(env.supports('arrow-functions'));
+  });
+
+  it('correctly identifies tesseract context', () => {
+    let env = new PublicEnvironment(
+      fromEnvironmentId(
+        createEnvironment({
+          context: 'tesseract',
+          engines: {
+            browsers: ['last 1 Chrome version'],
+          },
+        }),
+      ),
+      DEFAULT_OPTIONS,
+    );
+
+    assert(env.isTesseract());
+    assert(env.isBrowser());
+    assert(env.isIsolated());
+    assert(!env.isNode());
+    assert(!env.isElectron());
+    assert(!env.isWorklet());
+  });
+});

package/test/{PublicMutableBundleGraph.test.js → PublicMutableBundleGraph.test.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {Dependency} from '@atlaspack/types';
 
 import assert from 'assert';
@@ -8,10 +6,7 @@ import InternalBundleGraph from '../src/BundleGraph';
 import MutableBundleGraph from '../src/public/MutableBundleGraph';
 import {DEFAULT_ENV, DEFAULT_TARGETS, DEFAULT_OPTIONS} from './test-utils';
 import AssetGraph, {nodeFromAssetGroup} from '../src/AssetGraph';
-import {
-  createAsset as _createAsset,
-  type AssetOptions,
-} from '../src/assetUtils';
+import {createAsset as _createAsset, AssetOptions} from '../src/assetUtils';
 import {createDependency as _createDependency} from '../src/Dependency';
 import nullthrows from 'nullthrows';
 import {toProjectPath} from '../src/projectPath';
@@ -20,7 +15,7 @@ function createAsset(opts: AssetOptions) {
   return _createAsset('/', opts);
 }
 
-function createDependency(opts) {
+function createDependency(opts: any) {
   return _createDependency('/', opts);
 }
 
@@ -38,7 +33,7 @@ describe('PublicMutableBundleGraph', () => {
       DEFAULT_OPTIONS,
     );
 
-    mutableBundleGraph.traverse((node) => {
+    mutableBundleGraph.traverse((node: any) => {
       if (
         node.type === 'dependency' &&
         mutableBundleGraph.getResolvedAsset(node.value)
@@ -59,7 +54,7 @@ describe('PublicMutableBundleGraph', () => {
     });
 
     assert.deepEqual(
-      internalBundleGraph.getBundles().map((b) => b.publicId),
+      internalBundleGraph.getBundles().map((b: any) => b.publicId),
       ['8LVYC', 'd7Pd5'],
     );
   });
@@ -75,7 +70,7 @@ describe('PublicMutableBundleGraph', () => {
     );
 
     let dependency: Dependency;
-    mutableBundleGraph.traverse((node, _, actions) => {
+    mutableBundleGraph.traverse((node: any, _: any, actions: any) => {
       if (node.type === 'dependency') {
         dependency = node.value;
         actions.stop();
@@ -96,7 +91,7 @@ describe('PublicMutableBundleGraph', () => {
   });
 });
 
-const stats = {size: 0, time: 0};
+const stats = {size: 0, time: 0} as const;
 function createMockAssetGraph() {
   let graph = new AssetGraph();
   graph.setRootConnections({