@memoized-dom/language-service 0.0.2

package/README.md

@@ -0,0 +1,33 @@
+# @memoized-dom/language-service
+
+TypeScript editor diagnostics and code fixes for memoized-dom. Compiler errors
+come from `@memoized-dom/compiler`'s structured graph diagnostic API, so the
+editor, Vite overlay, and direct compiler report the same restrictions.
+
+Add the plugin to the application `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "plugins": [
+      {
+        "name": "@memoized-dom/language-service"
+      }
+    ]
+  }
+}
+```
+
+TypeScript language-service plugins run in editors powered by tsserver. They
+do not add diagnostics to standalone `tsc`; the analysis core is kept separate
+so a future CLI can report the same diagnostics in CI.
+
+The first diagnostic suggests `const` for initialized `let` bindings that are
+never reassigned. Its message explains that memoized-dom reactivity follows
+reads and writes rather than declaration keywords; `const` arrays and objects
+can still mutate their contents. The editor fix changes only the declaration
+keyword.
+
+Set `"preferConst": false` on the plugin entry to disable this diagnostic.
+Set `"compilerDiagnostics": false` only when compiler errors should be hidden
+from tsserver.

package/dist/diagnostics/catalog.d.ts

@@ -0,0 +1,8 @@
+import { compilerDiagnosticCode, compilerDiagnosticSource as diagnosticSource } from '@memoized-dom/compiler';
+export { compilerDiagnosticCode, diagnosticSource };
+export declare const diagnosticCodes: {
+    readonly compiler: 98000;
+    readonly preferConst: 98001;
+};
+export declare function preferConstMessage(names: readonly string[]): string;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/diagnostics/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../src/diagnostics/catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,wBAAwB,IAAI,gBAAgB,EAC7C,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,CAAC;AAEpD,eAAO,MAAM,eAAe;;;CAGlB,CAAC;AAEX,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAUnE"}

package/dist/diagnostics/prefer-const.d.ts

@@ -0,0 +1,6 @@
+import type * as ts from 'typescript';
+type TypeScript = typeof ts;
+export declare function collectPreferConstDiagnostics(typescript: TypeScript, program: ts.Program, sourceFile: ts.SourceFile): ts.DiagnosticWithLocation[];
+export declare function createPreferConstCodeFix(typescript: TypeScript, sourceFile: ts.SourceFile, diagnosticStart: number): ts.CodeFixAction | null;
+export {};
+//# sourceMappingURL=prefer-const.d.ts.map

package/dist/diagnostics/prefer-const.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-const.d.ts","sourceRoot":"","sources":["../../src/diagnostics/prefer-const.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAOtC,KAAK,UAAU,GAAG,OAAO,EAAE,CAAC;AAQ5B,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,EAAE,CAAC,OAAO,EACnB,UAAU,EAAE,EAAE,CAAC,UAAU,GACxB,EAAE,CAAC,sBAAsB,EAAE,CA6B7B;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,EAAE,CAAC,UAAU,EACzB,eAAe,EAAE,MAAM,GACtB,EAAE,CAAC,aAAa,GAAG,IAAI,CAyBzB"}

package/dist/index.cjs

