auklet 0.0.16 → 0.0.17

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 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 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/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>;

package/dist/css/core/style/dependencies.js

@@ -2,54 +2,51 @@ import path from 'node:path';
 import { isArray } from 'aidly';
 import { joinDependencySpecifier } from '#auklet/css/core/style/specifier';
 export function getGlobalStyleDependencies(config) {
-  const dependencies = [];
-  for (const [packageName, dependency] of Object.entries(
-    config.styles.dependencies,
-  )) {
-    const globalDependencies = isArray(dependency.entry)
-      ? dependency.entry
-      : dependency.entry
-      ? [dependency.entry]
-      : [];
-    for (const globalDependency of globalDependencies) {
-      dependencies.push(joinDependencySpecifier(packageName, globalDependency));
+    const dependencies = [];
+    for (const [packageName, dependency] of Object.entries(config.styles.dependencies)) {
+        const globalDependencies = isArray(dependency.entry)
+            ? dependency.entry
+            : dependency.entry
+                ? [dependency.entry]
+                : [];
+        for (const globalDependency of globalDependencies) {
+            dependencies.push(joinDependencySpecifier(packageName, globalDependency));
+        }
     }
-  }
-  return dependencies;
+    return dependencies;
 }
 export function getExternalStyleDependencies(config) {
-  return getGlobalStyleDependencies(config);
+    return getGlobalStyleDependencies(config);
 }
 export function getThemeStyleDependencies(config, themeName) {
-  const dependencies = [];
-  for (const [packageName, dependency] of Object.entries(
-    config.styles.dependencies,
-  )) {
-    const themeDependency = dependency.themes?.[themeName];
-    if (!themeDependency) continue;
-    dependencies.push(joinDependencySpecifier(packageName, themeDependency));
-  }
-  return dependencies;
+    const dependencies = [];
+    for (const [packageName, dependency] of Object.entries(config.styles.dependencies)) {
+        const themeDependency = dependency.themes?.[themeName];
+        if (!themeDependency)
+            continue;
+        dependencies.push(joinDependencySpecifier(packageName, themeDependency));
+    }
+    return dependencies;
 }
 export function getThemeNames(config) {
-  const names = new Set(Object.keys(config.styles.themes));
-  for (const dependency of Object.values(config.styles.dependencies)) {
-    for (const themeName of Object.keys(dependency.themes ?? {})) {
-      names.add(themeName);
+    const names = new Set(Object.keys(config.styles.themes));
+    for (const dependency of Object.values(config.styles.dependencies)) {
+        for (const themeName of Object.keys(dependency.themes ?? {})) {
+            names.add(themeName);
+        }
     }
-  }
-  return [...names];
+    return [...names];
 }
 export function getThemeStyleEntries(config) {
-  return Object.entries(config.styles.themes).map(([themeName, file]) => ({
-    themeName,
-    file,
-  }));
+    return Object.entries(config.styles.themes).map(([themeName, file]) => ({
+        themeName,
+        file,
+    }));
 }
 export function resolveThemeStyleFiles(config, packageRoot) {
-  const themeFiles = new Map();
-  for (const { themeName, file } of getThemeStyleEntries(config)) {
-    themeFiles.set(themeName, path.resolve(packageRoot, file));
-  }
-  return themeFiles;
+    const themeFiles = new Map();
+    for (const { themeName, file } of getThemeStyleEntries(config)) {
+        themeFiles.set(themeName, path.resolve(packageRoot, file));
+    }
+    return themeFiles;
 }