automatically optimize array-destructuring

resources/build-npm.ts

@@ -5,6 +5,7 @@ import path from 'node:path';
 import ts from 'typescript';
 
 import { inlineInvariant } from './inline-invariant.js';
+import { transformArrayDestructuring } from './transform-array-destruct.js'
 import {
   localRepoPath,
   readdirRecursive,
@@ -51,6 +52,7 @@ tsHost.writeFile = writeGeneratedFile;
 
 const tsProgram = ts.createProgram(['src/index.ts'], tsOptions, tsHost);
 const tsResult = tsProgram.emit(undefined, undefined, undefined, undefined, {
+  before: [transformArrayDestructuring()],
   after: [inlineInvariant],
 });
 assert(

resources/transform-array-destruct.ts

@@ -0,0 +1,37 @@
+import * as ts from 'typescript';
+
+export function transformArrayDestructuring() {
+  return (context: ts.TransformationContext) => {
+    const { factory } = context;
+
+    return (sourceFile: ts.SourceFile) => {
+      const visitor = (node: ts.Node): ts.Node => {
+        if (ts.isArrayBindingPattern(node)) {
+          const elements = node.elements
+            .map((el, i) => {
+              if (!el.getText()) {
+                return undefined;
+              }
+              return { key: String(i), name: el.getText() };
+            })
+            .filter(Boolean);
+
+          const els = elements
+            .map((el) => {
+              if (!el) {
+                return undefined;
+              }
+              const key = factory.createIdentifier(el.key);
+              const name = factory.createIdentifier(el.name);
+              return factory.createBindingElement(undefined, key, name);
+            })
+            .filter(Boolean) as Array<ts.BindingElement>;
+          return factory.createObjectBindingPattern(els);
+        }
+
+        return ts.visitEachChild(node, visitor, context);
+      };
+      return ts.visitNode(sourceFile, visitor);
+    };
+  };
+}