@litsx/compiler 0.1.0

package/src/index.d.ts

@@ -0,0 +1,64 @@
+export type TransformLitsxOptions = {
+  filename?: string;
+  parserPlugins?: string[];
+  sourceMaps?: boolean;
+  jsxTemplate?: boolean;
+  jsxTemplateOptions?: object;
+  authoringPlugins?: unknown[];
+  outputPlugins?: unknown[];
+  requireJsx?: boolean;
+};
+
+export type LitsxCompilationSession = {
+  transform(source: string, options?: TransformLitsxOptions): Promise<TransformLitsxResult>;
+  transformSync(source: string, options?: TransformLitsxOptions): TransformLitsxResult;
+  getTypecheckSession(rawArgs?: string[]): unknown;
+  invalidate(files?: string[] | null): void;
+  dispose(): void;
+};
+
+export type TransformLitsxResult = {
+  code: string;
+  map: object | null;
+  metadata: Record<string, unknown>;
+};
+
+export type PreparedLitsxAuthoredInput = {
+  filename?: string;
+  virtualization: {
+    code?: string;
+    map?: object | null;
+  } | null;
+  inputAst: object;
+  authoredWarnings: unknown[];
+};
+
+export function ensureLitsxParserPlugins(
+  filename?: string,
+  parserPlugins?: string[],
+  options?: { requireJsx?: boolean }
+): string[];
+
+export function prepareLitsxAuthoredInput(
+  source: string,
+  options?: TransformLitsxOptions,
+  runtime?: {
+    parse: (...args: unknown[]) => object;
+    transformFromAstSync: (...args: unknown[]) => { ast?: object } | null | undefined;
+  }
+): PreparedLitsxAuthoredInput;
+
+export function transformLitsx(
+  source: string,
+  options?: TransformLitsxOptions
+): Promise<TransformLitsxResult>;
+
+export function transformLitsxSync(
+  source: string,
+  options?: TransformLitsxOptions
+): TransformLitsxResult;
+
+export function createLitsxCompilationSession(options?: {
+  projectPath?: string;
+  transformOptions?: TransformLitsxOptions;
+}): LitsxCompilationSession;

package/src/index.js

