svelte-ag 1.3.0 → 1.3.1

package/src/lib/bin/build-tailwind-manifest/manifest-generator.ts

@@ -0,0 +1,119 @@
+import path from 'node:path';
+
+import { readPackageJson, writeIfDifferent } from 'ts-ag';
+import type { PackageJson } from 'type-fest';
+
+import {
+  getTailwindSourcesManifestPath,
+  serializeTailwindSourceManifest,
+  shouldIncludeManifestExport,
+  type TailwindSourceManifest,
+  type TailwindSourceManifestLeaf,
+  type TailwindSourcePackageJsonLike
+} from '../../vite/tailwind-sources-manifest.js';
+import { createGraphScanner } from './graph.js';
+import { resolvePackageEntryFile } from './path-utils.js';
+import type { GeneratorOptions, GraphScan, SymbolManifest } from './types.js';
+
+export async function generateTailwindManifestForPackage(
+  packageDir: string,
+  options: GeneratorOptions
+): Promise<{ didWrite: boolean; outputFile: string; exportCount: number }> {
+  const packageJson = (await readPackageJson(path.join(packageDir, 'package.json'))) as PackageJson &
+    TailwindSourcePackageJsonLike;
+  if (!packageJson) throw new Error(`No package.json found in ${packageDir}`);
+
+  const manifest: TailwindSourceManifest = { version: 1, exports: {} };
+  const exports = collectPackageExportEntries(packageJson.exports).filter(([exportKey]) =>
+    shouldIncludeManifestExport(exportKey, options.exportFilters)
+  );
+  const graphScanner = createGraphScanner(packageDir);
+
+  await Promise.all(
+    exports.map(async ([exportKey, exportTarget]) => {
+      if (exportKey.includes('*') || hasWildcardTarget(exportTarget)) {
+        console.warn(`[tailwind-manifest] Skipping wildcard export ${exportKey} in ${packageDir}`);
+      } else {
+        const entryFiles = collectRuntimeTargets(exportTarget)
+          .map((target) => resolvePackageEntryFile(packageDir, target))
+          .filter((targetPath): targetPath is string => targetPath !== null);
+
+        if (entryFiles.length === 0) return;
+
+        const manifestEntry = toManifestLeaf(await graphScanner.scanFileGraph(entryFiles));
+        const symbols = await collectExportSymbols(entryFiles, graphScanner);
+
+        manifest.exports[exportKey] = Object.keys(symbols).length > 0 ? { ...manifestEntry, symbols } : manifestEntry;
+      }
+    })
+  );
+
+  const outputFile = getTailwindSourcesManifestPath(packageDir, packageJson);
+  const didWrite = await writeIfDifferent(outputFile, serializeTailwindSourceManifest(manifest));
+  return { didWrite, outputFile, exportCount: Object.keys(manifest.exports).length };
+}
+
+async function collectExportSymbols(
+  entryFiles: string[],
+  graphScanner: ReturnType<typeof createGraphScanner>
+): Promise<SymbolManifest> {
+  const symbols = new Map<string, GraphScan>();
+
+  for (const entryFile of entryFiles) {
+    const targets = await graphScanner.readEntrySymbolTargets(entryFile);
+    await Promise.all(
+      targets.entries().map(async ([symbolName, targetFile]) => {
+        const scan = await graphScanner.scanFileGraph([targetFile]);
+        const existing = symbols.get(symbolName);
+
+        if (existing) {
+          for (const className of scan.classes) existing.classes.add(className);
+          for (const sourcePath of scan.sources) existing.sources.add(sourcePath);
+        } else {
+          symbols.set(symbolName, { classes: new Set(scan.classes), sources: new Set(scan.sources) });
+        }
+      })
+    );
+  }
+
+  return Object.fromEntries(
+    [...symbols.entries()]
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([symbolName, scan]) => [symbolName, toManifestLeaf(scan)])
+  );
+}
+
+function toManifestLeaf(scan: GraphScan): TailwindSourceManifestLeaf {
+  return { classes: [...scan.classes].sort(), sources: [...scan.sources].sort() };
+}
+
+function collectRuntimeTargets(target: PackageJson.Exports): string[] {
+  if (target === null) return [];
+  if (typeof target === 'string') {
+    return target.endsWith('.d.ts') ? [] : [target];
+  }
+
+  if (Array.isArray(target)) {
+    return target.flatMap(collectRuntimeTargets);
+  }
+
+  return Object.entries(target).flatMap(([key, value]) => (key === 'types' ? [] : collectRuntimeTargets(value)));
+}
+
+function hasWildcardTarget(target: PackageJson.Exports): boolean {
+  if (target === null) return false;
+  return typeof target === 'string'
+    ? target.includes('*')
+    : Array.isArray(target)
+      ? target.some(hasWildcardTarget)
+      : Object.values(target).some(hasWildcardTarget);
+}
+
+function collectPackageExportEntries(exports: PackageJson.Exports | undefined): [string, PackageJson.Exports][] {
+  if (exports === undefined) return [];
+  if (exports === null || typeof exports === 'string' || Array.isArray(exports)) return [['.', exports]];
+
+  const entries = Object.entries(exports);
+  const hasSubpathExports = entries.some(([key]) => key === '.' || key.startsWith('./'));
+  return hasSubpathExports ? entries : [['.', exports]];
+}

package/src/lib/bin/build-tailwind-manifest/path-utils.ts

