refactor(compartment-mapper): refactor bundler to produce less output

Author: naugtur

packages/compartment-mapper/scripts/bundle-live-test.js

@@ -15,5 +15,11 @@ const readPowers = makeReadPowers({ fs, url });
 const bundle = await makeBundle(readPowers.read, fixture);
 fs.writeFileSync(url.fileURLToPath(target), bundle);
 
+console.log(`
+#######################
+size: ${bundle.length}
+`);
+
+// eslint-disable-next-line no-undef
 global.print = console.log;
 import(target);

packages/compartment-mapper/src/bundle-cjs.js

@@ -1,18 +1,7 @@
-/** quotes strings */
-const q = JSON.stringify;
-
-const exportsCellRecord = exportsList =>
-  ''.concat(
-    ...exportsList.map(
-      exportName => `\
-      ${exportName}: cell(${q(exportName)}),
-`,
-    ),
-  );
-
+// vvv runtime to inline in the bundle vvv
+/* eslint-disable no-undef */
 // This function is serialized and references variables from its destination scope.
-const runtime = function wrapCjsFunctor(num) {
-  /* eslint-disable no-undef */
+function wrapCjsFunctor(num) {
   return ({ imports = {} }) => {
     const cModule = Object.freeze(
       Object.defineProperty({}, 'exports', cells[num].default),
@@ -24,8 +13,11 @@ const runtime = function wrapCjsFunctor(num) {
       .filter(k => k !== 'default' && k !== '*')
       .map(k => cells[num][k].set(cModule.exports[k]));
   };
-  /* eslint-enable no-undef */
-}.toString();
+}
+/* eslint-enable no-undef */
+const runtime = `\
+${wrapCjsFunctor}`;
+// ^^^ runtime to inline in the bundle ^^^
 
 export default {
   runtime,
@@ -41,11 +33,7 @@ export default {
 // === functors[${index}] ===
 ${cjsFunctor},
 `,
-      getCells: () => `\
-    {
-${exportsCellRecord(exportsList)}\
-    },
-`,
+      getCells: () => exportsList,
       getReexportsWiring: () => '',
       getFunctorCall: () => `\
   wrapCjsFunctor(${index})({imports: ${importsMap}});

packages/compartment-mapper/src/bundle-json.js

@@ -6,9 +6,7 @@ export default {
 // === functors[${index}] ===
 ${sourceText},
 `,
-      getCells: () => `\
-    { default: cell('default') }, 
-`,
+      getCells: () => ['default'],
       getReexportsWiring: () => '',
       getFunctorCall: () => `\
   cells[${index}].default.set(functors[${index}]);

packages/compartment-mapper/src/bundle-mjs.js

@@ -1,15 +1,6 @@
 /** quotes strings */
 const q = JSON.stringify;
 
-const exportsCellRecord = exportMap =>
-  ''.concat(
-    ...Object.keys(exportMap).map(
-      exportName => `\
-      ${exportName}: cell(${q(exportName)}),
-`,
-    ),
-  );
-
 const importsCellSetter = (exportMap, index) =>
   ''.concat(
     ...Object.entries(exportMap).map(
@@ -19,31 +10,56 @@ const importsCellSetter = (exportMap, index) =>
     ),
   );
 
-const adaptReexport = reexportMap => {
+const importImplementation = indexedImports => {
+  const knownEntries = Object.entries(indexedImports);
+  if (knownEntries.length === 0) {
+    return `imports() {},`;
+  }
+  return `\
+imports(entries) {
+      const map = new Map(entries);
+      observeImports(map, [
+  ${''.concat(
+    ...knownEntries.map(
+      ([importName, importIndex]) => `\
+    [${q(importName)}, ${importIndex}],
+  `,
+    ),
+  )}\
+    ]);},`;
+};
+
+const getReexportKeys = reexportMap => {
   if (!reexportMap) {
     return {};
   }
-  const ret = Object.fromEntries(
-    Object.values(reexportMap)
-      .flat()
-      .map(([local, exported]) => [exported, [local]]),
-  );
-  return ret;
+  return Object.values(reexportMap)
+    .flat()
+    .map(([local, _exported]) => local);
 };
 
-export const runtime = `\
-function observeImports(map, importName, importIndex) {
-  for (const [name, observers] of map.get(importName)) {
-    const cell = cells[importIndex][name];
-    if (cell === undefined) {
-      throw new ReferenceError(\`Cannot import name \${name}\`);
-    }
-    for (const observer of observers) {
-      cell.observe(observer);
+// vvv runtime to inline in the bundle vvv
+/* eslint-disable no-undef */
+function observeImports(map, pairs) {
+  for (const [importName, importIndex] of pairs) {
+    for (const [name, observers] of map.get(importName)) {
+      const cell = cells[importIndex][name];
+      if (cell === undefined) {
+        throw new ReferenceError(`Cannot import name ${name}`);
+      }
+      for (const observer of observers) {
+        cell.observe(observer);
+      }
     }
   }
 }
-`;
+
+/* eslint-enable no-undef */
+
+const runtime = `\
+${observeImports}
+${observeImports}`;
+// ^^^ runtime to inline in the bundle ^^^
 
 export default {
   runtime,
@@ -55,6 +71,7 @@ export default {
       __fixedExportMap__ = {},
       __liveExportMap__ = {},
       __reexportMap__ = {},
+      __needsImportMeta__ = false,
       reexports,
     },
   }) {
@@ -63,19 +80,17 @@ export default {
 // === functors[${index}] ===
 ${__syncModuleProgram__},
 `,
-      getCells: () => `\
-    {
-${exportsCellRecord(__fixedExportMap__)}${exportsCellRecord(
-        __liveExportMap__,
-      )}${exportsCellRecord(adaptReexport(__reexportMap__))}\
-    },
-`,
+      getCells: () => [
+        ...Object.keys(__fixedExportMap__),
+        ...Object.keys(__liveExportMap__),
+        ...getReexportKeys(__reexportMap__),
+      ],
+      reexportedCells: reexports.map(importSpecifier => [
+        index,
+        indexedImports[importSpecifier],
+      ]),
       getReexportsWiring: () => {
-        const mappings = reexports.map(
-          importSpecifier => `\
-  Object.defineProperties(cells[${index}], Object.getOwnPropertyDescriptors(cells[${indexedImports[importSpecifier]}]));
-`,
-        );
+        const mappings = [];
         // Create references for export name as newname
         const namedReexportsToProcess = Object.entries(__reexportMap__);
         if (namedReexportsToProcess.length > 0) {
@@ -96,23 +111,14 @@ ${exportsCellRecord(__fixedExportMap__)}${exportsCellRecord(
       },
       getFunctorCall: () => `\
   functors[${index}]({
-    imports(entries) {
-      const map = new Map(entries);
-  ${''.concat(
-    ...Object.entries(indexedImports).map(
-      ([importName, importIndex]) => `\
-    observeImports(map, ${q(importName)}, ${importIndex});
-  `,
-    ),
-  )}\
-  },
+    ${importImplementation(indexedImports)}
     liveVar: {
   ${importsCellSetter(__liveExportMap__, index)}\
   },
     onceVar: {
 ${importsCellSetter(__fixedExportMap__, index)}\
-    },
-    importMeta: {},
+    },\
+${__needsImportMeta__ ? '\n    importMeta: {},' : ''}
   });
 `,
     };

packages/compartment-mapper/src/bundle.js

@@ -79,8 +79,10 @@ const sortedModules = (
         );
       }
       if (record) {
-        const { imports = [], reexports = [] } =
-          /** @type {PrecompiledStaticModuleInterface} */ (record);
+        const {
+          imports = [],
+          reexports = [],
+        } = /** @type {PrecompiledStaticModuleInterface} */ (record);
         const resolvedImports = Object.create(null);
         for (const importSpecifier of [...imports, ...reexports]) {
           const resolvedSpecifier = resolve(importSpecifier, moduleSpecifier);
@@ -149,6 +151,49 @@ function getBundlerKitForModule(module) {
   return getBundlerKit(module);
 }
 
+// vvv runtime to inline in the bundle vvv
+/* eslint-disable no-undef */
+function cell(name, value = undefined) {
+  const observers = [];
+  return Object.freeze({
+    get: Object.freeze(() => {
+      return value;
+    }),
+    set: Object.freeze(newValue => {
+      value = newValue;
+      for (const observe of observers) {
+        observe(value);
+      }
+    }),
+    observe: Object.freeze(observe => {
+      observers.push(observe);
+      observe(value);
+    }),
+    enumerable: true,
+  });
+}
+function makeCells(orderedCells, reexports) {
+  const cells = orderedCells.map(cs =>
+    cs.reduce((kv, c) => {
+      kv[c] = cell(c);
+      return kv;
+    }, {}),
+  );
+  for (const [to, from] of reexports) {
+    Object.defineProperties(
+      cells[to],
+      Object.getOwnPropertyDescriptors(cells[from]),
+    );
+  }
+  return cells;
+}
+/* eslint-enable no-undef */
+const runtime = `\
+${cell}
+${makeCells}`;
+
+// ^^^ runtime to inline in the bundle ^^^
+
 /**
  * @param {ReadFn} read
  * @param {string} moduleLocation
@@ -251,29 +296,17 @@ export const makeBundle = async (read, moduleLocation, options) => {
 ${''.concat(...modules.map(m => m.bundlerKit.getFunctor()))}\
 ]; // functors end
 
-  const cell = (name, value = undefined) => {
-    const observers = [];
-    return Object.freeze({
-      get: Object.freeze(() => {
-        return value;
-      }),
-      set: Object.freeze((newValue) => {
-        value = newValue;
-        for (const observe of observers) {
-          observe(value);
-        }
-      }),
-      observe: Object.freeze((observe) => {
-        observers.push(observe);
-        observe(value);
-      }),
-      enumerable: true,
-    });
-  };
-
-  const cells = [
-${''.concat(...modules.map(m => m.bundlerKit.getCells()))}\
-  ];
+//runtime
+  ${''.concat(
+    runtime,
+    ...Array.from(parsersInUse).map(parser => getRuntime(parser)),
+  )}
+// runtime end
+  const cells = makeCells(
+${JSON.stringify([...modules.map(m => m.bundlerKit.getCells())], null, 2)},
+/* export * from */
+${JSON.stringify(modules.flatMap(m => m.bundlerKit.reexportedCells || []))}
+);
 
 ${''.concat(...modules.map(m => m.bundlerKit.getReexportsWiring()))}\
 
@@ -283,8 +316,6 @@ ${''.concat(...modules.map(m => m.bundlerKit.getReexportsWiring()))}\
     cells[index]['*'] = cell('*', namespaces[index]);
   }
 
-${''.concat(...Array.from(parsersInUse).map(parser => getRuntime(parser)))}
-
 ${''.concat(...modules.map(m => m.bundlerKit.getFunctorCall()))}\
 
   return cells[cells.length - 1]['*'].get();