@craft-ts/dev-tools 0.7.0-beta.13

package/src/eslint-rules/server-function-client-match.cjs

@@ -0,0 +1,283 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  Project,
+  SyntaxKind,
+} = require('ts-morph');
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Require server-function client facades to use a unique key matching their imported server definition.',
+    },
+    schema: [],
+    messages: {
+      missingUnique:
+        'createServerFunctionClient must receive craftUnique(<static server function id>), or a craftHandshake(...) shared with the server.',
+      nonStatic:
+        'createServerFunctionClient craftUnique(...) must wrap a string literal server function id.',
+      missingDefinition:
+        'createServerFunctionClient must reference a server definition with a typeof import from the same family.',
+      definitionMismatch:
+        'The client facade server definition does not belong to its *.fn-client.ts family.',
+      idMismatch:
+        'The client facade id "{{clientId}}" does not match server definition id "{{serverId}}".',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    const filePath = context.getFilename();
+
+    if (!filePath || !filePath.endsWith('.fn-client.ts')) {
+      return {};
+    }
+
+    return {
+      'Program:exit'() {
+        const sourceFile = createSourceFile(filePath, sourceCode.getText());
+        if (!sourceFile) return;
+
+        for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+          if (call.getExpression().getText() !== 'createServerFunctionClient') {
+            continue;
+          }
+
+          const reportNode = reportLocation(sourceCode, call.getStart(), call.getEnd());
+          const key = readClientKey(call, filePath);
+          if (key.kind === 'missing') {
+            context.report({ ...reportNode, messageId: 'missingUnique' });
+            continue;
+          }
+          if (key.kind === 'non-static') {
+            context.report({ ...reportNode, messageId: 'nonStatic' });
+            continue;
+          }
+
+          const definition = resolveServerDefinition(sourceFile, call, filePath);
+          if (!definition) {
+            context.report({ ...reportNode, messageId: 'missingDefinition' });
+            continue;
+          }
+
+          const clientFamily = filePath.replace(/\.fn-client\.ts$/, '');
+          const serverFamily = definition.filePath.replace(/\.fn-serveur\.ts$/, '');
+          if (clientFamily !== serverFamily) {
+            context.report({ ...reportNode, messageId: 'definitionMismatch' });
+            continue;
+          }
+
+          if (definition.id !== key.value) {
+            context.report({
+              ...reportNode,
+              messageId: 'idMismatch',
+              data: { clientId: key.value, serverId: definition.id ?? '<unknown>' },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+function createSourceFile(filePath, text) {
+  const project = new Project({
+    compilerOptions: {
+      allowJs: false,
+      module: 99,
+      target: 9,
+      skipLibCheck: true,
+    },
+  });
+  return project.createSourceFile(path.resolve(filePath), text, { overwrite: true });
+}
+
+function readClientKey(call, clientFilePath) {
+  const argument = call.getArguments()[0];
+  // Un `craftHandshake(...)` référencé tient le rôle : les deux côtés passent
+  // alors la même valeur, ce qui est une garantie plus forte que la chaîne
+  // répétée sous `craftUnique`.
+  if (argument && argument.isKind(SyntaxKind.Identifier)) {
+    const handshake = readHandshakeName(
+      call.getSourceFile(),
+      argument.getText(),
+      clientFilePath,
+    );
+    if (handshake !== undefined) return { kind: 'static', value: handshake };
+    return { kind: 'missing' };
+  }
+  if (!argument || !argument.isKind(SyntaxKind.CallExpression)) {
+    return { kind: 'missing' };
+  }
+  if (argument.getExpression().getText() !== 'craftUnique') {
+    return { kind: 'missing' };
+  }
+  const value = argument.getArguments()[0];
+  if (
+    !value ||
+    (!value.isKind(SyntaxKind.StringLiteral) &&
+      !value.isKind(SyntaxKind.NoSubstitutionTemplateLiteral))
+  ) {
+    return { kind: 'non-static' };
+  }
+  return { kind: 'static', value: value.getLiteralValue() };
+}
+
+/**
+ * Nom du `craftHandshake('…')` désigné par un identifiant, déclaré localement
+ * ou importé — la forme recommandée le met dans un module partagé, donc suivre
+ * l'import n'est pas optionnel.
+ */
+function readHandshakeName(sourceFile, variableName, filePath) {
+  const local = handshakeNameInFile(sourceFile, variableName);
+  if (local !== undefined) return local;
+
+  const importDeclaration = sourceFile.getImportDeclarations().find((declaration) =>
+    declaration.getNamedImports().some(
+      (specifier) =>
+        (specifier.getAliasNode()?.getText() ?? specifier.getName()) === variableName,
+    ),
+  );
+  if (!importDeclaration || !filePath) return undefined;
+  const specifier = importDeclaration.getNamedImports().find(
+    (candidate) =>
+      (candidate.getAliasNode()?.getText() ?? candidate.getName()) === variableName,
+  );
+  const importedPath = resolveRelativeImport(
+    filePath,
+    importDeclaration.getModuleSpecifierValue(),
+  );
+  if (!specifier || !importedPath || !fs.existsSync(importedPath)) return undefined;
+  return handshakeNameInFile(
+    createSourceFile(importedPath, fs.readFileSync(importedPath, 'utf8')),
+    specifier.getName(),
+  );
+}
+
+function handshakeNameInFile(sourceFile, variableName) {
+  const initializer = sourceFile.getVariableDeclaration(variableName)?.getInitializer();
+  if (!initializer) return undefined;
+  const call = initializer.isKind?.(SyntaxKind.CallExpression)
+    ? initializer
+    : initializer.getDescendantsOfKind(SyntaxKind.CallExpression).find(
+        (candidate) => candidate.getExpression().getText() === 'craftHandshake',
+      );
+  if (!call || call.getExpression().getText() !== 'craftHandshake') return undefined;
+  const value = call.getArguments()[0];
+  return value?.isKind(SyntaxKind.StringLiteral) ? value.getLiteralValue() : undefined;
+}
+
+function resolveServerDefinition(sourceFile, call, clientFilePath) {
+  const typeArgument = call.getTypeArguments()[0];
+  const typeText = typeArgument?.getText() ?? '';
+  const match = /^typeof\s+([A-Za-z_$][\w$]*)$/.exec(typeText);
+  if (!match) return undefined;
+
+  const importedName = match[1];
+  const importDeclaration = sourceFile.getImportDeclarations().find((declaration) =>
+    declaration.getNamedImports().some((specifier) =>
+      (specifier.getAliasNode()?.getText() ?? specifier.getName()) === importedName,
+    ),
+  );
+  if (!importDeclaration) return undefined;
+
+  const specifier = importDeclaration.getNamedImports().find((candidate) =>
+    (candidate.getAliasNode()?.getText() ?? candidate.getName()) === importedName,
+  );
+  if (!specifier) return undefined;
+
+  const importedFilePath = resolveRelativeImport(
+    clientFilePath,
+    importDeclaration.getModuleSpecifierValue(),
+  );
+  if (!importedFilePath?.endsWith('.fn-serveur.ts')) return undefined;
+
+  const serverSource = createSourceFile(
+    importedFilePath,
+    fs.readFileSync(importedFilePath, 'utf8'),
+  );
+  if (!serverSource) return undefined;
+
+  const declaration = serverSource.getVariableDeclaration(specifier.getName());
+  const serverCall = declaration
+    ?.getInitializer()
+    ?.getDescendantsOfKind(SyntaxKind.CallExpression)
+    .find((candidate) => candidate.getExpression().getText() === 'serverFunction');
+  if (!serverCall) return undefined;
+
+  const firstArgument = serverCall.getArguments()[0];
+  // Le serveur nomme son id soit par une chaîne, soit par un handshake partagé,
+  // soit par un contrat importé — dans cet ordre.
+  const id = firstArgument?.isKind(SyntaxKind.StringLiteral)
+    ? firstArgument.getLiteralValue()
+    : (firstArgument?.isKind(SyntaxKind.Identifier)
+        ? readHandshakeName(serverSource, firstArgument.getText(), importedFilePath)
+        : undefined) ?? readImportedContractId(serverSource, firstArgument);
+
+  return {
+    filePath: importedFilePath,
+    id,
+  };
+}
+
+function readImportedContractId(serverSource, argument) {
+  if (!argument?.isKind(SyntaxKind.Identifier)) return undefined;
+  const contractImport = serverSource.getImportDeclarations().find((declaration) =>
+    declaration.getNamedImports().some((specifier) => specifier.getName() === argument.getText()),
+  );
+  const contractSpecifier = contractImport?.getNamedImports().find(
+    (specifier) => specifier.getName() === argument.getText(),
+  );
+  const contractPath = contractImport
+    ? resolveRelativeImport(
+        serverSource.getFilePath(),
+        contractImport.getModuleSpecifierValue(),
+      )
+    : undefined;
+  if (!contractPath) return undefined;
+
+  const contractSource = createSourceFile(
+    contractPath,
+    fs.readFileSync(contractPath, 'utf8'),
+  );
+  const contractDeclaration = contractSource?.getVariableDeclaration(
+    contractSpecifier?.getAliasNode()?.getText() ?? contractSpecifier?.getName() ?? '',
+  );
+  const contractCall = contractDeclaration
+    ?.getInitializer()
+    ?.getDescendantsOfKind(SyntaxKind.CallExpression)
+    .find((candidate) => candidate.getExpression().getText() === 'serverFunctionContract');
+  const object = contractCall?.getArguments()[0];
+  const idProperty = object?.isKind(SyntaxKind.ObjectLiteralExpression)
+    ? object.getProperty('id')
+    : undefined;
+  const value = idProperty?.isKind(SyntaxKind.PropertyAssignment)
+    ? idProperty.getInitializer()
+    : undefined;
+  return value?.isKind(SyntaxKind.StringLiteral)
+    ? value.getLiteralValue()
+    : undefined;
+}
+
+function resolveRelativeImport(fromFilePath, moduleSpecifier) {
+  if (!moduleSpecifier.startsWith('.')) return undefined;
+  const base = path.resolve(path.dirname(fromFilePath), moduleSpecifier);
+  const candidates = [
+    base,
+    `${base}.ts`,
+    `${base}.tsx`,
+    path.join(base, 'index.ts'),
+  ];
+  return candidates.find((candidate) => fs.existsSync(candidate));
+}
+
+function reportLocation(sourceCode, start, end) {
+  return {
+    loc: {
+      start: sourceCode.getLocFromIndex(start),
+      end: sourceCode.getLocFromIndex(end),
+    },
+  };
+}

package/src/eslint-rules/target-blank-noopener.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+const { parseHyperscriptCall, hasProp, staticPropString } = require('./hyperscript-walk.cjs');
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Require rel="noopener" (or noreferrer) when target="_blank".',
+    },
+    schema: [],
+    messages: {
+      missing:
+        'target="_blank" requires rel to include "noopener" (or "noreferrer").',
+    },
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        const call = parseHyperscriptCall(node);
+        if (!call) return;
+        const target = staticPropString(call.props, 'target');
+        if (target !== '_blank') return;
+        const rel = staticPropString(call.props, 'rel') ?? '';
+        if (/\bnoopener\b/.test(rel) || /\bnoreferrer\b/.test(rel)) return;
+        if (hasProp(call.props, 'rel') && !rel) return;
+        context.report({ node, messageId: 'missing' });
+      },
+    };
+  },
+};

package/src/eslint-rules/template-element-name-unique.cjs

@@ -0,0 +1,124 @@
+const { NAMED_HTML_HELPER_SET: HTML_HELPERS } = require('./html-helpers.cjs');
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Require unique literal tag/local-name pairs in each Craft component template.',
+    },
+    schema: [],
+    messages: {
+      duplicate:
+        'The template element name "{{key}}" is declared more than once in this component.',
+      literal:
+        'Craft template element names must be string literals that can be resolved statically.',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+
+    return {
+      CallExpression(node) {
+        if (
+          node.callee.type !== 'Identifier' ||
+          node.callee.name !== 'craftComponent' ||
+          node.arguments.length < 4
+        ) {
+          return;
+        }
+
+        const template = node.arguments[3];
+        const seen = new Map();
+
+        walk(template, (candidate) => {
+          if (
+            candidate !== template &&
+            candidate.type === 'CallExpression' &&
+            candidate.callee.type === 'Identifier' &&
+            candidate.callee.name === 'craftComponent'
+          ) {
+            return 'skip';
+          }
+
+          if (
+            candidate.type !== 'CallExpression' ||
+            candidate.callee.type !== 'Identifier' ||
+            !HTML_HELPERS.has(candidate.callee.name) ||
+            candidate.arguments.length < 2
+          ) {
+            return;
+          }
+
+          const name = candidate.arguments[0];
+          const props = candidate.arguments[1];
+          if (
+            name.type === 'ObjectExpression' ||
+            name.type === 'ArrayExpression' ||
+            isNullLiteral(name)
+          ) {
+            return;
+          }
+
+          if (!isStringLiteral(name)) {
+            context.report({ node: name, messageId: 'literal' });
+            return;
+          }
+
+          // A second argument is the props position in the named helper form.
+          // Keep the check deliberately structural so branches and each bodies
+          // are inspected without evaluating user code.
+          if (props.type === 'ObjectExpression' || isNullLiteral(props)) {
+            const key = `${candidate.callee.name}:${stringLiteralValue(name)}`;
+            if (seen.has(key)) {
+              context.report({
+                node: name,
+                messageId: 'duplicate',
+                data: { key },
+              });
+            } else {
+              seen.set(key, name);
+            }
+          }
+        });
+      },
+    };
+
+    function walk(node, visit) {
+      if (!node || typeof node.type !== 'string') return;
+      const result = visit(node);
+      if (result === 'skip') return;
+
+      const keys = sourceCode.visitorKeys[node.type] ?? [];
+      for (const key of keys) {
+        const child = node[key];
+        if (Array.isArray(child)) {
+          child.forEach((item) => walk(item, visit));
+        } else {
+          walk(child, visit);
+        }
+      }
+    }
+  },
+};
+
+function isStringLiteral(node) {
+  return (
+    (node.type === 'Literal' && typeof node.value === 'string') ||
+    (node.type === 'TemplateLiteral' &&
+      node.expressions.length === 0 &&
+      node.quasis.length === 1)
+  );
+}
+
+function isNullLiteral(node) {
+  return (
+    node.type === 'NullLiteral' ||
+    (node.type === 'Literal' && node.value === null)
+  );
+}
+
+function stringLiteralValue(node) {
+  return node.type === 'Literal' ? node.value : node.quasis[0].value.cooked;
+}

