@toloka-platform/sdk 0.1.0-preview.6 → 0.1.0-preview.7

package/src/checks/task-ui-typecheck.ts

@@ -0,0 +1,345 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+
+import { assert } from "es-toolkit";
+import { type OxcError, parseSync } from "oxc-parser";
+import ts from "typescript-api";
+import { taskUiDeclarationSnapshot } from "./task-ui-declarations.generated";
+import {
+  createDefaultMapFromNodeModules,
+  createSystem,
+  createVirtualTypeScriptEnvironment,
+} from "./typescript-vfs.js";
+
+const tsLibDirectory = path.dirname(createRequire(import.meta.url).resolve("typescript-api"));
+
+const BLOCK_MARKERS = {
+  data: "DATA_INJECTION",
+  constants: "CONST_INJECTION",
+  preprocess: "PREPROCESS_INJECTION",
+  postprocess: "POSTPROCESS_INJECTION",
+  code: "CODE_INJECTION",
+};
+
+export type TaskUiBlockKey = keyof typeof BLOCK_MARKERS;
+
+export type TaskUiDiagnostic = {
+  severity: "error" | "warning";
+  text: string;
+};
+
+export type TaskUiDiagnosticsReport = Record<TaskUiBlockKey, TaskUiDiagnostic[]>;
+
+export type TaskUiSource = Record<TaskUiBlockKey, string>;
+
+export type TaskUiDeclarationSource = {
+  readonly reactDeclaration: string;
+  readonly elementsDeclaration: string;
+};
+
+const FILE_NAME = "index.tsx";
+
+const blockEntries: Array<[TaskUiBlockKey, string]> = [
+  ["data", BLOCK_MARKERS.data],
+  ["constants", BLOCK_MARKERS.constants],
+  ["preprocess", BLOCK_MARKERS.preprocess],
+  ["postprocess", BLOCK_MARKERS.postprocess],
+  ["code", BLOCK_MARKERS.code],
+];
+
+const emptyReport = (): TaskUiDiagnosticsReport => ({
+  data: [],
+  constants: [],
+  preprocess: [],
+  postprocess: [],
+  code: [],
+});
+
+const buildCompositeSource = (input: TaskUiSource): string => `
+import * as React from 'react';
+import { View, Field, Layout, SuspensePendingMarker, Validation, actions } from 'elements';
+
+declare global {
+const data: /* DATA_INJECTION_START */
+(
+${input.data}
+)
+/* DATA_INJECTION_END */ & { [key: string]: any };
+}
+
+declare global {
+const CONST: /* CONST_INJECTION_START */
+(
+${input.constants}
+)
+/* CONST_INJECTION_END */ & { [key: string]: any };
+}
+
+(() => /* PREPROCESS_INJECTION_START */
+{
+${input.preprocess}
+}
+/* PREPROCESS_INJECTION_END */ )()
+
+(() => /* POSTPROCESS_INJECTION_START */
+{
+${input.postprocess}
+}
+/* POSTPROCESS_INJECTION_END */ )()
+
+/* CODE_INJECTION_START */
+(
+${input.code}
+)
+/* CODE_INJECTION_END */
+
+export {}`;
+
+const buildRuntimeSource = (input: TaskUiSource): string => `
+const data = (
+/* DATA_INJECTION_START */
+${input.data}
+/* DATA_INJECTION_END */
+);
+
+const CONST = (
+/* CONST_INJECTION_START */
+${input.constants}
+/* CONST_INJECTION_END */
+);
+
+const preprocess = (data) => {
+/* PREPROCESS_INJECTION_START */
+${input.preprocess}
+/* PREPROCESS_INJECTION_END */
+};
+
+const postprocess = (data) => {
+/* POSTPROCESS_INJECTION_START */
+${input.postprocess}
+/* POSTPROCESS_INJECTION_END */
+};
+
+const code = (
+/* CODE_INJECTION_START */
+${input.code}
+/* CODE_INJECTION_END */
+);
+`;
+
+const runtimeJavaScriptBlocks: TaskUiBlockKey[] = ["preprocess", "postprocess", "code"];
+
+const mergeRuntimeDiagnostics = (
+  typeScriptReport: TaskUiDiagnosticsReport,
+  syntacticReport: TaskUiDiagnosticsReport,
+  runtimeReport: TaskUiDiagnosticsReport,
+): TaskUiDiagnosticsReport => {
+  const report = { ...typeScriptReport };
+
+  for (const block of runtimeJavaScriptBlocks) {
+    const syntacticTexts = new Set(syntacticReport[block].map((diagnostic) => diagnostic.text));
+    const semanticDiagnostics = typeScriptReport[block].filter(
+      (diagnostic) =>
+        !syntacticTexts.has(diagnostic.text) && !/TS(?:7006|7031)\b/u.test(diagnostic.text),
+    );
+    const syntaxDiagnostics =
+      runtimeReport[block].length > 0 ? runtimeReport[block] : syntacticReport[block];
+    report[block] = [...semanticDiagnostics, ...syntaxDiagnostics];
+  }
+
+  return report;
+};
+
+const mapDiagnosticsToBlocks = (
+  source: string,
+  diagnostics: readonly ts.Diagnostic[],
+): TaskUiDiagnosticsReport => {
+  const getDiagnosticsForBlock = (marker: string): TaskUiDiagnostic[] => {
+    const start = source.indexOf(`/* ${marker}_START */`) + `/* ${marker}_START */`.length + 1;
+    const end = source.indexOf(`/* ${marker}_END */`) - 1;
+
+    return diagnostics
+      .filter((diagnostic) => {
+        if (!diagnostic.file || diagnostic.start == null) return false;
+        return diagnostic.start >= start && diagnostic.start <= end;
+      })
+      .map((diagnostic) => {
+        const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+        const severity = diagnostic.category === ts.DiagnosticCategory.Error ? "error" : "warning";
+        assert(diagnostic.file && diagnostic.start != null, "Diagnostic location is missing");
+        const { line: startLine, character: startCharacter } =
+          diagnostic.file.getLineAndCharacterOfPosition(start);
+        const { line: originalLine, character: originalCharacter } =
+          diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+        const line = originalLine - startLine;
+        const character =
+          originalLine === startLine ? originalCharacter - startCharacter : originalCharacter;
+        const lineText = diagnostic.file.text.split(/\r?\n/gu)[originalLine] ?? "";
+        const pointer =
+          " ".repeat(originalCharacter) +
+          "^".repeat(diagnostic.length && diagnostic.length > 0 ? diagnostic.length : 1);
+
+        return {
+          severity,
+          text: [
+            `${line}:${character + 1} - [${ts.DiagnosticCategory[diagnostic.category]}] TS${diagnostic.code}`,
+            message,
+            "",
+            lineText,
+            pointer,
+          ].join("\n"),
+        };
+      });
+  };
+
+  return {
+    data: getDiagnosticsForBlock(BLOCK_MARKERS.data),
+    constants: getDiagnosticsForBlock(BLOCK_MARKERS.constants),
+    preprocess: getDiagnosticsForBlock(BLOCK_MARKERS.preprocess),
+    postprocess: getDiagnosticsForBlock(BLOCK_MARKERS.postprocess),
+    code: getDiagnosticsForBlock(BLOCK_MARKERS.code),
+  };
+};
+
+const mapParseErrorsToBlocks = (
+  source: string,
+  errors: readonly OxcError[],
+): TaskUiDiagnosticsReport => {
+  const lineStartOffsets = [0];
+  for (let index = 0; index < source.length; index += 1) {
+    if (source[index] === "\n") lineStartOffsets.push(index + 1);
+  }
+
+  const getLineAndCharacterOfPosition = (position: number) => {
+    let line = 0;
+    while (line + 1 < lineStartOffsets.length && lineStartOffsets[line + 1]! <= position) {
+      line += 1;
+    }
+    return { line, character: position - lineStartOffsets[line]! };
+  };
+
+  const sourceLines = source.split(/\r?\n/gu);
+  const blocks = blockEntries.map(([key, marker]) => ({
+    key,
+    start: source.indexOf(`/* ${marker}_START */`) + `/* ${marker}_START */`.length + 1,
+    end: source.indexOf(`/* ${marker}_END */`) - 1,
+  }));
+  const findBlockForPosition = (position: number) => {
+    const containing = blocks.find((block) => position >= block.start && position <= block.end);
+    if (containing) return containing;
+    const preceding = blocks.filter((block) => block.start <= position);
+    const block = preceding.at(-1) ?? blocks[0];
+    assert(block, "Task UI diagnostic block is missing");
+    return block;
+  };
+
+  const report = emptyReport();
+  for (const error of errors) {
+    const label = error.labels[0];
+    const position = label?.start ?? source.length;
+    const block = findBlockForPosition(position);
+    const severity = error.severity === "Error" ? "error" : "warning";
+    const { line: startLine, character: startCharacter } = getLineAndCharacterOfPosition(
+      block.start,
+    );
+    const { line: originalLine, character: originalCharacter } =
+      getLineAndCharacterOfPosition(position);
+    const line = originalLine - startLine;
+    const character =
+      originalLine === startLine ? originalCharacter - startCharacter : originalCharacter;
+    const lineText = sourceLines[originalLine] ?? "";
+    const length = label ? label.end - label.start : 0;
+    const pointer = " ".repeat(originalCharacter) + "^".repeat(length > 0 ? length : 1);
+
+    report[block.key].push({
+      severity,
+      text: [
+        `${line}:${character + 1} - [${error.severity}]`,
+        error.message,
+        "",
+        lineText,
+        pointer,
+      ].join("\n"),
+    });
+  }
+
+  return report;
+};
+
+export const createTaskUiTypechecker = ({
+  reactDeclaration,
+  elementsDeclaration,
+}: TaskUiDeclarationSource) => ({
+  performTypeCheck: async (input: TaskUiSource): Promise<TaskUiDiagnosticsReport> => {
+    const source = buildCompositeSource(input);
+    const fsMap = createDefaultMapFromNodeModules(
+      { target: ts.ScriptTarget.Latest },
+      ts,
+      tsLibDirectory,
+    );
+    fsMap.set("node_modules/@types/react/index.d.ts", reactDeclaration);
+    fsMap.set("node_modules/elements/index.d.ts", elementsDeclaration);
+    fsMap.set(FILE_NAME, source);
+    const system = createSystem(fsMap);
+    const { languageService } = createVirtualTypeScriptEnvironment(system, [FILE_NAME], ts, {
+      target: ts.ScriptTarget.Latest,
+      allowNonTsExtensions: true,
+      ignoreDeprecations: "6.0",
+      module: ts.ModuleKind.CommonJS,
+      moduleResolution: ts.ModuleResolutionKind.Node10,
+      noEmit: true,
+      typeRoots: ["node_modules/@types"],
+      jsx: ts.JsxEmit.React,
+      jsxFactory: "React.createElement",
+      noErrorTruncation: true,
+    });
+
+    let syntacticDiagnostics: ts.Diagnostic[] = [];
+    let otherDiagnostics: ts.Diagnostic[] = [];
+    try {
+      syntacticDiagnostics = languageService.getSyntacticDiagnostics(FILE_NAME);
+      otherDiagnostics = [
+        ...languageService.getSemanticDiagnostics(FILE_NAME),
+        ...languageService.getSuggestionDiagnostics(FILE_NAME),
+        ...languageService.getCompilerOptionsDiagnostics(),
+      ];
+    } finally {
+      languageService.dispose();
+    }
+
+    const syntacticReport = mapDiagnosticsToBlocks(source, syntacticDiagnostics);
+    const typeScriptReport = mapDiagnosticsToBlocks(source, [
+      ...syntacticDiagnostics,
+      ...otherDiagnostics,
+    ]);
+    const runtimeSource = buildRuntimeSource(input);
+    const runtimeReport = mapParseErrorsToBlocks(
+      runtimeSource,
+      parseSync("runtime.jsx", runtimeSource).errors,
+    );
+    return mergeRuntimeDiagnostics(typeScriptReport, syntacticReport, runtimeReport);
+  },
+
+  performSyntaxCheck: (input: TaskUiSource): TaskUiDiagnosticsReport => {
+    const typeScriptSource = buildCompositeSource(input);
+    const typeScriptReport = mapParseErrorsToBlocks(
+      typeScriptSource,
+      parseSync(FILE_NAME, typeScriptSource).errors,
+    );
+    const runtimeSource = buildRuntimeSource(input);
+    const runtimeReport = mapParseErrorsToBlocks(
+      runtimeSource,
+      parseSync("runtime.jsx", runtimeSource).errors,
+    );
+    return mergeRuntimeDiagnostics(typeScriptReport, typeScriptReport, runtimeReport);
+  },
+});
+
+export const createBundledTaskUiTypechecker = () =>
+  createTaskUiTypechecker({
+    reactDeclaration: taskUiDeclarationSnapshot.react.source,
+    elementsDeclaration: taskUiDeclarationSnapshot.elements.source,
+  });
+
+export type TaskUiTypechecker = ReturnType<typeof createTaskUiTypechecker>;
+export { taskUiDeclarationSnapshot } from "./task-ui-declarations.generated";

