@koobiq/components 20.1.0 → 20.3.0

package/schematics/utils/angular-parsing.js

@@ -10,23 +10,17 @@ var utils_typescript = require('./typescript.js');
  * @param tree
  * @param filePaths
  * @param context
- * @param migrationData
+ * @param transform
  */
-async function migrateTemplate(tree, filePaths, context, migrationData) {
+async function migrateTemplateWithTransform(tree, filePaths, context, transform) {
     for (const templatePath of filePaths) {
         const parsedFilePath = `.${templatePath}`;
-        let res = Promise.resolve({
-            fileContent: '',
-            changed: false,
-            errors: []
-        });
         const template = tree.read(parsedFilePath)?.toString();
         if (!template) {
             context.logger.error(`Cannot read "${parsedFilePath}" because it does not exist.`);
             continue;
         }
-        res = transformTemplateAttributes(template, parsedFilePath, migrationData);
-        const { fileContent, changed, errors } = await res;
+        const { fileContent, changed, errors } = await transform(template, parsedFilePath);
         if (changed) {
             tree.overwrite(templatePath, fileContent);
         }
@@ -35,15 +29,25 @@ async function migrateTemplate(tree, filePaths, context, migrationData) {
         }
     }
 }
+/**
+ * Update separate html file
+ * @param tree
+ * @param filePaths
+ * @param context
+ * @param migrationData
+ */
+async function migrateTemplate(tree, filePaths, context, migrationData) {
+    return migrateTemplateWithTransform(tree, filePaths, context, (template, fileName) => transformTemplateAttributes(template, fileName, migrationData));
+}
 /**
  * Update typescript file if classes with @Component decorator and `template` property exists
  * @param tree
  * @param sourceFiles
  * @param basePath
  * @param context
- * @param migrationData
+ * @param transform
  */
-async function migrateTs(tree, sourceFiles, basePath, context, migrationData) {
+async function migrateTsWithTransform(tree, sourceFiles, basePath, context, transform) {
     // run and track changed components
     const analysis = new Map();
     for (const sourceFile of sourceFiles) {
@@ -61,7 +65,7 @@ async function migrateTs(tree, sourceFiles, basePath, context, migrationData) {
         for (const { start, end } of ranges) {
             const template = content.slice(start, end);
             const length = (end ?? content.length) - start;
-            const { fileContent, changed, errors } = await transformTemplateAttributes(template, relativePath, migrationData);
+            const { fileContent, changed, errors } = await transform(template, relativePath);
             if (changed) {
                 update.remove(start, length);
                 update.insertLeft(start, fileContent);
@@ -73,6 +77,17 @@ async function migrateTs(tree, sourceFiles, basePath, context, migrationData) {
         tree.commitUpdate(update);
     }
 }
+/**
+ * Update typescript file if classes with @Component decorator and `template` property exists
+ * @param tree
+ * @param sourceFiles
+ * @param basePath
+ * @param context
+ * @param migrationData
+ */
+async function migrateTs(tree, sourceFiles, basePath, context, migrationData) {
+    return migrateTsWithTransform(tree, sourceFiles, basePath, context, (template, fileName) => transformTemplateAttributes(template, fileName, migrationData));
+}
 /**
  * Analyzes the decorators of a given class declaration to find and save
  * inline `template` metadata within `@Component` decorators.
@@ -122,6 +137,7 @@ async function transformTemplateAttributes(template, fileName, migrationData) {
     if (parsed.tree !== undefined) {
         const visitor = new utils_typescript.ElementCollector(migrationData, fileName);
         utils_ast.visitAll(visitor, parsed.tree.rootNodes);
+        let didReplace = false;
         for (const el of visitor.elementsToMigrate) {
             const migrationAttr = el.attrs.find((attr) => utils_ast.getSimpleAttributeName(attr.name) === migrationData.attrs.key.from);
             let updatedAttrValue;
@@ -132,7 +148,14 @@ async function transformTemplateAttributes(template, fileName, migrationData) {
                     updatedAttrValue = replacement.to;
                 }
                 else {
-                    console.warn(`Element is using dynamic value. Check the code and change value on your own.${(fileName && ' File: ' + fileName) || ''}`);
+                    // A bound attribute (`[panelWidth]="..."`) whose value isn't a quoted string
+                    // literal is a genuine runtime expression and can't be resolved statically. A
+                    // plain attribute, or a bound attribute holding a quoted literal, has a known
+                    // value at migration time — it's just one the replacement table doesn't cover.
+                    const isDynamicExpression = migrationAttr.name.startsWith('[') && !/^\s*['"].*['"]\s*$/.test(migrationAttr.value);
+                    console.warn(isDynamicExpression
+                        ? `Element is using a dynamic value. Check the code and change value on your own.${(fileName && ' File: ' + fileName) || ''}`
+                        : `Element has value "${cleanAttrValue}" with no matching replacement. Check the code and change value on your own.${(fileName && ' File: ' + fileName) || ''}`);
                     continue;
                 }
                 updatedTemplate =
@@ -141,13 +164,17 @@ async function transformTemplateAttributes(template, fileName, migrationData) {
                         updatedTemplate.slice(migrationAttr.valueSpan.end.offset + 1 - offset, updatedTemplate.length);
                 offset += migrationAttr.name.length - migrationData.attrs.key.to.length;
                 offset += migrationAttr.value.length - updatedAttrValue.length;
+                didReplace = true;
             }
         }
-        return { fileContent: updatedTemplate, changed: visitor.elementsToMigrate.length > 0, errors: parsed.errors };
+        return { fileContent: updatedTemplate, changed: didReplace, errors: parsed.errors };
     }
     return { fileContent: updatedTemplate, changed: undefined, errors: parsed.errors };
 }
 
 exports.analyzeDecorators = analyzeDecorators;
 exports.migrateTemplate = migrateTemplate;
+exports.migrateTemplateWithTransform = migrateTemplateWithTransform;
 exports.migrateTs = migrateTs;
+exports.migrateTsWithTransform = migrateTsWithTransform;
+exports.transformTemplateAttributes = transformTemplateAttributes;

package/schematics/utils/ast.js

@@ -22,7 +22,38 @@ function getSimpleAttributeName(attrName) {
 function getSimpleAttributeValue(attrValue) {
     return attrValue.replace(/[{}']/g, '');
 }
+/**
+ * Splits a whitespace-separated token list (an HTML `class` attribute value, or a bare
+ * `'custom-icons word-wrap_16'`-style string), replacing only tokens for which `lookup` returns a
+ * value. A `''`/`null` result drops the token; `undefined` leaves it untouched. Tokens are
+ * rejoined with single spaces. Returns `undefined` if no token was touched.
+ */
+function replaceTokenList(value, lookup) {
+    const tokens = value.split(/\s+/).filter(Boolean);
+    let changed = false;
+    const result = tokens
+        .map((token) => {
+        const replacement = lookup(token);
+        if (replacement === undefined) {
+            return token;
+        }
+        changed = true;
+        return replacement;
+    })
+        .filter((token) => !!token);
+    return changed ? result.join(' ') : undefined;
+}
+/**
+ * If `simpleAttrName` (already stripped of `[`/`]` binding brackets via `getSimpleAttributeName`)
+ * is a `class.<token>` binding, returns `<token>`; otherwise `undefined`.
+ */
+function getClassBindingToken(simpleAttrName) {
+    const match = /^class\.(.+)$/.exec(simpleAttrName);
+    return match ? match[1] : undefined;
+}
 
+exports.getClassBindingToken = getClassBindingToken;
 exports.getSimpleAttributeName = getSimpleAttributeName;
 exports.getSimpleAttributeValue = getSimpleAttributeValue;
+exports.replaceTokenList = replaceTokenList;
 exports.visitAll = visitAll;