auklet 0.0.1 → 0.0.2

package/dist/css/vite/hmr.js

@@ -0,0 +1,153 @@
+import path from 'node:path';
+import { normalizeCssFileKey } from '#auklet/css/core/path';
+// package CSS 的 HMR 不能直接走 Vite 原生 CSS 文件链路：
+// - 浏览器 import 的是 auklet-css:* 虚拟 CSS 模块，不是真实的
+//   packages/*/src/**/*.css 文件，所以真实 CSS 变化时 Vite 的 modules 可能为空。
+// - Vite dev 会把 CSS 转成自接受的 JS 模块，重新执行模块里的 updateStyle()
+//   才能更新样式，因此这里手动发送 js-update，而不是 css-update。
+// - @tailwindcss/vite 会在相关 CSS 变化时主动发 full-reload。package CSS 已由
+//   这个插件接管 HMR 时，需要在一个很短的窗口内吞掉这次 reload。
+const HMR_LOG_PREFIX = '[auklet:css:vite]';
+const FULL_RELOAD_SUPPRESS_MS = 100;
+const DUPLICATE_UPDATE_IGNORE_MS = 500;
+const toBrowserVirtualPath = (id) => {
+  return `/@id/${id.replace('\0', '__x00__')}`;
+};
+const getRelativeFile = (file) => {
+  return path.relative(process.cwd(), file);
+};
+const invalidateVirtualModules = (server, graph) => {
+  const modules = [];
+  for (const packageName of graph.getWorkspacePackageNames()) {
+    for (const entry of ['style.css', 'external.css', 'module.css']) {
+      const module = server.moduleGraph.getModuleById(
+        `\0auklet-css:${packageName}/${entry}`,
+      );
+      if (!module) continue;
+      server.moduleGraph.invalidateModule(module);
+      modules.push(module);
+    }
+  }
+  return modules;
+};
+const addVirtualCssDependency = (virtualIdsByDependency, file, virtualId) => {
+  var _a;
+  const normalizedFile = normalizeCssFileKey(file);
+  const values =
+    (_a = virtualIdsByDependency.get(normalizedFile)) !== null && _a !== void 0
+      ? _a
+      : new Set();
+  values.add(virtualId);
+  virtualIdsByDependency.set(normalizedFile, values);
+};
+const getDependencyVirtualIds = (virtualIdsByDependency, file) => {
+  var _a;
+  return Array.from(
+    (_a = virtualIdsByDependency.get(normalizeCssFileKey(file))) !== null &&
+      _a !== void 0
+      ? _a
+      : [],
+  );
+};
+const getDependencyVirtualModules = (virtualIdsByDependency, server, file) => {
+  return getDependencyVirtualIds(virtualIdsByDependency, file).flatMap((id) => {
+    const module = server.moduleGraph.getModuleById(id);
+    return module ? [module] : [];
+  });
+};
+export class AukletCssHmr {
+  constructor(graph) {
+    this.graph = graph;
+    this.lastUpdateTimes = new Map();
+    this.suppressFullReloadUntil = 0;
+    this.virtualIdsByDependency = new Map();
+  }
+  trackVirtualCssDependency(file, virtualId) {
+    addVirtualCssDependency(this.virtualIdsByDependency, file, virtualId);
+  }
+  installFullReloadGuard(server) {
+    const send = server.ws.send.bind(server.ws);
+    server.ws.send = (payload, data) => {
+      if (
+        typeof payload !== 'string' &&
+        payload.type === 'full-reload' &&
+        this.shouldSuppressFullReload()
+      ) {
+        console.info(`${HMR_LOG_PREFIX} suppressed package css full-reload`);
+        return;
+      }
+      if (typeof payload === 'string') {
+        send(payload, data);
+        return;
+      }
+      send(payload);
+    };
+  }
+  handleStyleHotUpdate(context) {
+    const graph = this.graph();
+    if (
+      !graph.isWorkspaceSourceGraphFile(context.file) ||
+      !graph.isStyleFile(context.file)
+    ) {
+      return;
+    }
+    if (this.isDuplicateUpdate(context.file)) {
+      return [];
+    }
+    this.suppressFullReload();
+    const virtualIds = getDependencyVirtualIds(
+      this.virtualIdsByDependency,
+      context.file,
+    );
+    const modules = getDependencyVirtualModules(
+      this.virtualIdsByDependency,
+      context.server,
+      context.file,
+    );
+    for (const module of modules) {
+      context.server.moduleGraph.invalidateModule(module);
+    }
+    invalidateVirtualModules(context.server, graph);
+    const updates = virtualIds.map((id) => {
+      const browserPath = toBrowserVirtualPath(id);
+      return {
+        type: 'js-update',
+        path: browserPath,
+        acceptedPath: browserPath,
+        timestamp: context.timestamp,
+        explicitImportRequired: false,
+        isWithinCircularImport: false,
+      };
+    });
+    console.info(
+      `${HMR_LOG_PREFIX} package css hmr ${getRelativeFile(
+        context.file,
+      )} tracked=${virtualIds.length} updates=${updates.length}`,
+    );
+    if (updates.length) {
+      context.server.ws.send({
+        type: 'update',
+        updates,
+      });
+    }
+    return [];
+  }
+  suppressFullReload() {
+    this.suppressFullReloadUntil = Date.now() + FULL_RELOAD_SUPPRESS_MS;
+  }
+  shouldSuppressFullReload() {
+    return Date.now() <= this.suppressFullReloadUntil;
+  }
+  isDuplicateUpdate(file) {
+    var _a;
+    const now = Date.now();
+    const normalizedFile = normalizeCssFileKey(file);
+    const lastUpdateTime =
+      (_a = this.lastUpdateTimes.get(normalizedFile)) !== null && _a !== void 0
+        ? _a
+        : 0;
+    const isDuplicate = now - lastUpdateTime < DUPLICATE_UPDATE_IGNORE_MS;
+    this.lastUpdateTimes.set(normalizedFile, now);
+    return isDuplicate;
+  }
+}

