@formspec/build 0.1.0-alpha.52 → 0.1.0-alpha.53

package/dist/internals.cjs

@@ -1044,39 +1044,85 @@ function isNonReferenceIdentifier(node) {
   }
   return false;
 }
-function statementReferencesImportedName(statement, importedNames) {
+function astReferencesImportedName(root, importedNames) {
   if (importedNames.size === 0) {
     return false;
   }
-  let referencesImportedName = false;
+  let found = false;
   const visit = (node) => {
-    if (referencesImportedName) {
-      return;
-    }
+    if (found) return;
     if (ts4.isIdentifier(node) && importedNames.has(node.text) && !isNonReferenceIdentifier(node)) {
-      referencesImportedName = true;
+      found = true;
       return;
     }
     ts4.forEachChild(node, visit);
   };
-  visit(statement);
-  return referencesImportedName;
+  visit(root);
+  return found;
+}
+function getObjectMembers(statement) {
+  if (ts4.isInterfaceDeclaration(statement)) {
+    return statement.members;
+  }
+  if (ts4.isTypeLiteralNode(statement.type)) {
+    return statement.type.members;
+  }
+  return void 0;
+}
+function rewriteImportedMemberTypes(statement, sourceFile, importedNames) {
+  const members = getObjectMembers(statement);
+  if (members === void 0) {
+    return null;
+  }
+  const replacements = [];
+  for (const member of members) {
+    if (!ts4.isPropertySignature(member)) {
+      if (astReferencesImportedName(member, importedNames)) {
+        return null;
+      }
+      continue;
+    }
+    const typeAnnotation = member.type;
+    if (typeAnnotation === void 0) continue;
+    if (astReferencesImportedName(typeAnnotation, importedNames)) {
+      replacements.push({
+        start: typeAnnotation.getStart(sourceFile),
+        end: typeAnnotation.getEnd()
+      });
+    }
+  }
+  if (replacements.length === 0) {
+    return statement.getText(sourceFile);
+  }
+  const stmtStart = statement.getStart(sourceFile);
+  let result = statement.getText(sourceFile);
+  for (const { start, end } of [...replacements].reverse()) {
+    result = result.slice(0, start - stmtStart) + "unknown" + result.slice(end - stmtStart);
+  }
+  return result;
 }
 function buildSupportingDeclarations(sourceFile, extensionTypeNames) {
   const importedNames = collectImportedNames(sourceFile);
   const importedNamesToSkip = new Set(
     [...importedNames].filter((name) => !extensionTypeNames.has(name))
   );
-  return sourceFile.statements.filter((statement) => {
-    if (ts4.isImportDeclaration(statement)) return false;
-    if (ts4.isImportEqualsDeclaration(statement)) return false;
-    if (ts4.isExportDeclaration(statement) && statement.moduleSpecifier !== void 0)
-      return false;
-    if (statementReferencesImportedName(statement, importedNamesToSkip)) {
-      return false;
+  const result = [];
+  for (const statement of sourceFile.statements) {
+    if (ts4.isImportDeclaration(statement)) continue;
+    if (ts4.isImportEqualsDeclaration(statement)) continue;
+    if (ts4.isExportDeclaration(statement) && statement.moduleSpecifier !== void 0) continue;
+    if (!astReferencesImportedName(statement, importedNamesToSkip)) {
+      result.push(statement.getText(sourceFile));
+      continue;
     }
-    return true;
-  }).map((statement) => statement.getText(sourceFile));
+    if (ts4.isInterfaceDeclaration(statement) || ts4.isTypeAliasDeclaration(statement)) {
+      const rewritten = rewriteImportedMemberTypes(statement, sourceFile, importedNamesToSkip);
+      if (rewritten !== null) {
+        result.push(rewritten);
+      }
+    }
+  }
+  return result;
 }
 function pushUniqueCompilerDiagnostics(target, additions) {
   for (const diagnostic of additions) {