@danielx/civet 0.6.87 → 0.6.88

package/dist/main.js

@@ -1704,7 +1704,11 @@ function patternAsValue(pattern) {
     }
     case "Identifier":
     case "BindingProperty": {
-      const children = [pattern.name, pattern.delim];
+      const children = [
+        // { name: value } = ... declares value, not name
+        pattern.value ?? pattern.name,
+        pattern.delim
+      ];
       if (isWhitespaceOrEmpty(pattern.children[0])) {
         children.unshift(pattern.children[0]);
       }
@@ -2312,6 +2316,111 @@ function processDeclarationConditionStatement(s, getRef) {
     }
   }
 }
+function dynamizeFromClause(from) {
+  from = from.slice(1);
+  from = insertTrimmingSpace(from, "");
+  if (from.at(-1)?.type === "ImportAssertion") {
+    const assert2 = from.pop();
+    from.push(", {", assert2.keyword, ":", assert2.object, "}");
+  }
+  return ["(", ...from, ")"];
+}
+function dynamizeImportDeclaration(decl) {
+  const { imports } = decl;
+  let { star, binding, specifiers } = imports;
+  const justDefault = binding && !specifiers && !star;
+  const pattern = (() => {
+    {
+      if (binding) {
+        if (specifiers) {
+          return makeRef();
+        } else {
+          return binding;
+        }
+      } else {
+        return convertNamedImportsToObject(imports, true);
+      }
+    }
+  })();
+  const c = "const";
+  const initializer = [
+    " = ",
+    justDefault ? "(" : void 0,
+    { type: "Await", children: ["await"] },
+    " ",
+    decl.children[0],
+    // import
+    dynamizeFromClause(decl.from),
+    justDefault ? ").default" : void 0
+  ];
+  const bindings = [{
+    type: "Binding",
+    names: pattern.names,
+    pattern,
+    initializer,
+    children: [pattern, initializer]
+  }];
+  if (binding && specifiers) {
+    const pattern2 = binding;
+    const initializer2 = [
+      " = ",
+      pattern,
+      ".default"
+    ];
+    bindings.push({
+      type: "Binding",
+      names: binding.names,
+      pattern: pattern2,
+      initializer: initializer2,
+      children: [pattern2, initializer2]
+    });
+    const pattern3 = convertNamedImportsToObject(imports.children.at(-1), true);
+    const initializer3 = [
+      " = ",
+      pattern
+    ];
+    bindings.push({
+      type: "Binding",
+      names: specifiers.names,
+      pattern: pattern3,
+      initializer: initializer3,
+      children: [pattern3, initializer3]
+    });
+  }
+  return {
+    type: "Declaration",
+    names: imports.names,
+    bindings,
+    decl: c,
+    children: [
+      c,
+      " ",
+      bindings.flatMap((binding2, i) => i > 0 ? [", ", binding2] : [binding2])
+    ]
+  };
+}
+function dynamizeImportDeclarationExpression($0) {
+  const [imp, ws1, named, ws2, from] = $0;
+  const object = convertNamedImportsToObject(named);
+  const dot = ".";
+  return processCallMemberExpression({
+    type: "CallExpression",
+    children: [
+      { type: "Await", children: "await" },
+      " ",
+      imp,
+      insertTrimmingSpace(ws2, ""),
+      dynamizeFromClause(from),
+      {
+        type: "PropertyGlob",
+        dot,
+        object,
+        children: [ws1, dot, object],
+        reversed: true
+      }
+    ]
+  });
+}
 var init_declaration = __esm({
   "source/parser/declaration.civet"() {
     "use strict";
@@ -2321,6 +2430,7 @@ var init_declaration = __esm({
     init_util();
     init_function();
     init_binding();
+    init_lib();
   }
 });
 
@@ -3137,10 +3247,13 @@ __export(lib_exports, {
   adjustIndexAccess: () => adjustIndexAccess,
   attachPostfixStatementAsExpression: () => attachPostfixStatementAsExpression,
   blockWithPrefix: () => blockWithPrefix,
+  convertNamedImportsToObject: () => convertNamedImportsToObject,
   convertObjectToJSXAttributes: () => convertObjectToJSXAttributes,
   dedentBlockString: () => dedentBlockString,
   dedentBlockSubstitutions: () => dedentBlockSubstitutions,
   deepCopy: () => deepCopy,
+  dynamizeImportDeclaration: () => dynamizeImportDeclaration,
+  dynamizeImportDeclarationExpression: () => dynamizeImportDeclarationExpression,
   expressionizeTypeIf: () => expressionizeTypeIf,
   forRange: () => forRange,
   gatherBindingCode: () => gatherBindingCode,
@@ -3412,9 +3525,13 @@ function processCallMemberExpression(node) {
           throw new Error(`Glob pattern must have call or member expression value, found ${JSON.stringify(part.value)}`);
         }
         let suppressPrefix = false;
-        let value = part.value ?? part.name;
+        let name = part.name;
+        let value = part.value ?? name;
         const wValue = getTrimmingSpace(part.value);
         [value, suppressPrefix] = handleThisPrivateShorthands(value);
+        if (glob.reversed) {
+          [name, value] = [value, name];
+        }
         if (!suppressPrefix) {
           value = prefix.concat(insertTrimmingSpace(value, ""));
         }
@@ -3432,13 +3549,13 @@ function processCallMemberExpression(node) {
         } else {
           parts.push({
             type: part.type === "Identifier" ? "Property" : part.type,
-            name: part.name,
+            name,
             value,
             delim: part.delim,
             names: part.names,
             children: [
               isWhitespaceOrEmpty(part.children[0]) && part.children[0],
-              part.name,
+              name,
               isWhitespaceOrEmpty(part.children[2]) && part.children[2],
               part.children[3]?.token === ":" ? part.children[3] : ":",
               value,
@@ -3583,6 +3700,35 @@ function convertMethodToFunction(method) {
     block
   };
 }
+function convertNamedImportsToObject(node, pattern) {
+  const properties = node.specifiers.map((specifier) => {
+    if (specifier.ts) {
+      return { type: "Error", message: "cannot use `type` in dynamic import" };
+    } else {
+      const { source, binding } = specifier;
+      const delim = specifier.children.at(-1);
+      return {
+        type: pattern ? "BindingProperty" : "Property",
+        name: source,
+        value: !(source === binding) ? binding : void 0,
+        delim,
+        children: source === binding ? [source, delim] : [source, ":", binding, delim]
+      };
+    }
+  });
+  return {
+    type: pattern ? "ObjectBindingPattern" : "ObjectExpression",
+    names: node.names,
+    properties,
+    children: [
+      node.children[0],
+      // {
+      properties,
+      node.children.at(-1)
+      // }
+    ]
+  };
+}
 function convertObjectToJSXAttributes(obj) {
   const { properties } = obj;
   const parts = [];
@@ -7058,14 +7204,17 @@ var require_parser = __commonJS({
         children: [$1, ...$2, ...rest.flat()]
       });
     });
-    var CallExpression$1 = $TS($S($EXPECT($L20, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
+    var CallExpression$1 = $TS($S(Import, _, NamedImports, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      return dynamizeImportDeclarationExpression($0);
+    });
+    var CallExpression$2 = $TS($S($EXPECT($L20, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
       var rest = $3;
       return processCallMemberExpression({
         type: "CallExpression",
         children: [$1, ...$2, ...rest.flat()]
       });
     });
-    var CallExpression$2 = $TS($S(MemberExpression, AllowedTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
+    var CallExpression$3 = $TS($S(MemberExpression, AllowedTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
       var member = $1;
       var trailing = $2;
       var rest = $3;
@@ -7078,7 +7227,7 @@ var require_parser = __commonJS({
       }
       return member;
     });
-    var CallExpression$$ = [CallExpression$0, CallExpression$1, CallExpression$2];
+    var CallExpression$$ = [CallExpression$0, CallExpression$1, CallExpression$2, CallExpression$3];
     function CallExpression(ctx, state) {
       return $EVENT_C(ctx, state, "CallExpression", CallExpression$$);
     }
@@ -11342,28 +11491,31 @@ var require_parser = __commonJS({
       };
     });
     var ImportDeclaration$1 = $T($S(Import, __, TypeKeyword, __, ImportClause, __, FromClause), function(value) {
-      return { "type": "ImportDeclaration", "ts": true, "children": value };
+      var imports = value[4];
+      var from = value[6];
+      return { "type": "ImportDeclaration", "ts": true, "children": value, "imports": imports, "from": from };
     });
     var ImportDeclaration$2 = $T($S(Import, __, ImportClause, __, FromClause), function(value) {
-      return { "type": "ImportDeclaration", "children": value };
+      var imports = value[2];
+      var from = value[4];
+      return { "type": "ImportDeclaration", "children": value, "imports": imports, "from": from };
     });
     var ImportDeclaration$3 = $T($S(Import, __, ModuleSpecifier), function(value) {
-      return { "type": "ImportDeclaration", "children": value };
+      var module4 = value[2];
+      return { "type": "ImportDeclaration", "children": value, "module": module4 };
     });
     var ImportDeclaration$4 = $TS($S(ImpliedImport, $E($S(TypeKeyword, __)), ImportClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var i = $1;
       var t = $2;
-      var c = $3;
+      var imports = $3;
       var w = $4;
-      var f = $5;
+      var from = $5;
       i.$loc = {
-        pos: f[0].$loc.pos - 1,
-        length: f[0].$loc.length + 1
+        pos: from[0].$loc.pos - 1,
+        length: from[0].$loc.length + 1
       };
-      const children = [i, t, c, w, f];
-      if (!t)
-        return children;
-      return { type: "ImportDeclaration", ts: true, children };
+      const children = [i, t, imports, w, from];
+      return { type: "ImportDeclaration", ts: !!t, children, imports, from };
     });
     var ImportDeclaration$$ = [ImportDeclaration$0, ImportDeclaration$1, ImportDeclaration$2, ImportDeclaration$3, ImportDeclaration$4];
     function ImportDeclaration(ctx, state) {
@@ -11381,14 +11533,17 @@ var require_parser = __commonJS({
       if (rest) {
         return {
           type: "Declaration",
-          children: $0,
-          names: [...binding.names, ...rest[3].names]
+          children: [binding, ...rest],
+          names: [...binding.names, ...rest[3].names],
+          binding,
+          specifiers: rest[3].specifiers
         };
       }
       return {
         type: "Declaration",
-        children: $0,
-        names: binding.names
+        children: [binding],
+        names: binding.names,
+        binding
       };
     });
     var ImportClause$1 = NameSpaceImport;
@@ -11398,11 +11553,14 @@ var require_parser = __commonJS({
       return $EVENT_C(ctx, state, "ImportClause", ImportClause$$);
     }
     var NameSpaceImport$0 = $TS($S(Star, ImportAsToken, __, ImportedBinding), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var star = $1;
       var binding = $4;
       return {
         type: "Declaration",
         children: $0,
-        names: binding.names
+        names: binding.names,
+        binding,
+        star
       };
     });
     function NameSpaceImport(ctx, state) {
@@ -11414,17 +11572,32 @@ var require_parser = __commonJS({
       return {
         type: "Declaration",
         children: $0,
-        names
+        names,
+        specifiers
       };
     });
     function NamedImports(ctx, state) {
       return $EVENT(ctx, state, "NamedImports", NamedImports$0);
     }
-    var FromClause$0 = $S(From, __, ModuleSpecifier);
+    var FromClause$0 = $TS($S(From, __, ModuleSpecifier), function($skip, $loc, $0, $1, $2, $3) {
+      var module4 = $3;
+      if (!Array.isArray(module4))
+        return $0;
+      return [$1, $2, ...module4];
+    });
     function FromClause(ctx, state) {
       return $EVENT(ctx, state, "FromClause", FromClause$0);
     }
-    var ImportAssertion$0 = $S($E(_), $C($EXPECT($L117, 'ImportAssertion "with"'), $EXPECT($L118, 'ImportAssertion "assert"')), NonIdContinue, $E(_), ObjectLiteral);
+    var ImportAssertion$0 = $TS($S($E(_), $C($EXPECT($L117, 'ImportAssertion "with"'), $EXPECT($L118, 'ImportAssertion "assert"')), NonIdContinue, $E(_), ObjectLiteral), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var keyword = $2;
+      var object = $5;
+      return {
+        type: "ImportAssertion",
+        keyword,
+        object,
+        children: $0
+      };
+    });
     function ImportAssertion(ctx, state) {
       return $EVENT(ctx, state, "ImportAssertion", ImportAssertion$0);
     }
@@ -11454,8 +11627,10 @@ var require_parser = __commonJS({
       return $EVENT_C(ctx, state, "TypeAndImportSpecifier", TypeAndImportSpecifier$$);
     }
     var ImportSpecifier$0 = $TS($S(__, ModuleExportName, ImportAsToken, __, ImportedBinding, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+      var source = $2;
       var binding = $5;
       return {
+        source,
         binding,
         children: $0
       };
@@ -11463,6 +11638,7 @@ var require_parser = __commonJS({
     var ImportSpecifier$1 = $TS($S(__, ImportedBinding, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
       var binding = $2;
       return {
+        source: binding,
         binding,
         children: $0
       };
@@ -11654,9 +11830,18 @@ var require_parser = __commonJS({
     function ImplicitExportSpecifier(ctx, state) {
       return $EVENT(ctx, state, "ImplicitExportSpecifier", ImplicitExportSpecifier$0);
     }
-    var Declaration$0 = HoistableDeclaration;
-    var Declaration$1 = ClassDeclaration;
-    var Declaration$2 = $TV(LexicalDeclaration, function($skip, $loc, $0, $1) {
+    var Declaration$0 = $TV(ImportDeclaration, function($skip, $loc, $0, $1) {
+      var decl = $0;
+      if (decl.ts || decl.module || !decl.imports || !decl.from)
+        return $skip;
+      const { imports } = decl;
+      if (!imports.binding && !imports.specifiers)
+        return $skip;
+      return dynamizeImportDeclaration(decl);
+    });
+    var Declaration$1 = HoistableDeclaration;
+    var Declaration$2 = ClassDeclaration;
+    var Declaration$3 = $TV(LexicalDeclaration, function($skip, $loc, $0, $1) {
       var d = $0;
       if (d.thisAssignments?.length)
         return {
@@ -11670,11 +11855,11 @@ var require_parser = __commonJS({
         };
       return d;
     });
-    var Declaration$3 = TypeDeclaration;
-    var Declaration$4 = EnumDeclaration;
-    var Declaration$5 = OperatorDeclaration;
-    var Declaration$6 = UsingDeclaration;
-    var Declaration$$ = [Declaration$0, Declaration$1, Declaration$2, Declaration$3, Declaration$4, Declaration$5, Declaration$6];
+    var Declaration$4 = TypeDeclaration;
+    var Declaration$5 = EnumDeclaration;
+    var Declaration$6 = OperatorDeclaration;
+    var Declaration$7 = UsingDeclaration;
+    var Declaration$$ = [Declaration$0, Declaration$1, Declaration$2, Declaration$3, Declaration$4, Declaration$5, Declaration$6, Declaration$7];
     function Declaration(ctx, state) {
       return $EVENT_C(ctx, state, "Declaration", Declaration$$);
     }