@@ -0,0 +1,53 @@
+import { existsSync, statSync } from 'node:fs';
+import path from 'node:path';
+
+export function isRelativeSpecifier(specifier: string): boolean {
+  return specifier.startsWith('./') || specifier.startsWith('../') || specifier.startsWith('/');
+}
+
+export function resolveLocalImportPath(specifier: string, importerPath: string): string | null {
+  return resolveFileCandidate(path.resolve(path.dirname(importerPath), specifier.split(/[?#]/, 1)[0] ?? specifier));
+}
+
+export function resolvePackageEntryFile(packageDir: string, entryTarget: string): string | null {
+  return resolveFileCandidate(
+    path.resolve(packageDir, entryTarget.startsWith('./') ? entryTarget : `./${entryTarget}`)
+  );
+}
+
+export function isPathInside(parentPath: string, childPath: string): boolean {
+  const relativePath = path.relative(parentPath, childPath);
+  return relativePath === '' || (!relativePath.startsWith('..') && !path.isAbsolute(relativePath));
+}
+
+export function toPosixPath(filePath: string): string {
+  return filePath.replaceAll('\\', '/');
+}
+
+function resolveFileCandidate(targetPath: string): string | null {
+  for (const candidate of [
+    ...buildBaseCandidates(targetPath),
+    ...buildBaseCandidates(path.join(targetPath, 'index'))
+  ]) {
+    if (existsSync(candidate) && statSync(candidate).isFile()) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+function buildBaseCandidates(basePath: string): string[] {
+  const candidates = new Set([basePath, `${basePath}.js`, `${basePath}.mjs`, `${basePath}.cjs`]);
+
+  for (const candidateBase of [basePath.replace(/\.(?:mjs|cjs|js)$/i, ''), basePath]) {
+    candidates.add(`${candidateBase}.ts`);
+    candidates.add(`${candidateBase}.tsx`);
+    candidates.add(`${candidateBase}.jsx`);
+    candidates.add(`${candidateBase}.svelte`);
+    candidates.add(`${candidateBase}.svelte.ts`);
+    candidates.add(`${candidateBase}.css`);
+  }
+
+  return [...candidates];
+}

package/src/lib/bin/build-tailwind-manifest/types.ts

@@ -0,0 +1,18 @@
+import type { TailwindSourceManifestLeaf } from '../../vite/tailwind-sources-manifest.js';
+
+export type GeneratorOptions = {
+  exportFilters: string[];
+};
+
+export type GraphScan = {
+  classes: Set<string>;
+  sources: Set<string>;
+};
+
+export type CliOptions = {
+  exportFilters: string[];
+  packagePatterns: string[];
+  watch: boolean;
+};
+
+export type SymbolManifest = Record<string, TailwindSourceManifestLeaf>;

package/src/lib/vite/vite-plugin-component-source-collector.ts

@@ -5,6 +5,7 @@ import { resolve, join, relative, dirname, isAbsolute, parse as parsePath } from
 import { init, parse as parseEsm } from 'es-module-lexer';
 import { parse as parseSvelte } from 'svelte/compiler';
 import { exists, writeIfDifferent } from 'ts-ag';
+import { ensureDotRelative } from 'ts-ag';
 import type { Plugin, ResolvedConfig } from 'vite';
 
 import {
@@ -50,12 +51,6 @@ const packageJsonCache = new Map<string, Promise<string | null>>();
 const packageManifestCache = new Map<string, Promise<TailwindSourceManifest | null>>();
 const TAILWIND_TOKEN_PROPERTY_PATTERN = String.raw`(?:class|(?:"[^"\n]*class[^"\n]*"|'[^'\n]*class[^'\n]*'|[A-Za-z_$][\w$]*class[\w$]*))`;
 
-// TODO replace with ts-ag method
-function ensureDotRelative(filePath: string): string {
-  if (filePath.startsWith('./')) return filePath;
-  return `./${filePath}`;
-}
-
 async function touch(path: string) {
   const handle = await open(path, 'a');
   await handle.close();

package/dist/bin/build-tailwind-manifest.d.ts

@@ -1,15 +0,0 @@
-//#region dist/bin/build-tailwind-manifest.d.ts
-type GeneratorOptions = {
-  exportFilters: string[];
-};
-/** Build a Tailwind source manifest for one package export map. */
-declare function generateTailwindManifestForPackage(packageDir: string, options: GeneratorOptions): Promise<{
-  didWrite: boolean;
-  outputFile: string;
-  exportCount: number;
-}>;
-/** Run the manifest builder once or in watch mode from the current working directory. */
-declare function main(argv?: string[]): Promise<void>;
-//#endregion
-export { generateTailwindManifestForPackage, main };
-//# sourceMappingURL=build-tailwind-manifest.d.ts.map

package/dist/bin/build-tailwind-manifest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build-tailwind-manifest.d.ts","names":["exportFilters","packageDir","GeneratorOptions","options","Promise","didWrite","outputFile","exportCount","argv"],"sources":["../../home/runner/work/svelte-ag/svelte-ag/dist/bin/build-tailwind-manifest.d.ts"],"mappings":";KAAK,gBAAA;EACDA,aAAa;AAAA;;iBAGO,kCAAA,CAAmCC,UAAAA,UAAoBE,OAAAA,EAAS,gBAAA,GAAmB,OAAO;EAC9GE,QAAAA;EACAC,UAAAA;EACAC,WAAAA;AAAAA;;iBAGoB,IAAA,CAAKC,IAAAA,cAAkB,OAAO"}