@@ -0,0 +1,353 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => initialize
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/plugin.ts
+var import_compiler2 = require("@memoized-dom/compiler");
+
+// src/diagnostics/catalog.ts
+var import_compiler = require("@memoized-dom/compiler");
+var diagnosticCodes = {
+  compiler: import_compiler.compilerDiagnosticCode,
+  preferConst: 98001
+};
+function preferConstMessage(names) {
+  const binding = names.length === 1 ? `'${names[0]}' is` : `Bindings ${names.map((name) => `'${name}'`).join(", ")} are`;
+  return `${binding} never reassigned. Use const; memoized-dom reactivity follows state reads and assignments, not let declarations. const arrays and objects may still mutate their contents.`;
+}
+
+// src/diagnostics/prefer-const.ts
+function collectPreferConstDiagnostics(typescript, program, sourceFile) {
+  if (sourceFile.isDeclarationFile) return [];
+  const checker = program.getTypeChecker();
+  const candidates = collectCandidates(typescript, checker, sourceFile);
+  if (candidates.length === 0) return [];
+  const candidateSymbols = new Set(
+    candidates.flatMap((candidate) => candidate.symbols)
+  );
+  const reassigned = collectReassignedSymbols(
+    typescript,
+    checker,
+    sourceFile,
+    candidateSymbols
+  );
+  return candidates.filter(
+    (candidate) => candidate.symbols.every((symbol) => !reassigned.has(symbol))
+  ).map((candidate) => ({
+    file: sourceFile,
+    start: candidate.declarationList.getStart(sourceFile),
+    length: "let".length,
+    category: typescript.DiagnosticCategory.Suggestion,
+    code: diagnosticCodes.preferConst,
+    source: import_compiler.compilerDiagnosticSource,
+    messageText: preferConstMessage(candidate.names)
+  }));
+}
+function createPreferConstCodeFix(typescript, sourceFile, diagnosticStart2) {
+  const declarationList = findDeclarationList(
+    typescript,
+    sourceFile,
+    diagnosticStart2
+  );
+  if (declarationList === null) return null;
+  return {
+    fixName: "memoizedDomPreferConst",
+    description: "Change let to const",
+    changes: [
+      {
+        fileName: sourceFile.fileName,
+        textChanges: [
+          {
+            span: {
+              start: declarationList.getStart(sourceFile),
+              length: "let".length
+            },
+            newText: "const"
+          }
+        ]
+      }
+    ]
+  };
+}
+function collectCandidates(typescript, checker, sourceFile) {
+  const candidates = [];
+  const visit = (node) => {
+    if (typescript.isVariableStatement(node) && (node.declarationList.flags & typescript.NodeFlags.Let) !== 0 && node.declarationList.declarations.every(
+      (declaration) => declaration.initializer !== void 0
+    )) {
+      const identifiers = node.declarationList.declarations.flatMap(
+        (declaration) => bindingIdentifiers(typescript, declaration.name)
+      );
+      const bindings = identifiers.map((identifier) => ({
+        name: identifier.text,
+        symbol: checker.getSymbolAtLocation(identifier)
+      })).filter(
+        (binding) => binding.symbol !== void 0
+      );
+      if (bindings.length === identifiers.length && bindings.length > 0) {
+        candidates.push({
+          declarationList: node.declarationList,
+          names: bindings.map((binding) => binding.name),
+          symbols: bindings.map((binding) => binding.symbol)
+        });
+      }
+    }
+    typescript.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return candidates;
+}
+function collectReassignedSymbols(typescript, checker, sourceFile, candidates) {
+  const reassigned = /* @__PURE__ */ new Set();
+  const markTarget = (node) => {
+    const target = unwrapTarget(typescript, node);
+    if (typescript.isIdentifier(target)) {
+      const symbol = checker.getSymbolAtLocation(target);
+      if (symbol !== void 0 && candidates.has(symbol)) {
+        reassigned.add(symbol);
+      }
+      return;
+    }
+    if (typescript.isArrayLiteralExpression(target)) {
+      for (const element of target.elements) {
+        if (!typescript.isOmittedExpression(element)) markTarget(element);
+      }
+      return;
+    }
+    if (typescript.isObjectLiteralExpression(target)) {
+      for (const property of target.properties) {
+        if (typescript.isShorthandPropertyAssignment(property)) {
+          markTarget(property.name);
+        } else if (typescript.isPropertyAssignment(property)) {
+          markTarget(property.initializer);
+        } else if (typescript.isSpreadAssignment(property)) {
+          markTarget(property.expression);
+        }
+      }
+    }
+  };
+  const visit = (node) => {
+    if (typescript.isBinaryExpression(node) && node.operatorToken.kind >= typescript.SyntaxKind.FirstAssignment && node.operatorToken.kind <= typescript.SyntaxKind.LastAssignment) {
+      markTarget(node.left);
+    } else if ((typescript.isPrefixUnaryExpression(node) || typescript.isPostfixUnaryExpression(node)) && (node.operator === typescript.SyntaxKind.PlusPlusToken || node.operator === typescript.SyntaxKind.MinusMinusToken)) {
+      markTarget(node.operand);
+    } else if ((typescript.isForInStatement(node) || typescript.isForOfStatement(node)) && !typescript.isVariableDeclarationList(node.initializer)) {
+      markTarget(node.initializer);
+    }
+    typescript.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return reassigned;
+}
+function bindingIdentifiers(typescript, name) {
+  if (typescript.isIdentifier(name)) return [name];
+  return name.elements.flatMap(
+    (element) => typescript.isOmittedExpression(element) ? [] : bindingIdentifiers(typescript, element.name)
+  );
+}
+function unwrapTarget(typescript, node) {
+  while (typescript.isParenthesizedExpression(node) || typescript.isAsExpression(node) || typescript.isTypeAssertionExpression(node) || typescript.isNonNullExpression(node) || typescript.isSatisfiesExpression(node)) {
+    node = node.expression;
+  }
+  return node;
+}
+function findDeclarationList(typescript, sourceFile, start) {
+  let found = null;
+  const visit = (node) => {
+    if (found !== null || start < node.getFullStart() || start > node.end) {
+      return;
+    }
+    if (typescript.isVariableDeclarationList(node) && (node.flags & typescript.NodeFlags.Let) !== 0 && node.getStart(sourceFile) === start) {
+      found = node;
+      return;
+    }
+    typescript.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return found;
+}
+
+// src/plugin.ts
+function createLanguageService(typescript, info) {
+  const original = info.languageService;
+  const proxy = bindLanguageService(original);
+  const config = info.config;
+  const preferConstCache = /* @__PURE__ */ new WeakMap();
+  const compilerCache = /* @__PURE__ */ new WeakMap();
+  proxy.getSemanticDiagnostics = (fileName) => {
+    const diagnostics = original.getSemanticDiagnostics(fileName);
+    const program = original.getProgram();
+    const sourceFile = program?.getSourceFile(fileName);
+    if (program === void 0 || sourceFile === void 0) {
+      return diagnostics;
+    }
+    const customDiagnostics = [];
+    if (config.preferConst !== false) {
+      let preferConst = preferConstCache.get(sourceFile);
+      if (preferConst === void 0) {
+        preferConst = collectPreferConstDiagnostics(
+          typescript,
+          program,
+          sourceFile
+        );
+        preferConstCache.set(sourceFile, preferConst);
+      }
+      customDiagnostics.push(...preferConst);
+    }
+    if (config.compilerDiagnostics !== false) {
+      let byFile = compilerCache.get(program);
+      if (byFile === void 0) {
+        byFile = collectCompilerDiagnostics(
+          typescript,
+          program
+        );
+        compilerCache.set(program, byFile);
+      }
+      customDiagnostics.push(...byFile.get(normalizePath(fileName)) ?? []);
+    }
+    return [...diagnostics, ...customDiagnostics];
+  };
+  proxy.getCodeFixesAtPosition = (fileName, start, end, errorCodes, formatOptions, preferences) => {
+    const fixes = original.getCodeFixesAtPosition(
+      fileName,
+      start,
+      end,
+      errorCodes,
+      formatOptions,
+      preferences
+    );
+    if (config.preferConst === false || !errorCodes.includes(diagnosticCodes.preferConst)) {
+      return fixes;
+    }
+    const sourceFile = original.getProgram()?.getSourceFile(fileName);
+    if (sourceFile === void 0) return fixes;
+    const fix = createPreferConstCodeFix(
+      typescript,
+      sourceFile,
+      start
+    );
+    return fix === null ? fixes : [...fixes, fix];
+  };
+  return proxy;
+}
+function collectCompilerDiagnostics(typescript, program) {
+  const sourceFiles = program.getSourceFiles().filter(
+    (sourceFile) => !sourceFile.isDeclarationFile && !normalizePath(sourceFile.fileName).includes("/node_modules/") && /\.[jt]sx?$/.test(sourceFile.fileName)
+  );
+  const modules = Object.fromEntries(
+    sourceFiles.map((sourceFile) => [
+      normalizePath(sourceFile.fileName),
+      sourceFile.text
+    ])
+  );
+  const diagnostics = (0, import_compiler2.diagnoseModules)(modules, {
+    resolveImport(specifier, importer) {
+      const resolution = typescript.resolveModuleName(
+        specifier,
+        importer,
+        program.getCompilerOptions(),
+        typescript.sys
+      ).resolvedModule;
+      if (resolution === void 0) return void 0;
+      const resolved = normalizePath(resolution.resolvedFileName);
+      return Object.hasOwn(modules, resolved) ? resolved : void 0;
+    }
+  });
+  const byFile = /* @__PURE__ */ new Map();
+  for (const diagnostic of diagnostics) {
+    const moduleId = diagnostic.moduleId;
+    const sourceFile = moduleId === void 0 ? sourceFiles[0] : sourceFiles.find(
+      (candidate) => normalizePath(candidate.fileName) === moduleId
+    );
+    if (sourceFile === void 0) continue;
+    const converted = compilerDiagnostic(
+      typescript,
+      sourceFile,
+      diagnostic
+    );
+    const key = normalizePath(sourceFile.fileName);
+    const list = byFile.get(key) ?? [];
+    list.push(converted);
+    byFile.set(key, list);
+  }
+  return byFile;
+}
+function compilerDiagnostic(typescript, sourceFile, diagnostic) {
+  const start = diagnosticStart(sourceFile, diagnostic);
+  return {
+    file: sourceFile,
+    start,
+    length: Math.min(1, Math.max(0, sourceFile.text.length - start)),
+    category: typescript.DiagnosticCategory.Error,
+    code: diagnosticCodes.compiler,
+    source: import_compiler.compilerDiagnosticSource,
+    messageText: diagnostic.message
+  };
+}
+function diagnosticStart(sourceFile, diagnostic) {
+  if (diagnostic.line !== void 0 && diagnostic.column !== void 0) {
+    const line = Math.max(0, diagnostic.line - 1);
+    if (line < sourceFile.getLineStarts().length) {
+      return sourceFile.getPositionOfLineAndCharacter(line, diagnostic.column);
+    }
+  }
+  const binding = diagnostic.message.match(/'([^']+)'/)?.[1];
+  if (binding !== void 0) {
+    const position = sourceFile.text.indexOf(binding);
+    if (position !== -1) return position;
+  }
+  return 0;
+}
+function normalizePath(fileName) {
+  return fileName.replaceAll("\\", "/");
+}
+function bindLanguageService(languageService) {
+  const proxy = /* @__PURE__ */ Object.create(null);
+  const writable = proxy;
+  for (const key of Object.keys(languageService)) {
+    const member = languageService[key];
+    if (typeof member === "function") {
+      writable[key] = (...args) => member.apply(
+        languageService,
+        args
+      );
+    } else {
+      writable[key] = member;
+    }
+  }
+  return proxy;
+}
+
+// src/index.ts
+function initialize({
+  typescript
+}) {
+  return {
+    create(info) {
+      return createLanguageService(typescript, info);
+    }
+  };
+}
+module.exports = module.exports.default;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import type * as ts from 'typescript';
+type TypeScript = typeof ts;
+/**
+ * tsserver requires the package's CommonJS value to be this factory function.
+ * The package build footer unwraps this default export after bundling.
+ */
+export default function initialize({ typescript, }: {
+    typescript: TypeScript;
+}): ts.server.PluginModule;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAGtC,KAAK,UAAU,GAAG,OAAO,EAAE,CAAC;AAE5B;;;GAGG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,EACjC,UAAU,GACX,EAAE;IACD,UAAU,EAAE,UAAU,CAAC;CACxB,GAAG,EAAE,CAAC,MAAM,CAAC,YAAY,CAMzB"}

package/dist/plugin.d.ts

@@ -0,0 +1,5 @@
+import type * as ts from 'typescript';
+type TypeScript = typeof ts;
+export declare function createLanguageService(typescript: TypeScript, info: ts.server.PluginCreateInfo): ts.LanguageService;
+export {};
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AActC,KAAK,UAAU,GAAG,OAAO,EAAE,CAAC;AAO5B,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,gBAAgB,GAC/B,EAAE,CAAC,eAAe,CAgFpB"}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@memoized-dom/language-service",
+  "version": "0.0.2",
+  "description": "TypeScript language-service diagnostics and code fixes for memoized-dom",
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.11.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "bun run ./scripts/clean.ts && esbuild ./src/index.ts --bundle --outfile=./dist/index.cjs --platform=node --format=cjs --target=node24 --packages=external --footer:js=\"module.exports = module.exports.default;\" && tsc -p tsconfig.build.json",
+    "test": "vitest run --config vitest.config.ts"
+  },
+  "dependencies": {
+    "@memoized-dom/compiler": "^0.0.6"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.7 <7"
+  },
+  "publishConfig": {
+    "access": "public"
+}
+}