@komaci/common-shared 264.5.0 → 266.3.0

package/build/moduleMetadata.d.ts

@@ -29,16 +29,20 @@ export declare const initializeImportMetdataFromKomaciDocument: (doc: KomaciDocu
  * @param isSupported if it's from a valid namespace
  * @param komaciDocImportRef reference index in komaci document
  * @param moduleMetadata the metadata object
+ * @param importAlias optional local alias used for this import in the source module
+ * @param isTypeOnly true when the import was declared as TypeScript type-only (`import type ...` or per-specifier `import { type Foo }`)
  *
  * @return the import metadata object in case anything needs to be modified
  */
-export declare const composeImportMetadata: (name: string, resourceName: string, isSupported: boolean, komaciDocImportRef: string, moduleMetadata: ModuleMetadata, importAlias?: string) => ImportMetadata;
+export declare const composeImportMetadata: (name: string, resourceName: string, isSupported: boolean, komaciDocImportRef: string, moduleMetadata: ModuleMetadata, importAlias: string | undefined, isTypeOnly: boolean) => ImportMetadata;
 /**
  * collect all the imports for a given ast and then execute a callback with information about the import
  * @param ast The babel ast
- * @param cb function to call for acting on import information
+ * @param cb function to call for acting on import information. The `isTypeOnly` arg is true when the
+ *           specifier is part of an `import type ...` declaration or has a per-specifier `type` modifier
+ *           (`import { type Foo, bar }`).
  */
-export declare const traverseAstImports: (ast: t.File, cb: (lookupName: string, referencedName: string, resourceName: string, originalImportName?: string) => void) => void;
+export declare const traverseAstImports: (ast: t.File, cb: (lookupName: string, referencedName: string, resourceName: string, originalImportName: string | undefined, isTypeOnly: boolean) => void) => void;
 /**
  * given the name of a resource see if we have information about it. if we don't compose the base object for later reference.
  * @param resourceName The import path
@@ -62,8 +66,9 @@ export declare const reconcileImport: (name: string, importPath: string, moduleM
  * @param namespace the metadata about the import namespace
  * @param moduleMetadata the metadata about the module
  * @param originalImportName (optional) the original name of the import that has been aliases. undefined if no alias.
+ * @param isTypeOnly true when the import was declared as TypeScript type-only (`import type ...` or per-specifier `import { type Foo }`)
  */
-export declare const addNewImportFromAst: (referencedName: string, namespace: ImportDetail, moduleMetadata: ModuleMetadata, originalImportName?: string) => void;
+export declare const addNewImportFromAst: (referencedName: string, namespace: ImportDetail, moduleMetadata: ModuleMetadata, originalImportName: string | undefined, isTypeOnly: boolean) => void;
 /**
  * Komaci Documents don't keep track of import aliases but sometimes they're referenced in code so we want to makes sure we have them.
  * @param lookupName the name used as the holdover key tor eference this import

package/build/moduleMetadata.js

@@ -73,7 +73,7 @@ const initializeImportMetdataFromKomaciDocument = (doc, moduleMetadata, template
             (0, exports.composeImportMetadata)(name, importNamespace.resourceName, isSupported, templateAdgIndex !== undefined
                 ? `t${templateAdgIndex}-` + komaciDocImportRef
                 : komaciDocImportRef, // to prevent collision in references
-            moduleMetadata, importAlias);
+            moduleMetadata, importAlias, false);
         }
         /*
          * For imports from other resolvable modules we know that they will always be only a default import.
@@ -99,10 +99,12 @@ exports.initializeImportMetdataFromKomaciDocument = initializeImportMetdataFromK
  * @param isSupported if it's from a valid namespace
  * @param komaciDocImportRef reference index in komaci document
  * @param moduleMetadata the metadata object
+ * @param importAlias optional local alias used for this import in the source module
+ * @param isTypeOnly true when the import was declared as TypeScript type-only (`import type ...` or per-specifier `import { type Foo }`)
  *
  * @return the import metadata object in case anything needs to be modified
  */
-const composeImportMetadata = (name, resourceName, isSupported, komaciDocImportRef, moduleMetadata, importAlias) => {
+const composeImportMetadata = (name, resourceName, isSupported, komaciDocImportRef, moduleMetadata, importAlias, isTypeOnly) => {
     const generatorIndex = isSupported
         ? moduleMetadata.importGeneratorIndex++
         : moduleMetadata.importGeneratorIndex;
@@ -128,6 +130,7 @@ const composeImportMetadata = (name, resourceName, isSupported, komaciDocImportR
         isFromSupportedLibrary: (0, allowlistNamespaces_1.isLibraryValid)(resourceName),
         usedInPriming: false,
         staticallyAnalyzable: true,
+        isTypeOnly,
     };
     if (allowlistNamespaces_1.isLocalHtmlImportReference.test(resourceName)) {
         const templateKomaciDoc = getImportTemplateKomaciDocByResourceName(resourceName, moduleMetadata.templateKomaciDocMap);
@@ -153,7 +156,9 @@ exports.composeImportMetadata = composeImportMetadata;
 /**
  * collect all the imports for a given ast and then execute a callback with information about the import
  * @param ast The babel ast
- * @param cb function to call for acting on import information
+ * @param cb function to call for acting on import information. The `isTypeOnly` arg is true when the
+ *           specifier is part of an `import type ...` declaration or has a per-specifier `type` modifier
+ *           (`import { type Foo, bar }`).
  */
 const traverseAstImports = (ast, cb) => {
     const program = ast.program;
@@ -162,6 +167,8 @@ const traverseAstImports = (ast, cb) => {
     importDeclarations.forEach((currentDec) => {
         const specifiers = currentDec.specifiers;
         const resourceName = currentDec.source.value;
+        // `import type { ... } from '...'` and `import type Foo from '...'` set importKind on the declaration.
+        const declarationIsTypeOnly = currentDec.importKind === 'type';
         specifiers.forEach((specifier) => {
             let referencedName;
             let originalImportName;
@@ -189,7 +196,10 @@ const traverseAstImports = (ast, cb) => {
                 referencedName = (0, utils_1.getFromIdentifierOrStringLiteral)(specifier.imported);
                 lookupName = referencedName;
             }
-            cb(lookupName, referencedName, resourceName, originalImportName);
+            // Per-specifier `import { type Foo, bar }` sets importKind on the specifier.
+            const specifierIsTypeOnly = specifier.type === 'ImportSpecifier' && specifier.importKind === 'type';
+            const isTypeOnly = declarationIsTypeOnly || specifierIsTypeOnly;
+            cb(lookupName, referencedName, resourceName, originalImportName, isTypeOnly);
         });
     });
 };
@@ -233,7 +243,7 @@ const reconcileImport = (name, importPath, moduleMetadata) => {
         return existingImport;
     }
     else {
-        const newImport = (0, exports.composeImportMetadata)(name, importPath, (0, allowlistNamespaces_1.isNamespaceInternal)((0, allowlistNamespaces_1.getNamespaceFromImport)(importPath)), exports.NO_KOMACI_DOC_REF, moduleMetadata);
+        const newImport = (0, exports.composeImportMetadata)(name, importPath, (0, allowlistNamespaces_1.isNamespaceInternal)((0, allowlistNamespaces_1.getNamespaceFromImport)(importPath)), exports.NO_KOMACI_DOC_REF, moduleMetadata, undefined, false);
         const namespace = (0, exports.reconcileNamespace)(importPath, moduleMetadata);
         namespace.names.add(newImport.name);
         return newImport;
@@ -246,12 +256,13 @@ exports.reconcileImport = reconcileImport;
  * @param namespace the metadata about the import namespace
  * @param moduleMetadata the metadata about the module
  * @param originalImportName (optional) the original name of the import that has been aliases. undefined if no alias.
+ * @param isTypeOnly true when the import was declared as TypeScript type-only (`import type ...` or per-specifier `import { type Foo }`)
  */
-const addNewImportFromAst = (referencedName, namespace, moduleMetadata, originalImportName) => {
+const addNewImportFromAst = (referencedName, namespace, moduleMetadata, originalImportName, isTypeOnly) => {
     const importAlias = originalImportName && referencedName !== originalImportName
         ? referencedName
         : undefined;
-    const importMetadata = (0, exports.composeImportMetadata)(originalImportName || referencedName, namespace.resourceName, namespace.isSupported, exports.NO_KOMACI_DOC_REF, moduleMetadata, importAlias);
+    const importMetadata = (0, exports.composeImportMetadata)(originalImportName || referencedName, namespace.resourceName, namespace.isSupported, exports.NO_KOMACI_DOC_REF, moduleMetadata, importAlias, isTypeOnly);
     importMetadata.staticallyAnalyzable = false;
     // this code might need to go in composeImportMetadata() method
     // SFS would like to make static resources available offline. This code will allow for priming resources from @salesforce/resource imports to make this possible.
@@ -345,16 +356,30 @@ exports.getImportFromNamespace = getImportFromNamespace;
  * @param ast ast for the given component
  */
 const collectImportMetadataFromAst = (ast, moduleMetadata) => {
-    (0, exports.traverseAstImports)(ast, (lookupName, referencedName, resourceName, originalImportName) => {
+    (0, exports.traverseAstImports)(ast, (lookupName, referencedName, resourceName, originalImportName, isTypeOnly) => {
         const namespace = (0, exports.reconcileNamespace)(resourceName, moduleMetadata);
         const existingImportMetadata = getImportFromNamespace(lookupName, resourceName, moduleMetadata);
         if (!namespace.originalNames.has(originalImportName || referencedName)) {
-            (0, exports.addNewImportFromAst)(referencedName, namespace, moduleMetadata, originalImportName);
+            (0, exports.addNewImportFromAst)(referencedName, namespace, moduleMetadata, originalImportName, isTypeOnly);
         }
         else {
             const importMetadata = (0, exports.findOtherAlias)(resourceName, originalImportName || referencedName, moduleMetadata);
             if (importMetadata) {
                 moduleMetadata.importsByName.set(referencedName, importMetadata);
+                // When the same imported name is brought in under multiple local aliases
+                // (once as type-only and once as a value) both aliases share a single
+                // metadata object (looked up via findOtherAlias). If we observe the type-
+                // only declaration first the shared object starts with `isTypeOnly: true`,
+                // so when the value alias is later observed we must downgrade the shared flag to
+                // `false` to keep the runtime alias callable in the generated ADG.
+                //
+                // Example (covered by the `value reference wins over a prior type-only reference`
+                // test):
+                //   import type { Foo as A } from 'force/shared';   // pass 1: A → new metadata, isTypeOnly=true
+                //   import { Foo as B } from 'force/shared';        // pass 2: B → reuses A's metadata; flip to isTypeOnly=false
+                if (importMetadata.isTypeOnly && !isTypeOnly) {
+                    importMetadata.isTypeOnly = false;
+                }
             }
         }
         if (existingImportMetadata &&

package/build/types.d.ts

@@ -145,6 +145,11 @@ export declare type BasicImportMetadata = {
     usedInPriming: boolean;
     /** flag representing if this import was statically picked up as part of the komaci document. we have to keep all statically analyzable imports */
     staticallyAnalyzable: boolean;
+    /**
+     * flag representing if this import is a TypeScript type-only import (`import type ...` or per-specifier `import { type Foo }`).
+     * type-only imports are preserved in the generated ADG so the LWC compiler's TS-strip pass can erase them at runtime.
+     */
+    isTypeOnly: boolean;
     /**
      * component id for if this import maps to a component used in a template
      * this is only managed as part of processTemplateImports

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@komaci/common-shared",
-    "version": "264.5.0",
+    "version": "266.3.0",
     "description": "Assets that are shared across Komaci commonjs packages",
     "homepage": "https://komaci.dev/",
     "repository": {