@ethlete/core 5.0.0-next.7 → 5.0.0-next.70

package/generators/migrate-to-v5/schema.json

@@ -4,6 +4,18 @@
   "title": "Migrate to Core v5",
   "type": "object",
   "properties": {
+    "projects": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Nx projects to migrate. Defaults to every project in the workspace.",
+      "alias": "project"
+    },
+    "include": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Path prefixes to migrate, relative to the workspace root (e.g. 'apps/web'). Unioned with `projects`. Defaults to the whole workspace.",
+      "alias": "includePath"
+    },
     "skipFormat": {
       "type": "boolean",
       "description": "Skip formatting files after migration",
@@ -23,6 +35,16 @@
       "type": "boolean",
       "description": "Migrate router state service to v5",
       "default": true
+    },
+    "migrateColorNaming": {
+      "type": "boolean",
+      "description": "Migrate theme naming to color naming (ProvideThemeDirective -> ProvideColorDirective, etc.)",
+      "default": true
+    },
+    "reportRemovedExports": {
+      "type": "boolean",
+      "description": "List imports of exports removed in v5 without a replacement (Memo, the props module)",
+      "default": true
     }
   },
   "required": []

package/generators/migrate-to-v5/service-classes.js

@@ -0,0 +1,108 @@
+import * as ts from 'typescript';
+import { applyReplacements } from './apply-replacements.js';
+export function getServiceImport(sourceFile, importedName) {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const bindings = statement.importClause?.namedBindings;
+        if (!bindings || !ts.isNamedImports(bindings))
+            continue;
+        const element = bindings.elements.find((el) => (el.propertyName?.text ?? el.name.text) === importedName);
+        if (element)
+            return { localName: element.name.text, packageName: statement.moduleSpecifier.text };
+    }
+    return null;
+}
+export function collectClasses(sourceFile) {
+    const classes = [];
+    const visit = (node) => {
+        if (ts.isClassDeclaration(node))
+            classes.push(node);
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return classes;
+}
+export function isServiceProperty(member, serviceName) {
+    const initializer = member.initializer;
+    const injectsService = !!initializer &&
+        ts.isCallExpression(initializer) &&
+        ts.isIdentifier(initializer.expression) &&
+        initializer.expression.text === 'inject' &&
+        !!initializer.arguments[0] &&
+        ts.isIdentifier(initializer.arguments[0]) &&
+        initializer.arguments[0].text === serviceName;
+    return injectsService || isServiceType(member.type, serviceName);
+}
+export function isServiceParameter(param, serviceName) {
+    return ts.isIdentifier(param.name) && isServiceType(param.type, serviceName);
+}
+export function findServiceClasses(sourceFile, serviceName) {
+    return collectClasses(sourceFile).flatMap((classNode, index) => {
+        const fields = classNode.members.flatMap((member) => {
+            if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name) && isServiceProperty(member, serviceName)) {
+                return [member.name.text];
+            }
+            if (ts.isConstructorDeclaration(member)) {
+                return member.parameters
+                    .filter((param) => isServiceParameter(param, serviceName))
+                    .map((param) => param.name.text);
+            }
+            return [];
+        });
+        return fields.length > 0 ? [{ index, fields }] : [];
+    });
+}
+export function applyReplacementsInClass(content, sourceFile, classNode, replacements) {
+    const start = classNode.getStart(sourceFile);
+    const end = classNode.getEnd();
+    return content.slice(0, start) + applyReplacements(content.slice(start, end), replacements) + content.slice(end);
+}
+export function removeServiceImport(sourceFile, content, importedName) {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement))
+            continue;
+        const bindings = statement.importClause?.namedBindings;
+        if (!bindings || !ts.isNamedImports(bindings))
+            continue;
+        const elements = bindings.elements;
+        const index = elements.findIndex((el) => (el.propertyName?.text ?? el.name.text) === importedName);
+        if (index === -1)
+            continue;
+        if (elements.length === 1) {
+            const defaultImport = statement.importClause.name;
+            if (defaultImport)
+                return content.slice(0, defaultImport.getEnd()) + content.slice(bindings.getEnd());
+            let lineEnd = statement.getEnd();
+            while (lineEnd < content.length && content[lineEnd] !== '\n')
+                lineEnd++;
+            if (content[lineEnd] === '\n')
+                lineEnd++;
+            return content.slice(0, statement.getStart(sourceFile)) + content.slice(lineEnd);
+        }
+        const element = elements[index];
+        const next = elements[index + 1];
+        const previous = elements[index - 1];
+        const [start, end] = next
+            ? [element.getStart(sourceFile), next.getStart(sourceFile)]
+            : [previous.getEnd(), element.getEnd()];
+        return content.slice(0, start) + content.slice(end);
+    }
+    return content;
+}
+function isServiceType(type, serviceName) {
+    return !!type && ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName) && type.typeName.text === serviceName;
+}
+export function isServiceStillUsed(sourceFile, serviceName, serviceClasses) {
+    const classes = collectClasses(sourceFile);
+    const referencesField = serviceClasses.some(({ index, fields }) => containsIdentifier(classes[index], fields));
+    const referencesService = sourceFile.statements.some((statement) => !ts.isImportDeclaration(statement) && containsIdentifier(statement, [serviceName]));
+    return referencesField || referencesService;
+}
+function containsIdentifier(node, names) {
+    if (!node)
+        return false;
+    if (ts.isIdentifier(node) && names.includes(node.text))
+        return true;
+    return !!ts.forEachChild(node, (child) => containsIdentifier(child, names) || undefined);
+}

