auklet 0.0.16 → 0.0.18

package/dist/config.js

@@ -1,50 +1,47 @@
 export const aukletConfigFile = 'auklet.config.ts';
 export const aukletDefaultOptions = {
-  source: 'src',
-  output: 'dist',
-  modules: false,
-  build: {
-    formats: ['cjs', 'esm', 'iife'],
-    target: 'es2020',
-    platform: 'neutral',
-  },
-  styles: {
-    themes: {},
-    dependencies: {},
-  },
+    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',
-  },
+    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,
+    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),
-        ]),
-      ),
-    },
-  };
+    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.d.ts

@@ -1,8 +1,3 @@
 import type { AukletConfig, LoadAukletConfigOptions } from '#auklet/types';
-export declare function resolveAukletConfigModule(
-  module: Record<string, unknown>,
-): AukletConfig;
-export declare function loadAukletConfig(
-  packageRoot: string,
-  options?: LoadAukletConfigOptions,
-): Promise<AukletConfig>;
+export declare function resolveAukletConfigModule(module: Record<string, unknown>): AukletConfig;
+export declare function loadAukletConfig(packageRoot: string, options?: LoadAukletConfigOptions): Promise<AukletConfig>;

package/dist/configLoader.js

@@ -4,81 +4,76 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import ts from 'typescript';
 import { aukletConfigFile } from '#auklet/config';
 const importAukletConfigModule = async (configPath, href) => {
-  try {
-    return await import(href);
-  } catch (error) {
-    if (!isUnknownTsExtensionError(error) || !configPath.endsWith('.ts')) {
-      throw error;
+    try {
+        return (await import(href));
+    }
+    catch (error) {
+        if (!isUnknownTsExtensionError(error) || !configPath.endsWith('.ts')) {
+            throw error;
+        }
+        return importTsOptionsModule(href);
     }
-    return importTsOptionsModule(href);
-  }
 };
 const importTsOptionsModule = async (href) => {
-  const configPath = fileURLToPath(href);
-  const source = fs.readFileSync(configPath, 'utf8');
-  const output = ts.transpileModule(source, {
-    compilerOptions: {
-      esModuleInterop: true,
-      module: ts.ModuleKind.ESNext,
-      target: ts.ScriptTarget.ES2020,
-    },
-    fileName: configPath,
-  });
-  const tempFile = path.join(
-    path.dirname(configPath),
-    `.auklet.config.${process.pid}.${Date.now()}.mjs`,
-  );
-  fs.writeFileSync(tempFile, output.outputText);
-  try {
-    return await import(pathToFileURL(tempFile).href);
-  } finally {
-    fs.rmSync(tempFile, { force: true });
-  }
+    const configPath = fileURLToPath(href);
+    const source = fs.readFileSync(configPath, 'utf8');
+    const output = ts.transpileModule(source, {
+        compilerOptions: {
+            esModuleInterop: true,
+            module: ts.ModuleKind.ESNext,
+            target: ts.ScriptTarget.ES2020,
+        },
+        fileName: configPath,
+    });
+    const tempFile = path.join(path.dirname(configPath), `.auklet.config.${process.pid}.${Date.now()}.mjs`);
+    fs.writeFileSync(tempFile, output.outputText);
+    try {
+        return (await import(pathToFileURL(tempFile).href));
+    }
+    finally {
+        fs.rmSync(tempFile, { force: true });
+    }
 };
 const isUnknownTsExtensionError = (error) => {
-  return (
-    error instanceof TypeError &&
-    'code' in error &&
-    error.code === 'ERR_UNKNOWN_FILE_EXTENSION'
-  );
+    return (error instanceof TypeError &&
+        'code' in error &&
+        error.code === 'ERR_UNKNOWN_FILE_EXTENSION');
 };
 const asRecord = (value) => {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
-    return null;
-  }
-  return value;
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    return value;
 };
 export function resolveAukletConfigModule(module) {
-  const candidates = [
-    module,
-    asRecord(module.default),
-    asRecord(module['module.exports']),
-  ];
-  for (const candidate of candidates) {
-    if (!candidate) continue;
-    const config = asRecord(candidate.config);
-    if (config) {
-      return config;
+    const candidates = [
+        module,
+        asRecord(module.default),
+        asRecord(module['module.exports']),
+    ];
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        const config = asRecord(candidate.config);
+        if (config) {
+            return config;
+        }
     }
-  }
-  return {};
+    return {};
 }
 export async function loadAukletConfig(packageRoot, options = {}) {
-  const configPath = path.join(
-    packageRoot,
-    options.configFile ?? aukletConfigFile,
-  );
-  if (!fs.existsSync(configPath)) {
-    return {};
-  }
-  const url = pathToFileURL(configPath);
-  if (options.cacheBust) {
-    url.searchParams.set('t', Date.now().toString());
-  }
-  if (configPath.endsWith('.ts')) {
-    const module = await importTsOptionsModule(url.href);
+    const configPath = path.join(packageRoot, options.configFile ?? aukletConfigFile);
+    if (!fs.existsSync(configPath)) {
+        return {};
+    }
+    const url = pathToFileURL(configPath);
+    if (options.cacheBust) {
+        url.searchParams.set('t', Date.now().toString());
+    }
+    if (configPath.endsWith('.ts')) {
+        const module = await importTsOptionsModule(url.href);
+        return resolveAukletConfigModule(module);
+    }
+    const module = await importAukletConfigModule(configPath, url.href);
     return resolveAukletConfigModule(module);
-  }
-  const module = await importAukletConfigModule(configPath, url.href);
-  return resolveAukletConfigModule(module);
 }

