@craft-ng/dev-tools 0.5.0-beta.5 → 0.5.1-beta.0

package/src/eslint-rules/require-exception-component-di-check.cjs

@@ -1,4 +1,4 @@
-/** Generates O(1) DI checks for renderComponent/errorComponent/withErrorComponent. */
+/** Generates O(1) DI checks for route, exception, and route-load error components. */
 module.exports = {
   meta: { type: 'problem', fixable: 'code', schema: [] },
   create(context) {
@@ -6,7 +6,11 @@ module.exports = {
     return {
       'Program:exit'(program) {
         const text = source.getText();
-        if (!/renderComponent|errorComponent|withErrorComponent/.test(text))
+        if (
+          !/renderComponent|errorComponent|withErrorComponent|withRouteLoadError|provideRouteLoadErrorComponent/.test(
+            text,
+          )
+        )
           return;
 
         const cascade = readCascadeContext(text);
@@ -14,25 +18,34 @@ module.exports = {
         walk(program, (node) => {
           if (isCall(node, 'craftRoutes')) {
             collectRouteChecks(node, source, cascade, checks);
-          } else if (isCall(node, 'withErrorComponent')) {
+          } else if (
+            isCall(node, 'withErrorComponent') ||
+            isCall(node, 'withRouteLoadError')
+          ) {
             const descriptor = node.arguments[0];
             const deps = readProperty(descriptor, 'componentDeps', source);
             if (deps) {
+              const routeLoad = isCall(node, 'withRouteLoadError');
               checks.push({
                 deps,
-                names: joinNames(cascade.names, ['CraftGlobalError']),
+                names: joinNames(
+                  cascade.names,
+                  routeLoad
+                    ? ['CraftRouteLoadError', 'CraftRouteLoadRecovery']
+                    : ['CraftGlobalError'],
+                ),
                 values: cascade.values,
-                label: 'global error component',
+                label: routeLoad
+                  ? 'global route load error component'
+                  : 'global error component',
               });
             }
           }
         });
 
+        const existingChecks = readExistingCheckDeps(text);
         const missing = checks.filter(
-          (check) =>
-            !text.includes(
-              `RouteExceptionComponentCheckedDI<\n  ${check.deps},`,
-            ),
+          (check) => !existingChecks.has(normalizeTypeText(check.deps)),
         );
         if (missing.length === 0) return;
 
@@ -84,6 +97,29 @@ function collectRouteChecks(call, source, cascade, checks) {
       });
     }
 
+    const providers = propertyValue(def, 'providers');
+    if (providers?.type === 'ArrayExpression') {
+      for (const provider of providers.elements) {
+        if (!isCall(provider, 'provideRouteLoadErrorComponent')) continue;
+        const deps = readProperty(
+          provider.arguments[0],
+          'componentDeps',
+          source,
+        );
+        if (!deps) continue;
+        checks.push({
+          deps,
+          names: joinNames(cascade.names, [
+            ...baseNames,
+            'CraftRouteLoadError',
+            'CraftRouteLoadRecovery',
+          ]),
+          values: cascade.values,
+          label: `route load error component: ${path}`,
+        });
+      }
+    }
+
     const handlers = routeCall
       ? routeCall.arguments[2]
       : propertyValue(def, 'handleExceptions');
@@ -193,10 +229,30 @@ function ensureImports(text) {
   );
 }
 
+function readExistingCheckDeps(text) {
+  const deps = new Set();
+  const regex = /RouteExceptionComponentCheckedDI<\s*([\s\S]*?),\s*(?:'[^']*'|never)/g;
+  let match;
+  while ((match = regex.exec(text))) {
+    deps.add(normalizeTypeText(match[1]));
+  }
+  return deps;
+}
+
+function normalizeTypeText(text) {
+  return String(text).replace(/\s+/g, '');
+}
+
 function readProperty(node, name, source) {
   const value = propertyValue(node, name);
-  return value ? source.getText(value) : undefined;
+  return value ? readTypeText(value, source) : undefined;
+}
+
+function readTypeText(node, source) {
+  if (node?.type === 'TSAsExpression') return source.getText(node.typeAnnotation);
+  return source.getText(node);
 }
+
 function propertyValue(node, name) {
   if (node?.type !== 'ObjectExpression') return undefined;
   return node.properties.find(

package/src/eslint-rules/require-lazy-load-with-retry.cjs

@@ -0,0 +1,148 @@
+'use strict';
+
+const LAZY_PROPERTIES = new Set([
+  'loadComponent',
+  'loadChildren',
+]);
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Require lazy route imports to use the withRetry helper so browser-cached module failures can be retried.',
+    },
+    fixable: 'code',
+    schema: [],
+  },
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    const importsByLoader = new Map();
+
+    return {
+      ImportExpression(node) {
+        const loader = enclosingLazyLoader(node);
+        if (!loader || isWrappedWithRetry(node)) return;
+
+        const imports = importsByLoader.get(loader) ?? [];
+        imports.push(node);
+        importsByLoader.set(loader, imports);
+      },
+      'Program:exit'() {
+        for (const [loader, imports] of importsByLoader) {
+          context.report({
+            node: imports[0],
+            message:
+              'Lazy route imports must be wrapped with withRetry(import(...)).',
+            fix(fixer) {
+              const parameterFixes = addWithRetryParameter(
+                fixer,
+                sourceCode,
+                loader,
+              );
+              if (!parameterFixes) return null;
+
+              return [
+                ...parameterFixes,
+                ...imports.flatMap((moduleImport) => [
+                  fixer.insertTextBefore(moduleImport, 'withRetry('),
+                  fixer.insertTextAfter(moduleImport, ')'),
+                ]),
+              ];
+            },
+          });
+        }
+      },
+    };
+  },
+};
+
+function enclosingLazyLoader(node) {
+  let current = node.parent;
+  while (current) {
+    if (
+      (current.type === 'ArrowFunctionExpression' ||
+        current.type === 'FunctionExpression') &&
+      current.parent?.type === 'Property' &&
+      LAZY_PROPERTIES.has(propertyName(current.parent)) &&
+      isInsideCraftRoute(current.parent)
+    ) {
+      return current;
+    }
+    if (current.type === 'Property' || current.type === 'Program') return null;
+    current = current.parent;
+  }
+  return null;
+}
+
+function isInsideCraftRoute(node) {
+  let current = node.parent;
+  while (current) {
+    if (
+      current.type === 'CallExpression' &&
+      current.callee.type === 'Identifier' &&
+      (current.callee.name === 'craftRoute' ||
+        current.callee.name === 'craftRoutes')
+    ) {
+      return true;
+    }
+    if (current.type === 'Program') return false;
+    current = current.parent;
+  }
+  return false;
+}
+
+function propertyName(property) {
+  if (property.computed) return undefined;
+  if (property.key.type === 'Identifier') return property.key.name;
+  if (property.key.type === 'Literal') return property.key.value;
+  return undefined;
+}
+
+function isWrappedWithRetry(node) {
+  return (
+    node.parent?.type === 'CallExpression' &&
+    node.parent.callee.type === 'Identifier' &&
+    node.parent.callee.name === 'withRetry' &&
+    node.parent.arguments[0] === node
+  );
+}
+
+function addWithRetryParameter(fixer, sourceCode, loader) {
+  if (loader.params.length === 0) {
+    const arrow = sourceCode.getTokenBefore(loader.body, {
+      filter: (token) => token.value === '=>',
+    });
+    if (!arrow) return null;
+
+    const closeParen = sourceCode.getTokenBefore(arrow);
+    const openParen = closeParen && sourceCode.getTokenBefore(closeParen);
+    if (openParen?.value !== '(' || closeParen?.value !== ')') return null;
+    return [
+      fixer.replaceTextRange(
+        [openParen.range[1], closeParen.range[0]],
+        '{ withRetry }',
+      ),
+    ];
+  }
+
+  if (loader.params.length !== 1 || loader.params[0].type !== 'ObjectPattern') {
+    return null;
+  }
+
+  const pattern = loader.params[0];
+  if (
+    pattern.properties.some(
+      (property) =>
+        property.type === 'Property' &&
+        property.key.type === 'Identifier' &&
+        property.key.name === 'withRetry',
+    )
+  ) {
+    return [];
+  }
+
+  const closingBrace = sourceCode.getLastToken(pattern);
+  const prefix = pattern.properties.length > 0 ? ', ' : '';
+  return [fixer.insertTextBefore(closingBrace, `${prefix}withRetry`)];
+}

package/src/index.d.ts

@@ -1 +1,9 @@
 export * from './scripts/angular-brand-codemod';
+export * from './scripts/primitives/migrate-primitives';
+export * from './scripts/migrate';
+export * from './scripts/primitives/migration-diagnostic';
+export * from './scripts/routes/migrate-routes';
+export * from './scripts/routes/migration-diagnostic';
+export * from './scripts/services/config';
+export * from './scripts/services/migrate-services';
+export * from './scripts/services/migration-diagnostic';

package/src/index.js

@@ -1,3 +1,11 @@
 // Export programmatic API for codemod
 export * from './scripts/angular-brand-codemod';
+export * from './scripts/primitives/migrate-primitives';
+export * from './scripts/migrate';
+export * from './scripts/primitives/migration-diagnostic';
+export * from './scripts/routes/migrate-routes';
+export * from './scripts/routes/migration-diagnostic';
+export * from './scripts/services/config';
+export * from './scripts/services/migrate-services';
+export * from './scripts/services/migration-diagnostic';
 //# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/dev-tools/src/index.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/dev-tools/src/index.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,yCAAyC,CAAC;AACxD,cAAc,mBAAmB,CAAC;AAClC,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iCAAiC,CAAC;AAChD,cAAc,uCAAuC,CAAC;AACtD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qCAAqC,CAAC;AACpD,cAAc,yCAAyC,CAAC"}

package/src/scripts/angular-brand-codemod.d.ts

@@ -19,6 +19,22 @@ export type AngularBrandImportAugmentationRule = {
 export type AngularBrandConfig = {
     importAugmentations?: readonly AngularBrandImportAugmentationRule[];
 };
+export type ServiceMigrationScope = 'global' | 'toProvide' | 'manuallyProvidedAtRoot' | 'function' | 'abstract';
+export type ServiceMigrationStrategy = 'craftService' | 'toCraftService' | 'companion' | 'ignore';
+export type ServiceMigrationOverride = {
+    file?: string;
+    module?: string;
+    symbol?: string;
+    name?: string;
+    scope?: ServiceMigrationScope;
+    strategy?: ServiceMigrationStrategy;
+};
+export type CraftDevToolsConfig = {
+    brand?: AngularBrandConfig;
+    serviceMigration?: {
+        overrides?: readonly ServiceMigrationOverride[];
+    };
+};
 export type TransformResult = {
     changed: boolean;
     skipped: boolean;
@@ -97,6 +113,7 @@ export type RunSummary = {
     files: RunFileReport[];
 };
 export declare function defineAngularBrandConfig<Config extends AngularBrandConfig>(config: Config): Config;
+export declare function defineCraftDevToolsConfig<Config extends CraftDevToolsConfig>(config: Config): Config;
 export declare function discoverAngularBrandConfigFilePath(searchFromDir: string, stopDir?: string): string | undefined;
 export declare function loadAngularBrandConfigFromFile(configFilePath: string): AngularBrandConfig;
 export declare function transformSourceFile(sourceFile: SourceFile, options?: AngularBrandCodemodOptions): TransformResult;

package/src/scripts/angular-brand-codemod.js

@@ -18,6 +18,7 @@ const DEFAULT_OPTIONS = {
     config: undefined,
     configFilePath: undefined,
 };
+const CRAFT_DEV_TOOLS_CONFIG_FILE_NAME = 'craft-dev-tools.config.ts';
 const ANGULAR_BRAND_CONFIG_FILE_NAME = 'craft-brand.config.ts';
 const DEFAULT_ANGULAR_BRAND_METADATA_CONTEXTS = [
     'imports',
@@ -54,7 +55,22 @@ const DEFAULT_ANGULAR_BRAND_CONFIG = defineAngularBrandConfig({
                 {
                     key: 'FormField',
                     symbol: 'FormField',
-                    typeText: 'FormField<unknown>',
+                    typeText: 'FormField<never>',
+                    module: '@angular/forms/signals',
+                },
+            ],
+        },
+        {
+            match: {
+                module: '@angular/forms/signals',
+                symbols: ['FormRoot'],
+                metadata: ['imports'],
+            },
+            deps: [
+                {
+                    key: 'FormRoot',
+                    symbol: 'FormRoot',
+                    typeText: 'FormRoot<unknown>',
                     module: '@angular/forms/signals',
                 },
             ],
@@ -168,13 +184,26 @@ const IGNORED_DIRECTORIES = new Set([
 export function defineAngularBrandConfig(config) {
     return config;
 }
+export function defineCraftDevToolsConfig(config) {
+    return config;
+}
+function isCraftDevToolsConfig(value) {
+    return Boolean(value &&
+        typeof value === 'object' &&
+        ('brand' in value || 'serviceMigration' in value));
+}
 export function discoverAngularBrandConfigFilePath(searchFromDir, stopDir) {
     const resolvedStopDir = stopDir ? resolve(stopDir) : undefined;
     let currentDir = resolve(searchFromDir);
     while (true) {
-        const candidatePath = join(currentDir, ANGULAR_BRAND_CONFIG_FILE_NAME);
-        if (existsSync(candidatePath) && statSync(candidatePath).isFile()) {
-            return candidatePath;
+        for (const fileName of [
+            CRAFT_DEV_TOOLS_CONFIG_FILE_NAME,
+            ANGULAR_BRAND_CONFIG_FILE_NAME,
+        ]) {
+            const candidatePath = join(currentDir, fileName);
+            if (existsSync(candidatePath) && statSync(candidatePath).isFile()) {
+                return candidatePath;
+            }
         }
         if (resolvedStopDir && currentDir === resolvedStopDir) {
             return undefined;
@@ -187,7 +216,7 @@ export function discoverAngularBrandConfigFilePath(searchFromDir, stopDir) {
     }
 }
 export function loadAngularBrandConfigFromFile(configFilePath) {
-    var _a;
+    var _a, _b;
     const resolvedConfigFilePath = resolve(configFilePath);
     const cachedConfig = angularBrandConfigCache.get(resolvedConfigFilePath);
     if (cachedConfig) {
@@ -213,14 +242,17 @@ export function loadAngularBrandConfigFromFile(configFilePath) {
         const compiledModule = new Function('exports', 'require', 'module', '__filename', '__dirname', transpiled.outputText);
         compiledModule(module.exports, (specifier) => {
             if (specifier === '@craft-ng/dev-tools') {
-                return { defineAngularBrandConfig };
+                return { defineAngularBrandConfig, defineCraftDevToolsConfig };
             }
             return moduleRequire(specifier);
         }, module, resolvedConfigFilePath, dirname(resolvedConfigFilePath));
         const exportedConfig = (_a = module.exports['default']) !== null && _a !== void 0 ? _a : (module.exports['__esModule']
             ? module.exports['default']
             : module.exports);
-        const validatedConfig = validateAngularBrandConfig(exportedConfig, resolvedConfigFilePath);
+        const brandConfig = isCraftDevToolsConfig(exportedConfig)
+            ? ((_b = exportedConfig.brand) !== null && _b !== void 0 ? _b : {})
+            : exportedConfig;
+        const validatedConfig = validateAngularBrandConfig(brandConfig, resolvedConfigFilePath);
         angularBrandConfigCache.set(resolvedConfigFilePath, validatedConfig);
         return validatedConfig;
     }
@@ -1065,7 +1097,11 @@ function ensureGeneratedDependencyTypeImports(sourceFile, generatedDependencyGro
             if (namesToAdd.length === 0) {
                 continue;
             }
-            existingImport.addNamedImports(namesToAdd.map((name) => ({ name, isTypeOnly: true })));
+            const declarationIsTypeOnly = existingImport.isTypeOnly();
+            existingImport.addNamedImports(namesToAdd.map((name) => ({
+                name,
+                isTypeOnly: !declarationIsTypeOnly,
+            })));
             continue;
         }
         sourceFile.addImportDeclaration({