@@ -0,0 +1,438 @@
+import babelCore from "@babel/core";
+import {
+  createLitsxPresetPlugins,
+  detectLitsxSourceFeatures,
+} from "@litsx/babel-preset-litsx";
+import { ensureTypescriptModule } from "@litsx/babel-preset-litsx/internal/transform-litsx-properties";
+import { createLitsxTypecheckSession } from "@litsx/typescript-plugin/typecheck";
+import {
+  createStandaloneTsSession,
+  normalizeFilePath,
+} from "@litsx/typescript-session";
+import {
+  patchLitAttributeSourcemap,
+} from "@litsx/babel-plugin-transform-jsx-html-template";
+import {
+  ensureLitsxParserPlugins,
+  prepareLitsxAuthoredInput,
+} from "./authored-input.js";
+import { mergeLitsxWarnings } from "./warnings.js";
+export {
+  ensureLitsxParserPlugins,
+  prepareLitsxAuthoredInput,
+} from "./authored-input.js";
+
+const { transformFromAstAsync, transformFromAstSync } = babelCore;
+const PROFILE_ENABLED = process.env.LITSX_PROFILE === "1";
+const PRESET_PLUGIN_CACHE = new WeakMap();
+const DEFAULT_PRESET_PLUGIN_CACHE = new Map();
+
+function createStandaloneTsCompilerOptions(ts) {
+  return {
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    jsx: ts.JsxEmit.Preserve,
+    allowJs: true,
+    checkJs: false,
+    skipLibCheck: true,
+    strict: false,
+    esModuleInterop: true,
+    allowSyntheticDefaultImports: true,
+    types: [],
+  };
+}
+
+function getSourceFeaturesCacheKey(sourceFeatures) {
+  if (!sourceFeatures) {
+    return "all";
+  }
+
+  return [
+    sourceFeatures.hooks ? "1" : "0",
+    sourceFeatures.domRefs ? "1" : "0",
+    sourceFeatures.scopedElements ? "1" : "0",
+  ].join("");
+}
+
+function profilePhase(name, callback, profile = null) {
+  if (!PROFILE_ENABLED) {
+    return callback();
+  }
+
+  const start = performance.now();
+  try {
+    return callback();
+  } finally {
+    const durationMs = performance.now() - start;
+    if (profile) {
+      profile.push({ name, durationMs });
+    }
+    if (PROFILE_ENABLED) {
+      globalThis.__litsxProfileEvents ??= [];
+      globalThis.__litsxProfileEvents.push({
+        namespace: "compiler",
+        name,
+        durationMs,
+      });
+    }
+  }
+}
+
+function normalizePluginList(plugins) {
+  return Array.isArray(plugins) ? plugins : [];
+}
+
+function getStandaloneTsSessionKey(filename = "", ts = ensureTypescriptModule()) {
+  const normalizedFilename = normalizeFilePath(filename);
+  const directory = normalizedFilename ? normalizedFilename.slice(0, normalizedFilename.lastIndexOf("/")) || "/" : "/";
+  return JSON.stringify({
+    directory,
+    compilerOptions: createStandaloneTsCompilerOptions(ts),
+  });
+}
+
+function getMemoizedPresetPlugins(options, sourceFeatures = null, session = null) {
+  const featureKey = getSourceFeaturesCacheKey(sourceFeatures);
+  if (session) {
+    const cache = session.presetPluginsByOptions;
+    const optionsKey = options && typeof options === "object" ? options : null;
+
+    if (!optionsKey) {
+      if (!cache.default.has(featureKey)) {
+        cache.default.set(featureKey, createLitsxPresetPlugins({}, sourceFeatures));
+      }
+      return cache.default.get(featureKey);
+    }
+
+    let cachedPluginsByFeature = cache.byOptions.get(optionsKey);
+    if (!cachedPluginsByFeature) {
+      cachedPluginsByFeature = new Map();
+      cache.byOptions.set(optionsKey, cachedPluginsByFeature);
+    }
+
+    const cachedPlugins = cachedPluginsByFeature.get(featureKey);
+    if (cachedPlugins) {
+      return cachedPlugins;
+    }
+
+    const plugins = createLitsxPresetPlugins(options, sourceFeatures);
+    cachedPluginsByFeature.set(featureKey, plugins);
+    return plugins;
+  }
+
+  if (!options || typeof options !== "object") {
+    if (!DEFAULT_PRESET_PLUGIN_CACHE.has(featureKey)) {
+      DEFAULT_PRESET_PLUGIN_CACHE.set(
+        featureKey,
+        createLitsxPresetPlugins({}, sourceFeatures),
+      );
+    }
+    return DEFAULT_PRESET_PLUGIN_CACHE.get(featureKey);
+  }
+
+  let cachedPluginsByFeature = PRESET_PLUGIN_CACHE.get(options);
+  if (!cachedPluginsByFeature) {
+    cachedPluginsByFeature = new Map();
+    PRESET_PLUGIN_CACHE.set(options, cachedPluginsByFeature);
+  }
+
+  const cachedPlugins = cachedPluginsByFeature.get(featureKey);
+  if (cachedPlugins) {
+    return cachedPlugins;
+  }
+
+  const plugins = createLitsxPresetPlugins(options, sourceFeatures);
+  cachedPluginsByFeature.set(featureKey, plugins);
+  return plugins;
+}
+
+function getSessionFeatureCacheKey(source, options = {}) {
+  return `${options.filename || ""}:${source}`;
+}
+
+function createCompilerCaches() {
+  return {
+    sourceFeatures: new Map(),
+    authoredInput: new Map(),
+    presetPluginsByOptions: {
+      default: new Map(),
+      byOptions: new WeakMap(),
+    },
+  };
+}
+
+function createStandaloneCompilerTsSession(options = {}) {
+  const typescriptModule = options.typescriptModule || ensureTypescriptModule();
+  return createStandaloneTsSession({
+    sessionKey: getStandaloneTsSessionKey(options.filename, typescriptModule),
+    typescript: typescriptModule,
+    compilerOptions: createStandaloneTsCompilerOptions(typescriptModule),
+  });
+}
+
+export function createLitsxCompilationSession(sessionOptions = {}) {
+  const caches = createCompilerCaches();
+  const session = {
+    projectPath: sessionOptions.projectPath || null,
+    transformOptions: sessionOptions.transformOptions || {},
+    typescriptSession:
+      sessionOptions.projectPath
+        ? createLitsxTypecheckSession(["--project", sessionOptions.projectPath]).projectSession
+        : createStandaloneCompilerTsSession({
+            filename: sessionOptions.transformOptions?.filename,
+            typescriptModule: sessionOptions.typescriptModule,
+          }),
+    presetPluginsByOptions: caches.presetPluginsByOptions,
+    sourceFeaturesCache: caches.sourceFeatures,
+    authoredInputCache: caches.authoredInput,
+    transform(source, options = {}) {
+      return transformLitsx(source, {
+        ...this.transformOptions,
+        ...options,
+        typescriptSession: this.typescriptSession,
+        __litsxCompilationSession: this,
+      });
+    },
+    transformSync(source, options = {}) {
+      return transformLitsxSync(source, {
+        ...this.transformOptions,
+        ...options,
+        typescriptSession: this.typescriptSession,
+        __litsxCompilationSession: this,
+      });
+    },
+    getTypecheckSession(rawArgs = this.projectPath ? ["--project", this.projectPath] : []) {
+      return createLitsxTypecheckSession(rawArgs, {
+        projectSession: this.typescriptSession,
+      });
+    },
+    invalidate(files = null) {
+      if (!files || files.length === 0) {
+        this.sourceFeaturesCache.clear();
+        this.authoredInputCache.clear();
+        this.typescriptSession?.invalidate?.({ host: true });
+        return;
+      }
+
+      for (const file of files) {
+        const normalizedFile = normalizeFilePath(file);
+        for (const key of [...this.sourceFeaturesCache.keys()]) {
+          if (key.startsWith(`${normalizedFile}:`)) {
+            this.sourceFeaturesCache.delete(key);
+          }
+        }
+        for (const key of [...this.authoredInputCache.keys()]) {
+          if (key.startsWith(`${normalizedFile}:`)) {
+            this.authoredInputCache.delete(key);
+          }
+        }
+        if (/\.(jsx|tsx|js|ts|litsx)$/.test(file) || file.endsWith(".litsx.jsx")) {
+          this.typescriptSession?.invalidate?.();
+        }
+      }
+    },
+    dispose() {
+      this.invalidate();
+      this.typescriptSession?.clearOverlayFiles?.();
+      this.typescriptSession = null;
+    },
+  };
+  return session;
+}
+
+export function createLitsxTransformConfig(source, options = {}) {
+  const profile = PROFILE_ENABLED ? [] : null;
+  const compilationSession = options.__litsxCompilationSession || null;
+  const memoizationOptions = options.__litsxMemoizeOptions || options;
+  const featureCacheKey = getSessionFeatureCacheKey(source, options);
+  const sourceFeatures = profilePhase(
+    "feature-detection",
+    () => {
+      if (compilationSession?.sourceFeaturesCache?.has(featureCacheKey)) {
+        return compilationSession.sourceFeaturesCache.get(featureCacheKey);
+      }
+      const detected = detectLitsxSourceFeatures(source, options);
+      compilationSession?.sourceFeaturesCache?.set(featureCacheKey, detected);
+      return detected;
+    },
+    profile,
+  );
+  const authoredInputCacheKey = featureCacheKey;
+  const { filename, virtualization, inputAst, authoredWarnings } = profilePhase(
+    "authored-input",
+    () => {
+      if (compilationSession?.authoredInputCache?.has(authoredInputCacheKey)) {
+        return compilationSession.authoredInputCache.get(authoredInputCacheKey);
+      }
+      const prepared = prepareLitsxAuthoredInput(
+        source,
+        options,
+        {
+          transformFromAstSync,
+        }
+      );
+      compilationSession?.authoredInputCache?.set(authoredInputCacheKey, prepared);
+      return prepared;
+    },
+    profile,
+  );
+  const outputPlugins = normalizePluginList(options.outputPlugins);
+  const presetPlugins = profilePhase(
+    "preset-plugins",
+    () => getMemoizedPresetPlugins(memoizationOptions, sourceFeatures, compilationSession),
+    profile,
+  );
+
+  return {
+    filename,
+    inputAst,
+    authoredWarnings,
+    profile,
+    babelOptions: {
+      filename,
+      sourceFileName: filename,
+      configFile: false,
+      babelrc: false,
+      inputSourceMap:
+        options.sourceMaps === true ? virtualization?.map ?? undefined : undefined,
+      sourceMaps: options.sourceMaps === true,
+      plugins: [
+        ...presetPlugins,
+        ...outputPlugins,
+      ],
+    },
+  };
+}
+
+function finalizeTransformResult(result, options, authoredWarnings = [], profile = []) {
+  if (!result) {
+    return {
+      code: "",
+      map: null,
+      metadata: profile?.length > 0 ? { litsxProfile: profile } : {},
+    };
+  }
+
+  const metadata = {
+    ...(result.metadata || {}),
+  };
+  const mergedWarnings = mergeLitsxWarnings(
+    metadata.litsxWarnings || [],
+    authoredWarnings,
+    { filename: options.filename }
+  );
+  if (mergedWarnings.length > 0) {
+    metadata.litsxWarnings = mergedWarnings;
+  }
+  if (profile?.length > 0) {
+    metadata.litsxProfile = profile;
+  }
+  const templateAttributeMappings = metadata.litsxTemplateAttributeMappings || [];
+  const map =
+    options.sourceMaps === true
+      ? options.jsxTemplate === false
+        ? result.map ?? null
+        : templateAttributeMappings.length === 0
+          ? result.map ?? null
+          : profilePhase(
+            "sourcemap-patching",
+            () => patchLitAttributeSourcemap(
+              result.code || "",
+              result.map ?? null,
+              templateAttributeMappings,
+            ),
+            profile,
+          )
+      : null;
+
+  return {
+    code: result.code || "",
+    map,
+    metadata,
+  };
+}
+
+export async function transformLitsx(source, options = {}) {
+  if (!options.__litsxCompilationSession) {
+    const standaloneTsSession = createStandaloneCompilerTsSession({
+      filename: options.filename,
+    });
+    const nextOptions = {
+      ...options,
+      typescriptSession: standaloneTsSession,
+      __litsxMemoizeOptions: options,
+    };
+    const {
+      inputAst,
+      babelOptions,
+      authoredWarnings,
+      profile,
+    } = createLitsxTransformConfig(source, nextOptions);
+    const result = await profilePhase(
+      "babel-transform",
+      () => transformFromAstAsync(inputAst, source, {
+        ...babelOptions,
+        plugins: babelOptions.plugins,
+      }),
+      profile,
+    );
+    return finalizeTransformResult(result, nextOptions, authoredWarnings, profile);
+  }
+
+  const {
+    inputAst,
+    babelOptions,
+    authoredWarnings,
+    profile,
+  } = createLitsxTransformConfig(source, options);
+  const result = await profilePhase(
+    "babel-transform",
+    () => transformFromAstAsync(inputAst, source, {
+      ...babelOptions,
+      plugins: babelOptions.plugins,
+    }),
+    profile,
+  );
+  return finalizeTransformResult(result, options, authoredWarnings, profile);
+}
+
+export function transformLitsxSync(source, options = {}) {
+  if (!options.__litsxCompilationSession) {
+    const standaloneTsSession = createStandaloneCompilerTsSession({
+      filename: options.filename,
+    });
+    const nextOptions = {
+      ...options,
+      typescriptSession: standaloneTsSession,
+      __litsxMemoizeOptions: options,
+    };
+    const {
+      inputAst,
+      babelOptions,
+      authoredWarnings,
+      profile,
+    } = createLitsxTransformConfig(source, nextOptions);
+    const result = profilePhase(
+      "babel-transform",
+      () => transformFromAstSync(inputAst, source, babelOptions),
+      profile,
+    );
+    return finalizeTransformResult(result, nextOptions, authoredWarnings, profile);
+  }
+
+  const {
+    inputAst,
+    babelOptions,
+    authoredWarnings,
+    profile,
+  } = createLitsxTransformConfig(source, options);
+  const result = profilePhase(
+    "babel-transform",
+    () => transformFromAstSync(inputAst, source, babelOptions),
+    profile,
+  );
+  return finalizeTransformResult(result, options, authoredWarnings, profile);
+}
+
+export default transformLitsx;