package/generators/migrate-to-v5/sync-observable-consumers.js

@@ -0,0 +1,80 @@
+import * as ts from 'typescript';
+const MESSAGE = 'reads an observable made by toObservable(), which emits only after its first effect run. Read the signal directly or use computed().';
+export function findSyncObservableConsumers(filePath, originalContent, content) {
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const isAddedToObservable = (node) => ts.isCallExpression(node) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === 'toObservable' &&
+        !originalContent.includes(node.getText());
+    const containsAddedToObservable = (node) => isAddedToObservable(node) || (ts.forEachChild(node, containsAddedToObservable) ?? false);
+    const asyncNames = new Set();
+    const collectNames = (node) => {
+        if ((ts.isPropertyDeclaration(node) || ts.isVariableDeclaration(node)) &&
+            ts.isIdentifier(node.name) &&
+            node.initializer &&
+            containsAddedToObservable(node.initializer)) {
+            asyncNames.add(node.name.text);
+        }
+        ts.forEachChild(node, collectNames);
+    };
+    collectNames(sourceFile);
+    const isAsyncSource = (expression) => {
+        let root = expression;
+        while (ts.isCallExpression(root) && ts.isPropertyAccessExpression(root.expression)) {
+            root = root.expression.expression;
+        }
+        if (isAddedToObservable(root))
+            return true;
+        if (ts.isIdentifier(root))
+            return asyncNames.has(root.text);
+        return ts.isPropertyAccessExpression(root) && root.expression.kind === ts.SyntaxKind.ThisKeyword
+            ? asyncNames.has(root.name.text)
+            : false;
+    };
+    const findings = [];
+    const visit = (node) => {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+            const [source, options] = node.arguments;
+            const name = node.expression.text;
+            if (name === 'toSignal' && source && options && requiresSync(options) && isAsyncSource(source)) {
+                findings.push({ node, label: `toSignal(${flatText(source)}, { requireSync: true })` });
+            }
+            if (name === 'withLatestFrom') {
+                for (const argument of node.arguments.filter(isAsyncSource)) {
+                    findings.push({ node: argument, label: `withLatestFrom(${flatText(argument)})` });
+                }
+            }
+        }
+        if (ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            node.expression.name.text === 'pipe' &&
+            isAsyncSource(node.expression.expression)) {
+            for (const operator of node.arguments.filter(isFirstValueOperator)) {
+                findings.push({ node: operator, label: flatText(operator) });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return findings
+        .sort((a, b) => a.node.getStart() - b.node.getStart())
+        .map(({ node, label }) => {
+        const line = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+        return `${filePath}:${line}: ${label} ${MESSAGE}`;
+    });
+}
+function requiresSync(options) {
+    return (ts.isObjectLiteralExpression(options) &&
+        options.properties.some((property) => ts.isPropertyAssignment(property) &&
+            property.name.getText() === 'requireSync' &&
+            property.initializer.kind === ts.SyntaxKind.TrueKeyword));
+}
+function isFirstValueOperator(operator) {
+    if (!ts.isCallExpression(operator) || !ts.isIdentifier(operator.expression))
+        return false;
+    const name = operator.expression.text;
+    return name === 'first' || (name === 'take' && operator.arguments[0]?.getText() === '1');
+}
+function flatText(node) {
+    return node.getText().replace(/\s+/g, ' ');
+}