package/dist/css/config.js

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

package/dist/css/constants.d.ts

@@ -1,7 +1,7 @@
-export declare const NODE_MODULES_DIR = 'node_modules';
-export declare const SOURCE_COMPONENT_MODULE_RE: RegExp;
-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';
+export declare const NODE_MODULES_DIR = "node_modules";
+export declare const SOURCE_MODULE_RE: RegExp;
+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

@@ -1,5 +1,5 @@
 export const NODE_MODULES_DIR = 'node_modules';
-export const SOURCE_COMPONENT_MODULE_RE = /\.tsx$/;
+export const SOURCE_MODULE_RE = /\.tsx$/;
 export const THEMES_DIR = 'themes';
 export const THEMES_ENTRY_PREFIX = 'themes/';
 export const STYLE_ENTRY = 'style.css';

package/dist/css/core/resolvers/packageImports.d.ts

@@ -1,5 +1 @@
-export declare function resolvePackageImportsSourceImport(
-  packageRoot: string,
-  sourceRoot: string,
-  importPath: string,
-): string[];
+export declare function resolvePackageImportsSourceImport(packageRoot: string, sourceRoot: string, importPath: string): string[];

package/dist/css/core/resolvers/packageImports.js

@@ -5,49 +5,44 @@ import { POSIX_SEPARATOR, toPosixPath } from '#auklet/utils';
 const conditions = ['source', 'import', 'default'];
 const sourceExtensions = /\.(?:[cm]?[jt]s|[jt]sx)$/;
 const readPackageImports = (packageRoot) => {
-  const packageJsonPath = path.join(packageRoot, 'package.json');
-  if (!fs.existsSync(packageJsonPath)) return {};
-  try {
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-    return packageJson.imports ?? {};
-  } catch {
-    return {};
-  }
+    const packageJsonPath = path.join(packageRoot, 'package.json');
+    if (!fs.existsSync(packageJsonPath))
+        return {};
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        return packageJson.imports ?? {};
+    }
+    catch {
+        return {};
+    }
 };
 const trimSourceExtension = (value) => {
-  return value.replace(sourceExtensions, '');
+    return value.replace(sourceExtensions, '');
 };
 const toSourceRelativePath = (packageRoot, sourceRoot, target) => {
-  if (!target.startsWith('.')) return null;
-  const file = path.resolve(packageRoot, target);
-  const relative = path.relative(sourceRoot, file);
-  if (relative.startsWith('..') || path.isAbsolute(relative)) return null;
-  return trimSourceExtension(toPosixPath(relative));
+    if (!target.startsWith('.'))
+        return null;
+    const file = path.resolve(packageRoot, target);
+    const relative = path.relative(sourceRoot, file);
+    if (relative.startsWith('..') || path.isAbsolute(relative))
+        return null;
+    return trimSourceExtension(toPosixPath(relative));
 };
