@atlaspack/core 2.16.2-canary.372 → 2.16.2-canary.375

package/dist/BundleGraph.js

@@ -16,6 +16,7 @@ const Environment_1 = require("./public/Environment");
 const projectPath_1 = require("./projectPath");
 const constants_1 = require("./constants");
 const feature_flags_1 = require("@atlaspack/feature-flags");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
 const EnvironmentManager_1 = require("./EnvironmentManager");
 exports.bundleGraphEdgeTypes = {
     // A lack of an edge type indicates to follow the edge while traversing
@@ -380,6 +381,66 @@ class BundleGraph {
             conditions: serialized.conditions,
         });
     }
+    /**
+     * Serialize the bundle graph for efficient transfer to native Rust code.
+     * Returns a JSON string of nodes and an array of edges.
+     */
+    serializeForNative() {
+        const start = performance.now();
+        const nodes = this._graph.nodes;
+        const edges = [];
+        const edgeIterator = this._graph.getAllEdges();
+        let next = edgeIterator.next();
+        while (!next.done) {
+            const edge = next.value;
+            edges.push([edge.from, edge.to, edge.type]);
+            next = edgeIterator.next();
+        }
+        // Optimize nodes by omitting null/undefined values to reduce JSON size
+        const optimizedNodes = nodes.map((node) => this._omitNulls(node));
+        const nodesJson = JSON.stringify(optimizedNodes);
+        const duration = performance.now() - start;
+        const sizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+        logger_1.default.verbose({
+            origin: '@atlaspack/core',
+            message: `serializeForNative: ${duration.toFixed(1)}ms, ${sizeMB}MB JSON, ${nodes.length} nodes, ${edges.length} edges`,
+        });
+        return { nodesJson, edges };
+    }
+    /**
+     * Remove null and undefined values from an object to reduce JSON size.
+     * Preserves false, 0, empty strings, and arrays.
+     */
+    _omitNulls(obj) {
+        if (obj === null || obj === undefined)
+            return obj;
+        if (typeof obj !== 'object')
+            return obj;
+        if (Array.isArray(obj)) {
+            return obj.map((item) => this._omitNulls(item));
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (value === null || value === undefined) {
+                continue;
+            }
+            if (typeof value === 'object' &&
+                !Array.isArray(value) &&
+                Object.keys(value).length === 0) {
+                continue;
+            }
+            if (typeof value === 'object') {
+                const processed = this._omitNulls(value);
+                if (processed !== undefined) {
+                    result[key] = processed;
+                }
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
     createBundle(opts) {
         // @ts-expect-error TS2339
         let { entryAsset, target } = opts;

package/dist/atlaspack-v3/AtlaspackV3.js

@@ -7,7 +7,6 @@ exports.AtlaspackV3 = void 0;
 const rust_1 = require("@atlaspack/rust");
 const NapiWorkerPool_1 = require("./NapiWorkerPool");
 const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
-const assert_1 = __importDefault(require("assert"));
 class AtlaspackV3 {
     constructor(atlaspack_napi, napiWorkerPool, isDefaultNapiWorkerPool) {
         this._atlaspack_napi = atlaspack_napi;
@@ -52,9 +51,9 @@ class AtlaspackV3 {
     buildAssetGraph() {
         return (0, rust_1.atlaspackNapiBuildAssetGraph)(this._atlaspack_napi);
     }
-    loadBundleGraph({ nodes, edges, }) {
-        (0, assert_1.default)(nodes.length > 0, 'Bundle graph must have at least one node');
-        return (0, rust_1.atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodes, edges);
+    loadBundleGraph(bundleGraph) {
+        const { nodesJson, edges } = bundleGraph.serializeForNative();
+        return (0, rust_1.atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges);
     }
     package() {
         return (0, rust_1.atlaspackNapiPackage)(this._atlaspack_napi);

package/dist/requests/AtlaspackBuildRequest.js

@@ -48,17 +48,7 @@ async function run({ input, api, options, rustAtlaspack, }) {
             }
         });
         if (hasSupportedTarget) {
-            // In theory this could be a (somehow) null[] - but we know if we've gotten this far it probably isn't..
-            let nodes = bundleGraph._graph.nodes;
-            let rawEdges = [];
-            const gen = bundleGraph._graph.getAllEdges();
-            let next = gen.next();
-            while (!next.done) {
-                let edge = next.value;
-                rawEdges.push([edge.from, edge.to, edge.type]);
-                next = gen.next();
-            }
-            await rustAtlaspack.loadBundleGraph({ nodes, edges: rawEdges });
+            await rustAtlaspack.loadBundleGraph(bundleGraph);
         }
     }
     // @ts-expect-error TS2345

package/lib/BundleGraph.js

@@ -51,6 +51,13 @@ function _featureFlags() {
   };
   return data;
 }
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
 var _EnvironmentManager = require("./EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const bundleGraphEdgeTypes = exports.bundleGraphEdgeTypes = {
@@ -428,6 +435,67 @@ class BundleGraph {
       conditions: serialized.conditions
     });
   }
+
+  /**
+   * Serialize the bundle graph for efficient transfer to native Rust code.
+   * Returns a JSON string of nodes and an array of edges.
+   */
+  serializeForNative() {
+    const start = performance.now();
+    const nodes = this._graph.nodes;
+    const edges = [];
+    const edgeIterator = this._graph.getAllEdges();
+    let next = edgeIterator.next();
+    while (!next.done) {
+      const edge = next.value;
+      edges.push([edge.from, edge.to, edge.type]);
+      next = edgeIterator.next();
+    }
+
+    // Optimize nodes by omitting null/undefined values to reduce JSON size
+    const optimizedNodes = nodes.map(node => this._omitNulls(node));
+    const nodesJson = JSON.stringify(optimizedNodes);
+    const duration = performance.now() - start;
+    const sizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+    _logger().default.verbose({
+      origin: '@atlaspack/core',
+      message: `serializeForNative: ${duration.toFixed(1)}ms, ${sizeMB}MB JSON, ${nodes.length} nodes, ${edges.length} edges`
+    });
+    return {
+      nodesJson,
+      edges
+    };
+  }
+
+  /**
+   * Remove null and undefined values from an object to reduce JSON size.
+   * Preserves false, 0, empty strings, and arrays.
+   */
+  _omitNulls(obj) {
+    if (obj === null || obj === undefined) return obj;
+    if (typeof obj !== 'object') return obj;
+    if (Array.isArray(obj)) {
+      return obj.map(item => this._omitNulls(item));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (value === null || value === undefined) {
+        continue;
+      }
+      if (typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0) {
+        continue;
+      }
+      if (typeof value === 'object') {
+        const processed = this._omitNulls(value);
+        if (processed !== undefined) {
+          result[key] = processed;
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
   createBundle(opts) {
     // @ts-expect-error TS2339
     let {

package/lib/atlaspack-v3/AtlaspackV3.js

@@ -19,13 +19,6 @@ function _diagnostic() {
   };
   return data;
 }
-function _assert() {
-  const data = _interopRequireDefault(require("assert"));
-  _assert = function () {
-    return data;
-  };
-  return data;
-}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class AtlaspackV3 {
   constructor(atlaspack_napi, napiWorkerPool, isDefaultNapiWorkerPool) {
@@ -79,12 +72,12 @@ class AtlaspackV3 {
   buildAssetGraph() {
     return (0, _rust().atlaspackNapiBuildAssetGraph)(this._atlaspack_napi);
   }
-  loadBundleGraph({
-    nodes,
-    edges
-  }) {
-    (0, _assert().default)(nodes.length > 0, 'Bundle graph must have at least one node');
-    return (0, _rust().atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodes, edges);
+  loadBundleGraph(bundleGraph) {
+    const {
+      nodesJson,
+      edges
+    } = bundleGraph.serializeForNative();
+    return (0, _rust().atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges);
   }
   package() {
     return (0, _rust().atlaspackNapiPackage)(this._atlaspack_napi);

package/lib/requests/AtlaspackBuildRequest.js

@@ -70,20 +70,7 @@ async function run({
       }
     });
     if (hasSupportedTarget) {
-      // In theory this could be a (somehow) null[] - but we know if we've gotten this far it probably isn't..
-      let nodes = bundleGraph._graph.nodes;
-      let rawEdges = [];
-      const gen = bundleGraph._graph.getAllEdges();
-      let next = gen.next();
-      while (!next.done) {
-        let edge = next.value;
-        rawEdges.push([edge.from, edge.to, edge.type]);
-        next = gen.next();
-      }
-      await rustAtlaspack.loadBundleGraph({
-        nodes,
-        edges: rawEdges
-      });
+      await rustAtlaspack.loadBundleGraph(bundleGraph);
     }
   }
 

package/lib/types/BundleGraph.d.ts

@@ -77,6 +77,19 @@ export default class BundleGraph {
     static fromAssetGraph(assetGraph: AssetGraph, isProduction: boolean, publicIdByAssetId?: Map<string, string>, assetPublicIds?: Set<string>): BundleGraph;
     serialize(): SerializedBundleGraph;
     static deserialize(serialized: BundleGraphOpts): BundleGraph;
+    /**
+     * Serialize the bundle graph for efficient transfer to native Rust code.
+     * Returns a JSON string of nodes and an array of edges.
+     */
+    serializeForNative(): {
+        nodesJson: string;
+        edges: [number, number, BundleGraphEdgeType][];
+    };
+    /**
+     * Remove null and undefined values from an object to reduce JSON size.
+     * Preserves false, 0, empty strings, and arrays.
+     */
+    private _omitNulls;
     createBundle(opts: {
         readonly entryAsset: Asset;
         readonly bundleRoots?: Array<Asset>;

package/lib/types/atlaspack-v3/AtlaspackV3.d.ts

@@ -1,8 +1,7 @@
 import { AtlaspackNapi, Lmdb, AtlaspackNapiOptions, CacheStats } from '@atlaspack/rust';
 import type { Event } from '@parcel/watcher';
 import type { NapiWorkerPool as INapiWorkerPool } from '@atlaspack/types';
-import { BundleGraphNode } from '../types';
-import { BundleGraphEdgeType } from '../BundleGraph';
+import type BundleGraph from '../BundleGraph';
 export type AtlaspackV3Options = {
     fs?: AtlaspackNapiOptions['fs'];
     packageManager?: AtlaspackNapiOptions['packageManager'];
@@ -24,10 +23,7 @@ export declare class AtlaspackV3 {
     static create({ fs, packageManager, threads, lmdb, napiWorkerPool, ...options }: AtlaspackV3Options): Promise<AtlaspackV3>;
     end(): void;
     buildAssetGraph(): Promise<any>;
-    loadBundleGraph({ nodes, edges, }: {
-        nodes: BundleGraphNode[];
-        edges: [number, number, BundleGraphEdgeType][];
-    }): Promise<any>;
+    loadBundleGraph(bundleGraph: BundleGraph): Promise<void>;
     package(): Promise<any>;
     respondToFsEvents(events: Array<Event>): Promise<boolean>;
     completeCacheSession(): Promise<CacheStats>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.16.2-canary.372+3753cb1bf",
+  "version": "2.16.2-canary.375+d0200834a",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -22,22 +22,22 @@
     "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3-canary.440+3753cb1bf",
-    "@atlaspack/cache": "3.1.1-canary.372+3753cb1bf",
-    "@atlaspack/diagnostic": "2.14.1-canary.440+3753cb1bf",
-    "@atlaspack/events": "2.14.1-canary.440+3753cb1bf",
-    "@atlaspack/feature-flags": "2.14.1-canary.440+3753cb1bf",
-    "@atlaspack/fs": "2.14.5-canary.372+3753cb1bf",
-    "@atlaspack/graph": "3.4.1-canary.440+3753cb1bf",
-    "@atlaspack/logger": "2.14.5-canary.372+3753cb1bf",
-    "@atlaspack/package-manager": "2.14.5-canary.372+3753cb1bf",
-    "@atlaspack/plugin": "2.14.5-canary.372+3753cb1bf",
-    "@atlaspack/profiler": "2.14.1-canary.440+3753cb1bf",
-    "@atlaspack/rust": "3.2.1-canary.372+3753cb1bf",
-    "@atlaspack/source-map": "3.2.5-canary.4151+3753cb1bf",
-    "@atlaspack/types": "2.14.5-canary.372+3753cb1bf",
-    "@atlaspack/utils": "2.14.5-canary.372+3753cb1bf",
-    "@atlaspack/workers": "2.14.5-canary.372+3753cb1bf",
+    "@atlaspack/build-cache": "2.13.3-canary.443+d0200834a",
+    "@atlaspack/cache": "3.1.1-canary.375+d0200834a",
+    "@atlaspack/diagnostic": "2.14.1-canary.443+d0200834a",
+    "@atlaspack/events": "2.14.1-canary.443+d0200834a",
+    "@atlaspack/feature-flags": "2.14.1-canary.443+d0200834a",
+    "@atlaspack/fs": "2.14.5-canary.375+d0200834a",
+    "@atlaspack/graph": "3.4.1-canary.443+d0200834a",
+    "@atlaspack/logger": "2.14.5-canary.375+d0200834a",
+    "@atlaspack/package-manager": "2.14.5-canary.375+d0200834a",
+    "@atlaspack/plugin": "2.14.5-canary.375+d0200834a",
+    "@atlaspack/profiler": "2.14.1-canary.443+d0200834a",
+    "@atlaspack/rust": "3.2.1-canary.375+d0200834a",
+    "@atlaspack/source-map": "3.2.5-canary.4154+d0200834a",
+    "@atlaspack/types": "2.14.5-canary.375+d0200834a",
+    "@atlaspack/utils": "2.14.5-canary.375+d0200834a",
+    "@atlaspack/workers": "2.14.5-canary.375+d0200834a",
     "@mischnic/json-sourcemap": "^0.1.0",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
@@ -61,5 +61,5 @@
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
   "type": "commonjs",
-  "gitHead": "3753cb1bf9155eaf3a1a8f952886864682738647"
+  "gitHead": "d0200834a2dbe54b56f8b127d8c8ee8d60af27e7"
 }

package/src/BundleGraph.ts

@@ -46,6 +46,7 @@ import {ISOLATED_ENVS} from './public/Environment';
 import {fromProjectPath, fromProjectPathRelative} from './projectPath';
 import {HASH_REF_PREFIX} from './constants';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
+import logger from '@atlaspack/logger';
 import {fromEnvironmentId} from './EnvironmentManager';
 import type {EnvironmentRef} from './EnvironmentManager';
 
@@ -571,6 +572,76 @@ export default class BundleGraph {
     });
   }
 
+  /**
+   * Serialize the bundle graph for efficient transfer to native Rust code.
+   * Returns a JSON string of nodes and an array of edges.
+   */
+  serializeForNative(): {
+    nodesJson: string;
+    edges: [number, number, BundleGraphEdgeType][];
+  } {
+    const start = performance.now();
+
+    const nodes = this._graph.nodes as BundleGraphNode[];
+    const edges: [number, number, BundleGraphEdgeType][] = [];
+
+    const edgeIterator = this._graph.getAllEdges();
+    let next = edgeIterator.next();
+    while (!next.done) {
+      const edge = next.value;
+      edges.push([edge.from, edge.to, edge.type]);
+      next = edgeIterator.next();
+    }
+
+    // Optimize nodes by omitting null/undefined values to reduce JSON size
+    const optimizedNodes = nodes.map((node) => this._omitNulls(node));
+    const nodesJson = JSON.stringify(optimizedNodes);
+
+    const duration = performance.now() - start;
+    const sizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+    logger.verbose({
+      origin: '@atlaspack/core',
+      message: `serializeForNative: ${duration.toFixed(1)}ms, ${sizeMB}MB JSON, ${nodes.length} nodes, ${edges.length} edges`,
+    });
+
+    return {nodesJson, edges};
+  }
+
+  /**
+   * Remove null and undefined values from an object to reduce JSON size.
+   * Preserves false, 0, empty strings, and arrays.
+   */
+  private _omitNulls(obj: unknown): unknown {
+    if (obj === null || obj === undefined) return obj;
+    if (typeof obj !== 'object') return obj;
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this._omitNulls(item));
+    }
+
+    const result: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+      if (value === null || value === undefined) {
+        continue;
+      }
+      if (
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        Object.keys(value as object).length === 0
+      ) {
+        continue;
+      }
+      if (typeof value === 'object') {
+        const processed = this._omitNulls(value);
+        if (processed !== undefined) {
+          result[key] = processed;
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+
   createBundle(
     opts:
       | {

package/src/atlaspack-v3/AtlaspackV3.ts

@@ -14,9 +14,8 @@ import {NapiWorkerPool} from './NapiWorkerPool';
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
 import type {Event} from '@parcel/watcher';
 import type {NapiWorkerPool as INapiWorkerPool} from '@atlaspack/types';
-import {BundleGraphNode} from '../types';
 import invariant from 'assert';
-import {BundleGraphEdgeType} from '../BundleGraph';
+import type BundleGraph from '../BundleGraph';
 
 export type AtlaspackV3Options = {
   fs?: AtlaspackNapiOptions['fs'];
@@ -102,19 +101,14 @@ export class AtlaspackV3 {
     return atlaspackNapiBuildAssetGraph(this._atlaspack_napi) as Promise<any>;
   }
 
-  loadBundleGraph({
-    nodes,
-    edges,
-  }: {
-    nodes: BundleGraphNode[];
-    edges: [number, number, BundleGraphEdgeType][];
-  }): Promise<any> {
-    invariant(nodes.length > 0, 'Bundle graph must have at least one node');
+  loadBundleGraph(bundleGraph: BundleGraph): Promise<void> {
+    const {nodesJson, edges} = bundleGraph.serializeForNative();
+
     return atlaspackNapiLoadBundleGraph(
       this._atlaspack_napi,
-      nodes,
+      nodesJson,
       edges,
-    ) as Promise<any>;
+    ) as Promise<void>;
   }
 
   package(): Promise<any> {

package/src/requests/AtlaspackBuildRequest.ts

@@ -3,12 +3,7 @@ import type {Async} from '@atlaspack/types';
 import type {SharedReference} from '@atlaspack/workers';
 
 import type {StaticRunOpts} from '../RequestTracker';
-import type {
-  Asset,
-  AssetGroup,
-  BundleGraphNode,
-  PackagedBundleInfo,
-} from '../types';
+import type {Asset, AssetGroup, PackagedBundleInfo} from '../types';
 import type BundleGraph from '../BundleGraph';
 
 import createBundleGraphRequest, {
@@ -17,7 +12,7 @@ import createBundleGraphRequest, {
 import createWriteBundlesRequest from './WriteBundlesRequest';
 import {assertSignalNotAborted} from '../utils';
 import dumpGraphToGraphViz from '../dumpGraphToGraphViz';
-import {BundleGraphEdgeType, bundleGraphEdgeTypes} from '../BundleGraph';
+import {bundleGraphEdgeTypes} from '../BundleGraph';
 import {report} from '../ReporterRunner';
 import IBundleGraph from '../public/BundleGraph';
 import {NamedBundle} from '../public/Bundle';
@@ -107,17 +102,7 @@ async function run({
       }
     });
     if (hasSupportedTarget) {
-      // In theory this could be a (somehow) null[] - but we know if we've gotten this far it probably isn't..
-      let nodes = bundleGraph._graph.nodes as BundleGraphNode[];
-      let rawEdges: [number, number, BundleGraphEdgeType][] = [];
-      const gen = bundleGraph._graph.getAllEdges();
-      let next = gen.next();
-      while (!next.done) {
-        let edge = next.value;
-        rawEdges.push([edge.from, edge.to, edge.type]);
-        next = gen.next();
-      }
-      await rustAtlaspack.loadBundleGraph({nodes, edges: rawEdges});
+      await rustAtlaspack.loadBundleGraph(bundleGraph);
     }
   }