auklet 0.0.2 → 0.0.4

package/dist/build/tsdownConfig.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { defineConfig } from 'tsdown/config';
 import { loadAukletConfig } from '#auklet/configLoader';
+import { normalizeAukletConfig } from '#auklet/config';
 const formatMap = {
   cjs: '.cjs',
   iife: '.global.js',
@@ -16,23 +17,19 @@ const getExternal = (names) => {
   return [...external];
 };
 const getPackageExternal = (pkg, options) => {
-  var _a, _b, _c;
   return getExternal([
-    ...Object.keys((_a = pkg.dependencies) !== null && _a !== void 0 ? _a : {}),
-    ...Object.keys(
-      (_b = pkg.peerDependencies) !== null && _b !== void 0 ? _b : {},
-    ),
-    ...((_c = options.externals) !== null && _c !== void 0 ? _c : []),
+    ...Object.keys(pkg.dependencies ?? {}),
+    ...Object.keys(pkg.peerDependencies ?? {}),
+    ...Object.keys(pkg.optionalDependencies ?? {}),
+    ...Object.keys(pkg.devDependencies ?? {}),
+    ...(options.externals ?? []),
   ]);
 };
 const getPeerExternal = (pkg, options) => {
-  var _a, _b;
   return [
     ...new Set([
-      ...Object.keys(
-        (_a = pkg.peerDependencies) !== null && _a !== void 0 ? _a : {},
-      ),
-      ...((_b = options.externals) !== null && _b !== void 0 ? _b : []),
+      ...Object.keys(pkg.peerDependencies ?? {}),
+      ...(options.externals ?? []),
     ]),
   ];
 };
@@ -50,7 +47,7 @@ const getIifeGlobals = (context) => {
   );
 };
 const getIifeAlwaysBundle = (context) => {
-  const names = new Set(context.dependencyNames);
+  const names = new Set(context.runtimeDependencyNames);
   if (context.peerExternal.includes('react')) {
     names.add('react/jsx-runtime');
     names.add('react/jsx-dev-runtime');
@@ -58,13 +55,7 @@ const getIifeAlwaysBundle = (context) => {
   return [...names];
 };
 const getGlobalName = (pkg) => {
-  var _a;
-  return (
-    (_a = pkg === null || pkg === void 0 ? void 0 : pkg.name) !== null &&
-    _a !== void 0
-      ? _a
-      : ''
-  )
+  return (pkg?.name ?? '')
     .replace(/@/g, '')
     .split(/[/-]/g)
     .map((label) => label[0].toUpperCase() + label.slice(1))
@@ -80,43 +71,89 @@ const findWorkspaceTsconfig = (packageRoot) => {
     current = parent;
   }
 };
-const createBuildContext = (packageRoot, options) => {
-  var _a, _b;
+const getBundleEntry = (packageRoot) => {
+  const tsEntry = 'src/index.ts';
+  const tsxEntry = 'src/index.tsx';
+  if (fs.existsSync(path.join(packageRoot, tsEntry))) {
+    return { index: tsEntry };
+  }
+  if (fs.existsSync(path.join(packageRoot, tsxEntry))) {
+    return { index: tsxEntry };
+  }
+  return { index: tsEntry };
+};
+const toPosixPath = (value) => {
+  return value.split(path.sep).join('/');
+};
+const getModuleEntries = (packageRoot) => {
+  const sourceRoot = path.join(packageRoot, 'src');
+  const entries = {};
+  if (!fs.existsSync(sourceRoot)) {
+    return getBundleEntry(packageRoot);
+  }
+  const collect = (dir) => {
+    const dirEntries = fs
+      .readdirSync(dir, { withFileTypes: true })
+      .sort((a, b) => a.name.localeCompare(b.name));
+    for (const dirEntry of dirEntries) {
+      const file = path.join(dir, dirEntry.name);
+      if (dirEntry.isDirectory()) {
+        if (dirEntry.name !== '__tests__') collect(file);
+        continue;
+      }
+      if (!/\.(ts|tsx)$/.test(dirEntry.name)) continue;
+      if (/\.d\.ts$/.test(dirEntry.name)) continue;
+      if (/\.(spec|test)\.(ts|tsx)$/.test(dirEntry.name)) continue;
+      const sourceRelative = toPosixPath(path.relative(packageRoot, file));
+      const entryName = toPosixPath(path.relative(sourceRoot, file)).replace(
+        /\.(ts|tsx)$/,
+        '',
+      );
+      entries[entryName] ??= sourceRelative;
+    }
+  };
+  collect(sourceRoot);
+  return Object.keys(entries).length > 0
+    ? entries
+    : getBundleEntry(packageRoot);
+};
+const createBuildContext = (packageRoot, options, output) => {
   const pkg = JSON.parse(
     fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'),
   );
   const banner =
-    (_a = options.banner) !== null && _a !== void 0
-      ? _a
-      : '/*!\n' +
-        ` * ${pkg.name}.js v${pkg.version}\n` +
-        (pkg.author
-          ? ` * (c) 2026-${new Date().getFullYear()} ${pkg.author}\n`
-          : '') +
-        ' */';
+    options.banner ??
+    '/*!\n' +
+      ` * ${pkg.name}.js v${pkg.version}\n` +
+      (pkg.author
+        ? ` * (c) 2026-${new Date().getFullYear()} ${pkg.author}\n`
+        : '') +
+      ' */';
   return {
-    packageRoot,
-    tsconfig: options.tsconfig
-      ? path.resolve(packageRoot, options.tsconfig)
-      : findWorkspaceTsconfig(packageRoot),
     pkg,
-    dependencyNames: Object.keys(
-      (_b = pkg.dependencies) !== null && _b !== void 0 ? _b : {},
-    ),
+    banner,
+    packageRoot,
+    output,
+    runtimeDependencyNames: Object.keys(pkg.dependencies ?? {}),
     packageExternal: getPackageExternal(pkg, options),
     peerExternal: getPeerExternal(pkg, options),
     globalName: getGlobalName(pkg),
-    banner,
+    platform: options.platform,
+    target: options.target,
+    tsconfig: options.tsconfig
+      ? path.resolve(packageRoot, options.tsconfig)
+      : findWorkspaceTsconfig(packageRoot),
   };
 };
 const createCommonConfig = (context, deps) => {
   return {
     cwd: context.packageRoot,
+    root: context.packageRoot,
     clean: false,
     sourcemap: false,
     tsconfig: context.tsconfig,
-    target: 'es2018',
-    platform: 'browser',
+    target: context.target,
+    platform: context.platform,
     deps,
     define: {
       __TEST__: 'false',
@@ -128,13 +165,16 @@ const createCommonConfig = (context, deps) => {
 };
 const createBundleConfigs = (context, formats) => {
   const outputConfigs = [];
+  let hasDtsConfig = false;
   for (const format of formats) {
     const extnames = formatMap[format];
     for (const extname of Array.isArray(extnames) ? extnames : [extnames]) {
-      outputConfigs.push({ format, extname });
+      const emitDts = !hasDtsConfig;
+      outputConfigs.push({ format, extname, dts: emitDts });
+      hasDtsConfig ||= emitDts;
     }
   }
-  return outputConfigs.map(({ format, extname }) => {
+  return outputConfigs.map(({ format, extname, dts }) => {
     const deps =
       format === 'iife'
         ? {
@@ -147,11 +187,11 @@ const createBundleConfigs = (context, formats) => {
           };
     return {
       ...createCommonConfig(context, deps),
-      entry: ['src/index.ts'],
+      entry: getBundleEntry(context.packageRoot),
       format,
       globalName: context.globalName,
-      outDir: 'dist',
-      dts: false,
+      outDir: context.output,
+      dts,
       treeshake: true,
       banner: context.banner,
       outExtensions: () => ({
@@ -165,17 +205,10 @@ const createBundleConfigs = (context, formats) => {
     };
   });
 };
-const createModuleConfig = (commonConfig, format, outDir) => {
+const createModuleConfig = (commonConfig, entry, format, outDir) => {
   return {
     ...commonConfig,
-    entry: [
-      'src/**/*.ts',
-      'src/**/*.tsx',
-      '!src/**/*.d.ts',
-      '!src/**/__tests__/**',
-      '!src/**/*.spec.ts',
-      '!src/**/*.spec.tsx',
-    ],
+    entry,
     format,
     outDir,
     dts: true,
@@ -190,24 +223,36 @@ const createModuleConfigs = (context) => {
   const commonConfig = createCommonConfig(context, {
     neverBundle: context.packageExternal,
   });
+  const entry = getModuleEntries(context.packageRoot);
   return [
-    createModuleConfig(commonConfig, 'esm', 'dist/es'),
-    createModuleConfig(commonConfig, 'cjs', 'dist/lib'),
+    createModuleConfig(
+      commonConfig,
+      entry,
+      'esm',
+      path.join(context.output, 'es'),
+    ),
+    createModuleConfig(
+      commonConfig,
+      entry,
+      'cjs',
+      path.join(context.output, 'lib'),
+    ),
   ];
 };
 export function defineKernelPackageConfigFromOptions(
   packageRoot = process.cwd(),
   config = {},
 ) {
-  var _a, _b;
-  const buildOptions = (_a = config.build) !== null && _a !== void 0 ? _a : {};
-  const formats =
-    (_b = buildOptions.formats) !== null && _b !== void 0
-      ? _b
-      : ['cjs', 'esm', 'iife'];
-  const context = createBuildContext(packageRoot, buildOptions);
+  const normalizedConfig = normalizeAukletConfig(config);
+  const buildOptions = normalizedConfig.build;
+  const formats = buildOptions.formats;
+  const context = createBuildContext(
+    packageRoot,
+    buildOptions,
+    normalizedConfig.output,
+  );
   const bundleConfigs = createBundleConfigs(context, formats);
-  const moduleConfigs = buildOptions.modules
+  const moduleConfigs = normalizedConfig.modules
     ? createModuleConfigs(context)
     : [];
   return [...bundleConfigs, ...moduleConfigs];

package/dist/config.d.ts

@@ -1,3 +1,40 @@
-import type { CssDependencyGroup } from '#auklet/types';
+import type { AukletConfig, StyleDependencyGroup } from '#auklet/types';
 export declare const aukletConfigFile = 'auklet.config.ts';
-export declare const aukletDefaultCssDependencyConfig: CssDependencyGroup;
+export declare const aukletDefaultOptions: {
+  source: string;
+  output: string;
+  modules: false;
+  build: {
+    formats: ('cjs' | 'esm' | 'iife')[];
+    target: string;
+    platform: 'neutral';
+  };
+  styles: {
+    themes: {};
+    dependencies: {};
+  };
+};
+export declare const aukletDefaultStyleDependencyConfig: StyleDependencyGroup;
+export declare function normalizeAukletConfig(config?: AukletConfig): {
+  source: string;
+  output: string;
+  modules: boolean;
+  build: {
+    formats: Array<import('#auklet/types').PackageBuildFormat>;
+    target: import('#auklet/types').PackageBuildTarget;
+    platform: import('#auklet/types').PackageBuildPlatform;
+    banner?: string;
+    externals?: Array<string>;
+    tsconfig?: string;
+  };
+  styles: {
+    themes: {};
+    dependencies: {
+      [k: string]: {
+        entry: string | string[] | undefined;
+        themes: Record<string, string> | undefined;
+        components: string | string[] | undefined;
+      };
+    };
+  };
+};

package/dist/config.js

@@ -1,9 +1,50 @@
 export const aukletConfigFile = 'auklet.config.ts';
-export const aukletDefaultCssDependencyConfig = {
-  global: '/style.css',
-  component: ['/pages/**.css', '/components/**.css'],
+export const aukletDefaultOptions = {
+  source: 'src',
+  output: 'dist',
+  modules: false,
+  build: {
+    formats: ['cjs', 'esm', 'iife'],
+    target: 'es2020',
+    platform: 'neutral',
+  },
+  styles: {
+    themes: {},
+    dependencies: {},
+  },
+};
+export const aukletDefaultStyleDependencyConfig = {
+  entry: '/style.css',
+  components: ['/pages/**.css', '/components/**.css'],
   themes: {
     dark: '/themes/dark.css',
     light: '/themes/light.css',
   },
 };
+const normalizeStyleDependency = (dependency) => ({
+  entry: dependency.entry,
+  themes: dependency.themes,
+  components: dependency.components,
+});
+export function normalizeAukletConfig(config = {}) {
+  const dependencies =
+    config.styles?.dependencies ?? aukletDefaultOptions.styles.dependencies;
+  return {
+    source: config.source ?? aukletDefaultOptions.source,
+    output: config.output ?? aukletDefaultOptions.output,
+    modules: config.modules ?? aukletDefaultOptions.modules,
+    build: {
+      ...aukletDefaultOptions.build,
+      ...config.build,
+    },
+    styles: {
+      themes: config.styles?.themes ?? aukletDefaultOptions.styles.themes,
+      dependencies: Object.fromEntries(
+        Object.entries(dependencies).map(([packageName, dependency]) => [
+          packageName,
+          normalizeStyleDependency(dependency),
+        ]),
+      ),
+    },
+  };
+}

package/dist/configLoader.js

@@ -64,10 +64,9 @@ export function resolveAukletConfigModule(module) {
   return {};
 }
 export async function loadAukletConfig(packageRoot, options = {}) {
-  var _a;
   const configPath = path.join(
     packageRoot,
-    (_a = options.configFile) !== null && _a !== void 0 ? _a : aukletConfigFile,
+    options.configFile ?? aukletConfigFile,
   );
   if (!fs.existsSync(configPath)) {
     return {};

package/dist/css/config.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleStyleBuildConfig } from '#auklet/types';
+export declare const moduleStyleBuildConfig: ModuleStyleBuildConfig;

package/dist/css/config.js

@@ -0,0 +1,10 @@
+export const moduleStyleBuildConfig = {
+  styleExtensions: ['.css'],
+  output: {
+    styleDir: 'style',
+    indexStyleFile: 'index.css',
+    moduleStyleFile: 'module.css',
+    externalStyleFile: 'external.css',
+    outputFormats: ['es', 'lib'],
+  },
+};

package/dist/css/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const NODE_MODULES_DIR = 'node_modules';
+export declare const THEMES_DIR = 'themes';
+export declare const THEMES_ENTRY_PREFIX = 'themes/';
+export declare const STYLE_ENTRY = 'style.css';
+export declare const MODULE_ENTRY = 'module.css';
+export declare const EXTERNAL_ENTRY = 'external.css';

package/dist/css/constants.js

@@ -0,0 +1,6 @@
+export const NODE_MODULES_DIR = 'node_modules';
+export const THEMES_DIR = 'themes';
+export const THEMES_ENTRY_PREFIX = 'themes/';
+export const STYLE_ENTRY = 'style.css';
+export const MODULE_ENTRY = 'module.css';
+export const EXTERNAL_ENTRY = 'external.css';

package/dist/css/core/moduleGraph.d.ts

@@ -0,0 +1,55 @@
+import { type LoadAukletConfig } from '#auklet/css/core/moduleGraphRequestCache';
+import type { ModuleStyleBuildConfig } from '#auklet/types';
+export interface ModuleStyleGraphOptions {
+  workspaceRoot: string;
+  packagesDir?: string;
+  config?: ModuleStyleBuildConfig;
+  loadAukletConfig?: LoadAukletConfig;
+}
+export type PackageStyleId = {
+  packageName: string;
+  stylePath: string;
+};
+export type PackageStyleLoadResult = {
+  code: string;
+  watchFiles: Array<string>;
+};
+export declare class ModuleStyleGraph {
+  private readonly config;
+  private readonly workspaceRoot;
+  private readonly packagesDir;
+  private readonly loadAukletConfig;
+  constructor(options: ModuleStyleGraphOptions);
+  parsePackageStyleId(id: string): {
+    packageName: string;
+    stylePath: string;
+  } | null;
+  isWorkspaceSourceGraphFile(file: string): boolean;
+  isStyleConfigFile(file: string): boolean;
+  isStyleFile(file: string): boolean;
+  getWorkspacePackageNames(): string[];
+  getWatchRoots(): string[];
+  createPackageStyleCode(parsed: PackageStyleId): Promise<{
+    code: string;
+    watchFiles: string[];
+  }>;
+  private createPackageStyleCodeWithCache;
+  private createStyleCode;
+  private createDependencyStyleCode;
+  private createExternalStyleCode;
+  private createThemeStyleCode;
+  private createModuleStyleCode;
+  private createSourceModuleStyleCode;
+  private toDevModuleImportSpecifier;
+  private toDevExternalStyleSpecifier;
+  private parsePackageStyleIdInRequest;
+  private isWorkspacePackageName;
+  private createRequestCache;
+}
+export declare function parsePackageStyleId(
+  id: string,
+  packageNames: Array<string>,
+): {
+  packageName: string;
+  stylePath: string;
+} | null;