package/src/eslint-rules/valid-aria.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+const ariaQuery = require('aria-query');
+const { parseHyperscriptCall } = require('./hyperscript-walk.cjs');
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Reject unknown aria-* attributes on Craft hyperscript nodes.',
+    },
+    schema: [],
+    messages: {
+      unknown: '"{{name}}" is not a valid ARIA attribute.',
+    },
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        const call = parseHyperscriptCall(node);
+        if (!call?.props || call.props.type !== 'ObjectExpression') return;
+        for (const entry of call.props.properties) {
+          if (entry.type !== 'Property' || entry.computed) continue;
+          const name =
+            entry.key.type === 'Identifier'
+              ? entry.key.name
+              : entry.key.type === 'Literal'
+                ? String(entry.key.value)
+                : '';
+          if (!name.startsWith('aria-')) continue;
+          if (!ariaQuery.aria.has(name)) {
+            context.report({ node: entry.key, messageId: 'unknown', data: { name } });
+          }
+        }
+      },
+    };
+  },
+};

package/src/generators/route/compat.d.ts

@@ -0,0 +1,3 @@
+export declare const routeSchematic: (generatorOptions: import("./schema.js").RouteGeneratorSchema) => (tree: any, context: any) => Promise<any>;
+export declare const routeSplitSchematic: (generatorOptions: import("./schema.js").RouteSplitGeneratorSchema) => (tree: any, context: any) => Promise<any>;
+export default routeSchematic;