package/src/checks/typescript-vfs.d.ts

@@ -0,0 +1,26 @@
+import type ts from "typescript-api";
+
+export interface VirtualTypeScriptEnvironment {
+  sys: ts.System;
+  languageService: ts.LanguageService;
+  getSourceFile: (fileName: string) => ts.SourceFile | undefined;
+  createFile: (fileName: string, content: string) => void;
+  updateFile: (fileName: string, content: string, replaceTextSpan?: ts.TextSpan) => void;
+  deleteFile: (fileName: string) => void;
+}
+
+export declare function createVirtualTypeScriptEnvironment(
+  sys: ts.System,
+  rootFiles: string[],
+  tsModule: typeof ts,
+  compilerOptions?: ts.CompilerOptions,
+  customTransformers?: ts.CustomTransformers,
+): VirtualTypeScriptEnvironment;
+
+export declare const createDefaultMapFromNodeModules: (
+  compilerOptions: ts.CompilerOptions,
+  tsModule: typeof ts,
+  tsLibDirectory: string,
+) => Map<string, string>;
+
+export declare function createSystem(files: Map<string, string>): ts.System;

package/src/checks/typescript-vfs.js

@@ -0,0 +1,5 @@
+export {
+  createDefaultMapFromNodeModules,
+  createSystem,
+  createVirtualTypeScriptEnvironment,
+} from "@typescript/vfs";

package/src/cli/analytics.ts

@@ -103,6 +103,7 @@ const COMMAND_GROUPS: Readonly<Record<string, Readonly<Record<string, true>>>> =
 
 const ROOT_COMMANDS: Readonly<Record<string, true>> = {
   apply: true,
+  check: true,
   "auth-status": true,
   help: true,
   import: true,