-export function resolvePackageImportsSourceImport(
-  packageRoot,
-  sourceRoot,
-  importPath,
-) {
-  if (!importPath.startsWith('#')) return [];
-  const resolved = (() => {
-    try {
-      return findPathInImports(
-        importPath,
-        readPackageImports(packageRoot),
-        conditions,
-      );
-    } catch {
-      return null;
-    }
-  })();
-  if (!resolved) return [];
-  const sourceRelativePath = toSourceRelativePath(
-    packageRoot,
-    sourceRoot,
-    resolved,
-  );
-  return sourceRelativePath
-    ? [sourceRelativePath.split(POSIX_SEPARATOR).join(path.sep)]
-    : [];
+export function resolvePackageImportsSourceImport(packageRoot, sourceRoot, importPath) {
+    if (!importPath.startsWith('#'))
+        return [];
+    const resolved = (() => {
+        try {
+            return findPathInImports(importPath, readPackageImports(packageRoot), conditions);
+        }
+        catch {
+            return null;
+        }
+    })();
+    if (!resolved)
+        return [];
+    const sourceRelativePath = toSourceRelativePath(packageRoot, sourceRoot, resolved);
+    return sourceRelativePath
+        ? [sourceRelativePath.split(POSIX_SEPARATOR).join(path.sep)]
+        : [];
 }

package/dist/css/core/resolvers/relative.d.ts

@@ -1,4 +1 @@
-export declare function resolveRelativeSourceImport(
-  sourceDir: string,
-  importPath: string,
-): string[];
+export declare function resolveRelativeSourceImport(sourceDir: string, importPath: string): string[];

package/dist/css/core/resolvers/relative.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 export function resolveRelativeSourceImport(sourceDir, importPath) {
-  if (!importPath.startsWith('.')) return [];
-  return [path.normalize(path.join(sourceDir, importPath))];
+    if (!importPath.startsWith('.'))
+        return [];
+    return [path.normalize(path.join(sourceDir, importPath))];
 }

package/dist/css/core/resolvers/tsconfigPaths.d.ts

@@ -1,5 +1 @@
-export declare function resolveTsconfigPathsSourceImport(
-  packageRoot: string,
-  sourceRoot: string,
-  importPath: string,
-): string[];
+export declare function resolveTsconfigPathsSourceImport(packageRoot: string, sourceRoot: string, importPath: string): string[];

package/dist/css/core/resolvers/tsconfigPaths.js

@@ -4,82 +4,75 @@ import ts from 'typescript';
 import { POSIX_SEPARATOR, toPosixPath } from '#auklet/utils';
 const sourceExtensions = /\.(?:[cm]?[jt]s|[jt]sx)$/;
 const findTsconfig = (packageRoot) => {
-  let current = packageRoot;
-  while (true) {
-    const tsconfig = path.join(current, 'tsconfig.json');
-    if (fs.existsSync(tsconfig)) return tsconfig;
-    const parent = path.dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
+    let current = packageRoot;
+    while (true) {
+        const tsconfig = path.join(current, 'tsconfig.json');
+        if (fs.existsSync(tsconfig))
+            return tsconfig;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
 };
 const readTsconfigPaths = (packageRoot) => {
-  const tsconfig = findTsconfig(packageRoot);
-  if (!tsconfig) return null;
-  const loaded = ts.readConfigFile(tsconfig, ts.sys.readFile);
-  if (loaded.error) return null;
-  const parsed = ts.parseJsonConfigFileContent(
-    loaded.config,
-    ts.sys,
-    path.dirname(tsconfig),
-    {},
-    tsconfig,
-  );
-  return {
-    baseUrl: parsed.options.baseUrl ?? path.dirname(tsconfig),
-    paths: parsed.options.paths ?? {},
-  };
+    const tsconfig = findTsconfig(packageRoot);
+    if (!tsconfig)
+        return null;
+    const loaded = ts.readConfigFile(tsconfig, ts.sys.readFile);
+    if (loaded.error)
+        return null;
+    const parsed = ts.parseJsonConfigFileContent(loaded.config, ts.sys, path.dirname(tsconfig), {}, tsconfig);
+    return {
+        baseUrl: parsed.options.baseUrl ?? path.dirname(tsconfig),
+        paths: parsed.options.paths ?? {},
+    };
 };
 const resolvePattern = (pattern, target, importPath) => {
-  const wildcardIndex = pattern.indexOf('*');
-  if (wildcardIndex < 0) return pattern === importPath ? target : null;
-  const prefix = pattern.slice(0, wildcardIndex);
-  const suffix = pattern.slice(wildcardIndex + 1);
-  if (!importPath.startsWith(prefix) || !importPath.endsWith(suffix)) {
-    return null;
-  }
-  const value = importPath.slice(
-    prefix.length,
-    importPath.length - suffix.length,
-  );
-  return target.replace(/\*/g, value);
+    const wildcardIndex = pattern.indexOf('*');
+    if (wildcardIndex < 0)
+        return pattern === importPath ? target : null;
+    const prefix = pattern.slice(0, wildcardIndex);
+    const suffix = pattern.slice(wildcardIndex + 1);
+    if (!importPath.startsWith(prefix) || !importPath.endsWith(suffix)) {
+        return null;
+    }
+    const value = importPath.slice(prefix.length, importPath.length - suffix.length);
+    return target.replace(/\*/g, value);
 };
 const getPatternScore = (pattern) => {
-  const wildcardIndex = pattern.indexOf('*');
-  if (wildcardIndex < 0) return Number.MAX_SAFE_INTEGER;
-  return pattern.slice(0, wildcardIndex).length;
+    const wildcardIndex = pattern.indexOf('*');
+    if (wildcardIndex < 0)
+        return Number.MAX_SAFE_INTEGER;
+    return pattern.slice(0, wildcardIndex).length;
 };
 const trimSourceExtension = (value) => {
-  return value.replace(sourceExtensions, '');
+    return value.replace(sourceExtensions, '');
 };
 const toSourceRelativePath = (sourceRoot, file) => {
-  const relative = path.relative(sourceRoot, file);
-  if (relative.startsWith('..') || path.isAbsolute(relative)) return null;
-  return trimSourceExtension(toPosixPath(relative));
+    const relative = path.relative(sourceRoot, file);
+    if (relative.startsWith('..') || path.isAbsolute(relative))
+        return null;
+    return trimSourceExtension(toPosixPath(relative));
 };
-export function resolveTsconfigPathsSourceImport(
-  packageRoot,
-  sourceRoot,
-  importPath,
-) {
-  const config = readTsconfigPaths(packageRoot);
-  if (!config) return [];
-  const matches = [];
-  for (const [pattern, targets] of Object.entries(config.paths)) {
-    for (const target of targets) {
-      const resolved = resolvePattern(pattern, target, importPath);
-      if (!resolved) continue;
-      const sourceRelativePath = toSourceRelativePath(
-        sourceRoot,
-        path.resolve(config.baseUrl, resolved),
-      );
-      if (sourceRelativePath) {
-        matches.push({
-          path: sourceRelativePath.split(POSIX_SEPARATOR).join(path.sep),
-          score: getPatternScore(pattern),
-        });
-      }
+export function resolveTsconfigPathsSourceImport(packageRoot, sourceRoot, importPath) {
+    const config = readTsconfigPaths(packageRoot);
+    if (!config)
+        return [];
+    const matches = [];
+    for (const [pattern, targets] of Object.entries(config.paths)) {
+        for (const target of targets) {
+            const resolved = resolvePattern(pattern, target, importPath);
+            if (!resolved)
+                continue;
+            const sourceRelativePath = toSourceRelativePath(sourceRoot, path.resolve(config.baseUrl, resolved));
+            if (sourceRelativePath) {
+                matches.push({
+                    path: sourceRelativePath.split(POSIX_SEPARATOR).join(path.sep),
+                    score: getPatternScore(pattern),
+                });
+            }
+        }
     }
-  }
-  return matches.sort((a, b) => b.score - a.score).map((match) => match.path);
+    return matches.sort((a, b) => b.score - a.score).map((match) => match.path);
 }

package/dist/css/core/style/dependencies.d.ts

@@ -1,20 +1,10 @@
 import type { NormalizedAukletConfig } from '#auklet/types';
-export declare function getGlobalStyleDependencies(
-  config: NormalizedAukletConfig,
-): string[];
-export declare function getExternalStyleDependencies(
-  config: NormalizedAukletConfig,
-): string[];
-export declare function getThemeStyleDependencies(
-  config: NormalizedAukletConfig,
-  themeName: string,
-): string[];
+export declare function getGlobalStyleDependencies(config: NormalizedAukletConfig): string[];
+export declare function getExternalStyleDependencies(config: NormalizedAukletConfig): string[];
+export declare function getThemeStyleDependencies(config: NormalizedAukletConfig, themeName: string): string[];
 export declare function getThemeNames(config: NormalizedAukletConfig): string[];
 export declare function getThemeStyleEntries(config: NormalizedAukletConfig): {
-  themeName: string;
-  file: string;
+    themeName: string;
+    file: string;
 }[];
-export declare function resolveThemeStyleFiles(
-  config: NormalizedAukletConfig,
-  packageRoot: string,
-): Map<string, string>;
+export declare function resolveThemeStyleFiles(config: NormalizedAukletConfig, packageRoot: string): Map<string, string>;