package/src/generators/route/compat.js

@@ -0,0 +1,6 @@
+import { convertNxGenerator } from '@nx/devkit';
+import { routeGenerator, routeSplitGenerator } from './generator.js';
+export const routeSchematic = convertNxGenerator(routeGenerator);
+export const routeSplitSchematic = convertNxGenerator(routeSplitGenerator);
+export default routeSchematic;
+//# sourceMappingURL=compat.js.map

package/src/generators/route/compat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compat.js","sourceRoot":"","sources":["../../../../../../libs/dev-tools/src/generators/route/compat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAErE,MAAM,CAAC,MAAM,cAAc,GAAG,kBAAkB,CAAC,cAAc,CAAC,CAAC;AACjE,MAAM,CAAC,MAAM,mBAAmB,GAAG,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;AAE3E,eAAe,cAAc,CAAC"}

package/src/generators/route/generator.d.ts

@@ -0,0 +1,31 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+import type { RouteGeneratorSchema, RouteSplitGeneratorSchema } from './schema.js';
+export declare function routeGenerator(tree: Tree, options: RouteGeneratorSchema): Promise<GeneratorCallback | void>;
+type ConfiguredRouteTargetOptions = Pick<RouteGeneratorSchema, 'component' | 'createComponent' | 'redirectTo'>;
+type ComponentCreationTarget = {
+    name: string;
+    path: string;
+};
+type ResolvedRouteTargetOptions = {
+    component?: string;
+    createComponent?: ComponentCreationTarget;
+    redirectTo?: string;
+};
+type RouteQuestion = (prompt: string) => Promise<string>;
+type RouteParentOption = {
+    collectionName: string;
+    filePath: string;
+    routesName: string;
+};
+export declare function resolveRouteParentOption(parents: RouteParentOption[], interactive: {
+    configuredParent?: string;
+    rootDir: string;
+    routePath: string;
+    ask?: RouteQuestion;
+}): Promise<string | undefined>;
+export declare function resolveRouteTargetOptions(options: ConfiguredRouteTargetOptions, interactive: {
+    componentBase: string;
+    ask?: RouteQuestion;
+}): Promise<ResolvedRouteTargetOptions>;
+export declare function routeSplitGenerator(tree: Tree, options: RouteSplitGeneratorSchema): Promise<GeneratorCallback | void>;
+export default routeGenerator;