package/src/warnings.js

@@ -0,0 +1,66 @@
+function normalizeLocationNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+export function normalizeLitsxWarning(warning, context = {}) {
+  const normalized = warning && typeof warning === "object" ? { ...warning } : {};
+
+  normalized.code =
+    (typeof normalized.code === "string" && normalized.code !== "") ||
+    (typeof normalized.code === "number" && Number.isFinite(normalized.code))
+      ? normalized.code
+      : null;
+  normalized.message =
+    typeof normalized.message === "string" && normalized.message !== ""
+      ? normalized.message
+      : "LitSX emitted a warning during compilation.";
+  normalized.filename =
+    typeof normalized.filename === "string" && normalized.filename !== ""
+      ? normalized.filename
+      : typeof context.filename === "string" && context.filename !== ""
+        ? context.filename
+        : null;
+  normalized.line = normalizeLocationNumber(normalized.line);
+  normalized.column = normalizeLocationNumber(normalized.column);
+  normalized.attributeName =
+    typeof normalized.attributeName === "string" && normalized.attributeName !== ""
+      ? normalized.attributeName
+      : null;
+  normalized.tagName =
+    typeof normalized.tagName === "string" && normalized.tagName !== ""
+      ? normalized.tagName
+      : null;
+  normalized.propName =
+    typeof normalized.propName === "string" && normalized.propName !== ""
+      ? normalized.propName
+      : null;
+
+  return normalized;
+}
+
+export function mergeLitsxWarnings(existingWarnings = [], additionalWarnings = [], context = {}) {
+  const merged = [];
+  const seen = new Set();
+
+  for (const rawWarning of [...existingWarnings, ...additionalWarnings]) {
+    const warning = normalizeLitsxWarning(rawWarning, context);
+    const key = [
+      warning.code ?? "",
+      warning.attributeName ?? "",
+      warning.tagName ?? "",
+      warning.propName ?? "",
+      warning.line ?? "",
+      warning.column ?? "",
+      warning.message ?? "",
+    ].join(":");
+
+    if (seen.has(key)) {
+      continue;
+    }
+
+    seen.add(key);
+    merged.push(warning);
+  }
+
+  return merged;
+}