package/dist/css/vite/vitePlugin.d.ts

@@ -0,0 +1,24 @@
+import type { HotUpdateOptions, ViteDevServer } from 'vite';
+import { type ModuleCssGraphOptions } from '#auklet/css/core/moduleCssGraph';
+export type AukletCssPluginOptions = Partial<
+  Pick<ModuleCssGraphOptions, 'workspaceRoot'>
+> &
+  Omit<ModuleCssGraphOptions, 'workspaceRoot'>;
+export declare function aukletCssPlugin(options?: AukletCssPluginOptions): {
+  name: string;
+  apply: 'serve';
+  enforce: 'pre';
+  configResolved(config: { root: string }): void;
+  resolveId(id: string): string | null;
+  load(
+    this: {
+      addWatchFile?: (file: string) => void;
+    },
+    id: string,
+  ): Promise<string | null>;
+  configureServer(server: ViteDevServer): void;
+  hotUpdate: {
+    order: 'pre';
+    handler(context: HotUpdateOptions): never[] | undefined;
+  };
+};

package/dist/css/vite/vitePlugin.js

@@ -0,0 +1,140 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ModuleCssGraph } from '#auklet/css/core/moduleCssGraph';
+import { AukletCssHmr } from '#auklet/css/vite/hmr';
+const WORKSPACE_FILE = 'pnpm-workspace.yaml';
+const VIRTUAL_ID_PREFIX = 'virtual:auklet-css:';
+const RESOLVED_VIRTUAL_ID_PREFIX = '\0auklet-css:';
+const BROWSER_VIRTUAL_ID_PREFIX = 'auklet-css:';
+const stripQuery = (id) => id.split('?')[0];
+const toResolvedVirtualId = (id) => {
+  if (id.startsWith(RESOLVED_VIRTUAL_ID_PREFIX)) {
+    return id;
+  }
+  if (id.startsWith(BROWSER_VIRTUAL_ID_PREFIX)) {
+    return `${RESOLVED_VIRTUAL_ID_PREFIX}${id.slice(
+      BROWSER_VIRTUAL_ID_PREFIX.length,
+    )}`;
+  }
+  return null;
+};
+const findWorkspaceRoot = (startDir) => {
+  let current = path.resolve(startDir);
+  while (true) {
+    if (fs.existsSync(path.join(current, WORKSPACE_FILE))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+};
+const createModuleCssGraph = (options, viteRoot) => {
+  var _a, _b;
+  const workspaceRoot =
+    (_b =
+      (_a = options.workspaceRoot) !== null && _a !== void 0
+        ? _a
+        : findWorkspaceRoot(viteRoot)) !== null && _b !== void 0
+      ? _b
+      : process.cwd();
+  return new ModuleCssGraph({
+    ...options,
+    workspaceRoot,
+  });
+};
+const invalidateVirtualModules = (server, graph) => {
+  const modules = [];
+  for (const packageName of graph.getWorkspacePackageNames()) {
+    for (const entry of ['style.css', 'external.css', 'module.css']) {
+      const module = server.moduleGraph.getModuleById(
+        `${RESOLVED_VIRTUAL_ID_PREFIX}${packageName}/${entry}`,
+      );
+      if (!module) continue;
+      server.moduleGraph.invalidateModule(module);
+      modules.push(module);
+    }
+  }
+  return modules;
+};
+export function aukletCssPlugin(options = {}) {
+  let graph = null;
+  const getGraph = () => {
+    if (!graph) {
+      graph = createModuleCssGraph(options, process.cwd());
+    }
+    return graph;
+  };
+  const hmr = new AukletCssHmr(getGraph);
+  return {
+    name: 'auklet-css',
+    apply: 'serve',
+    enforce: 'pre',
+    configResolved(config) {
+      graph = createModuleCssGraph(options, config.root);
+    },
+    resolveId(id) {
+      const graph = getGraph();
+      const cleanId = stripQuery(id);
+      const resolvedVirtualId = toResolvedVirtualId(cleanId);
+      if (resolvedVirtualId) return resolvedVirtualId;
+      if (cleanId.startsWith(VIRTUAL_ID_PREFIX)) {
+        return `${RESOLVED_VIRTUAL_ID_PREFIX}${cleanId.slice(
+          VIRTUAL_ID_PREFIX.length,
+        )}`;
+      }
+      if (!graph.parsePackageCssId(cleanId)) return null;
+      return `${RESOLVED_VIRTUAL_ID_PREFIX}${cleanId}`;
+    },
+    async load(id) {
+      var _a;
+      if (!id.startsWith(RESOLVED_VIRTUAL_ID_PREFIX)) return null;
+      const originalId = id.slice(RESOLVED_VIRTUAL_ID_PREFIX.length);
+      const graph = getGraph();
+      const parsed = graph.parsePackageCssId(originalId);
+      if (!parsed) return null;
+      const result = await graph.createPackageCssCode(parsed);
+      for (const file of result.watchFiles) {
+        hmr.trackVirtualCssDependency(file, id);
+        (_a = this.addWatchFile) === null || _a === void 0
+          ? void 0
+          : _a.call(this, file);
+      }
+      return result.code;
+    },
+    configureServer(server) {
+      const graph = getGraph();
+      hmr.installFullReloadGuard(server);
+      server.watcher.add(graph.getWatchRoots());
+      const invalidateCssGraph = (file) => {
+        if (!graph.isWorkspaceSourceGraphFile(file)) return false;
+        invalidateVirtualModules(server, graph);
+        return true;
+      };
+      const reloadCssGraph = (file) => {
+        if (!invalidateCssGraph(file)) return;
+        server.ws.send({ type: 'full-reload' });
+      };
+      const handleSourceAddOrUnlink = (file) => {
+        if (graph.isStyleFile(file)) {
+          invalidateCssGraph(file);
+          return;
+        }
+        reloadCssGraph(file);
+      };
+      server.watcher.on('add', handleSourceAddOrUnlink);
+      server.watcher.on('unlink', handleSourceAddOrUnlink);
+      server.watcher.on('change', (file) => {
+        if (graph.isCssConfigFile(file)) {
+          reloadCssGraph(file);
+        }
+      });
+    },
+    hotUpdate: {
+      order: 'pre',
+      handler(context) {
+        return hmr.handleStyleHotUpdate(context);
+      },
+    },
+  };
+}

package/dist/css/watch/moduleCssWatcher.d.ts

@@ -0,0 +1,19 @@
+import type {
+  ModuleCssBuildConfig,
+  ModuleCssBuildContext,
+} from '#auklet/types';
+export declare class ModuleCssWatcher {
+  private readonly config;
+  private readonly context;
+  private readonly logger?;
+  private timer;
+  private isBuilding;
+  private shouldRebuild;
+  private watcher;
+  constructor(context?: ModuleCssBuildContext, config?: ModuleCssBuildConfig);
+  watch(): Promise<void>;
+  private rebuild;
+  private refreshWatcher;
+  private scheduleBuild;
+  close(): Promise<void>;
+}

package/dist/css/watch/moduleCssWatcher.js

@@ -0,0 +1,106 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import chokidar from 'chokidar';
+import { aukletConfigFile } from '#auklet/config';
+import { moduleCssBuildConfig } from '#auklet/css/core/config';
+import { ModuleCssBuilder } from '#auklet/css/production/moduleCssBuilder';
+export class ModuleCssWatcher {
+  constructor(context = {}, config = moduleCssBuildConfig) {
+    this.config = config;
+    this.timer = null;
+    this.isBuilding = false;
+    this.shouldRebuild = false;
+    this.watcher = null;
+    this.context = {
+      packageRoot: process.cwd(),
+      ...context,
+    };
+    this.logger = context.logger;
+  }
+  async watch() {
+    var _a, _b;
+    await this.rebuild();
+    (_b = (_a = this.logger) === null || _a === void 0 ? void 0 : _a.log) ===
+      null || _b === void 0
+      ? void 0
+      : _b.call(_a, '[auklet:css] watch mode ready');
+  }
+  async rebuild() {
+    var _a, _b;
+    if (this.isBuilding) {
+      this.shouldRebuild = true;
+      return;
+    }
+    this.isBuilding = true;
+    try {
+      const builder = new ModuleCssBuilder(this.context, this.config);
+      await builder.build();
+      await this.refreshWatcher();
+    } catch (error) {
+      (_b =
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error) ===
+        null || _b === void 0
+        ? void 0
+        : _b.call(_a, error);
+    } finally {
+      this.isBuilding = false;
+      if (this.shouldRebuild) {
+        this.shouldRebuild = false;
+        this.scheduleBuild();
+      }
+    }
+  }
+  async refreshWatcher() {
+    var _a, _b, _c, _d;
+    const cssOptions =
+      (_a = this.context.aukletConfig) !== null && _a !== void 0 ? _a : {};
+    const sourceDir =
+      (_c =
+        (_b = cssOptions.sourceDir) !== null && _b !== void 0
+          ? _b
+          : this.context.sourceDir) !== null && _c !== void 0
+        ? _c
+        : 'src';
+    const sourceRoot = path.join(this.context.packageRoot, sourceDir);
+    const configPath = path.join(this.context.packageRoot, aukletConfigFile);
+    const watchPaths = [sourceRoot, configPath].filter((file) =>
+      fs.existsSync(file),
+    );
+    await ((_d = this.watcher) === null || _d === void 0 ? void 0 : _d.close());
+    this.watcher = chokidar.watch(watchPaths, {
+      ignoreInitial: true,
+      interval: 300,
+      usePolling: true,
+    });
+    this.watcher.on('all', () => {
+      this.scheduleBuild();
+    });
+    this.watcher.on('error', (error) => {
+      var _a, _b;
+      (_b =
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error) ===
+        null || _b === void 0
+        ? void 0
+        : _b.call(_a, error);
+    });
+  }
+  scheduleBuild() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.rebuild().catch((error) => {
+        var _a, _b;
+        (_b =
+          (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error) ===
+          null || _b === void 0
+          ? void 0
+          : _b.call(_a, error);
+      });
+    }, 80);
+  }
+  async close() {
+    var _a;
+    if (this.timer) clearTimeout(this.timer);
+    await ((_a = this.watcher) === null || _a === void 0 ? void 0 : _a.close());
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+export type {
+  CssOptions,
+  CssDependencyGroup,
+  AukletConfig,
+  LoadAukletConfigOptions,
+  ModuleCssBuildConfig,
+  ModuleCssBuildContext,
+  ModuleCssBuildOptions,
+  PackageBuildFormat,
+  PackageBuildOptions,
+  ResolvedModuleCssBuildContext,
+  StyleLanguage,
+} from '#auklet/types';
+export type { RunTsdownOptions } from '#auklet/build/runTsdown';
+export type { AukletCssPluginOptions } from '#auklet/css/vite/vitePlugin';
+export { aukletDefaultCssDependencyConfig } from '#auklet/config';
+export {
+  loadAukletConfig,
+  resolveAukletConfigModule,
+} from '#auklet/configLoader';
+export { aukletCssPlugin } from '#auklet/css/vite/vitePlugin';
+export { createTsdownArgs, runTsdown } from '#auklet/build/runTsdown';
+export { ModuleCssWatcher } from '#auklet/css/watch/moduleCssWatcher';
+export { ModuleCssBuilder } from '#auklet/css/production/moduleCssBuilder';

package/dist/index.js

@@ -0,0 +1,9 @@
+export { aukletDefaultCssDependencyConfig } from '#auklet/config';
+export {
+  loadAukletConfig,
+  resolveAukletConfigModule,
+} from '#auklet/configLoader';
+export { aukletCssPlugin } from '#auklet/css/vite/vitePlugin';
+export { createTsdownArgs, runTsdown } from '#auklet/build/runTsdown';
+export { ModuleCssWatcher } from '#auklet/css/watch/moduleCssWatcher';
+export { ModuleCssBuilder } from '#auklet/css/production/moduleCssBuilder';

package/dist/types.d.ts

@@ -0,0 +1,60 @@
+export type CssDependencyGroup = {
+  global?: string | Array<string>;
+  themes?: Record<string, string>;
+  component?: string | Array<string>;
+};
+export interface CssOptions {
+  cssDependencies?: Record<string, CssDependencyGroup>;
+  themes?: Record<string, string>;
+  sourceDir?: string;
+  outputDir?: string;
+}
+export type PackageBuildFormat = 'cjs' | 'esm' | 'iife';
+export type PackageBuildOptions = {
+  formats?: Array<PackageBuildFormat>;
+  banner?: string;
+  externals?: Array<string>;
+  modules?: boolean;
+  tsconfig?: string;
+};
+export interface AukletConfig extends CssOptions {
+  build?: PackageBuildOptions;
+}
+export type AukletLogger = {
+  log?: (...args: Array<unknown>) => void;
+  info?: (...args: Array<unknown>) => void;
+  error?: (...args: Array<unknown>) => void;
+};
+export type LoadAukletConfigOptions = {
+  configFile?: string;
+  cacheBust?: boolean;
+};
+export type StyleLanguage = 'css' | 'less';
+export interface ModuleCssBuildContext {
+  packageRoot?: string;
+  aukletConfig?: AukletConfig;
+  logger?: AukletLogger;
+  sourceDir?: string;
+  outputDir?: string;
+}
+export interface ResolvedModuleCssBuildContext {
+  packageRoot: string;
+  sourceDir: string;
+  outputDir: string;
+}
+export type ModuleCssBuildOptions = {
+  aukletConfig?: AukletConfig;
+  logger?: AukletLogger;
+};
+export interface ModuleCssBuildOutputConfig {
+  outputFormats: Array<string>;
+  styleDir: string;
+  indexCssFile: string;
+  externalCssFile: string;
+  moduleCssFile: string;
+}
+export interface ModuleCssBuildConfig {
+  output: ModuleCssBuildOutputConfig;
+  styleExtensions: Record<string, StyleLanguage>;
+  lessLanguage: StyleLanguage;
+}

package/dist/utils.d.ts

@@ -0,0 +1,20 @@
+export declare const POSIX_SEPARATOR = '/';
+export declare const IMPORT_LIST_SEPARATOR = ',';
+export declare const TEST_DIR_NAMES: Set<string>;
+export declare const SOURCE_TEST_RE: RegExp;
+export declare const SOURCE_MODULE_RE: RegExp;
+export declare const SOURCE_DECLARATION_RE: RegExp;
+export declare const TYPE_IMPORT_PREFIX: RegExp;
+export declare const IMPORT_ALIAS_SEPARATOR: RegExp;
+export declare function isTestDir(name: string): boolean;
+export declare function isTestFile(name: string): boolean;
+export declare function fileWalker(dir: string): Array<string>;
+export declare function toPosixPath(value: string): string;
+export declare function removeExtension(file: string): string;
+export declare function getSourceModuleDir(file: string): string;
+export declare function escapeRegExp(value: string): string;
+export declare function appendUniqueMapValue<K, V>(
+  map: Map<K, Array<V>>,
+  key: K,
+  value: V,
+): void;

package/dist/utils.js

@@ -0,0 +1,59 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { slash } from 'aidly';
+export const POSIX_SEPARATOR = '/';
+export const IMPORT_LIST_SEPARATOR = ',';
+export const TEST_DIR_NAMES = new Set([
+  '__test__',
+  '__tests__',
+  'test',
+  'tests',
+]);
+export const SOURCE_TEST_RE = /\.(spec|test)\.[cm]?(ts|tsx|js|jsx)$/;
+export const SOURCE_MODULE_RE = /\.(ts|tsx)$/;
+export const SOURCE_DECLARATION_RE = /\.d\.[cm]?ts$/;
+export const TYPE_IMPORT_PREFIX = /^type\s+/;
+export const IMPORT_ALIAS_SEPARATOR = /\s+as\s+/;
+export function isTestDir(name) {
+  return TEST_DIR_NAMES.has(name);
+}
+export function isTestFile(name) {
+  return SOURCE_TEST_RE.test(name);
+}
+export function fileWalker(dir) {
+  const files = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory() && isTestDir(entry.name)) continue;
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...fileWalker(fullPath));
+      continue;
+    }
+    if (isTestFile(entry.name)) continue;
+    files.push(fullPath);
+  }
+  return files;
+}
+export function toPosixPath(value) {
+  return slash(value);
+}
+export function removeExtension(file) {
+  return file.slice(0, -path.extname(file).length);
+}
+export function getSourceModuleDir(file) {
+  const filename = path.basename(file);
+  if (filename.startsWith('index.')) {
+    return path.dirname(file);
+  }
+  return removeExtension(file);
+}
+export function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+export function appendUniqueMapValue(map, key, value) {
+  var _a;
+  const values = (_a = map.get(key)) !== null && _a !== void 0 ? _a : [];
+  if (!values.includes(value)) values.push(value);
+  map.set(key, values);
+}