auklet 0.1.4 → 0.1.6

package/dist/workspace/targets.js

@@ -0,0 +1,144 @@
+import path from 'node:path';
+import { isPlainObject } from 'aidly';
+import { findWorkspaceRoot } from '#auklet/workspace/root';
+import { readPnpmWorkspacePackageInfo } from '#auklet/workspace/packages';
+export async function resolveWorkspacePackageInfos(cwd, filters, options) {
+    const root = requireWorkspaceRoot(cwd, options.scope);
+    const packages = await readWorkspacePackageInfo(root, options);
+    return filterWorkspacePackages(packages, filters, options.scope);
+}
+export async function resolveWorkspaceTargets(options) {
+    const root = requireWorkspaceRoot(options.cwd, options.scope);
+    const packages = filterWorkspaceRootPackage(await readWorkspacePackageInfo(root, options), root, options);
+    const matchedPackages = filterWorkspacePackages(packages, options.filters, options.scope);
+    const targetFactory = createWorkspaceTargetFactory(options);
+    const targets = options.includeDependencies
+        ? includeWorkspaceDependencies(matchedPackages, packages, targetFactory, options)
+        : matchedPackages
+            .map((item) => targetFactory.create(item))
+            .filter(isWorkspaceTarget);
+    if (!targets.length) {
+        throw new Error(options.emptyTargetMessage);
+    }
+    return sortWorkspaceTargets(targets, {
+        getDependencies: options.getDependencies,
+        scope: options.scope,
+    });
+}
+export function getWorkspaceDependencyNames(value) {
+    return isPlainObject(value) ? Object.keys(value) : [];
+}
+const filterWorkspaceRootPackage = (packages, root, options) => {
+    if (!options.excludeRoot)
+        return packages;
+    const normalizedRoot = path.resolve(root);
+    return packages.filter((item) => path.resolve(item.path) !== normalizedRoot);
+};
+const isWorkspaceTarget = (target) => {
+    return target !== null;
+};
+const createWorkspaceTargetFactory = (options) => {
+    const cache = new Map();
+    const create = (item) => {
+        const cached = cache.get(item.name);
+        if (cached !== undefined)
+            return cached;
+        if (!options.includePrivate && item.private) {
+            options.onPrivatePackage?.(item, {
+                exact: options.filters.includes(item.name),
+            });
+            cache.set(item.name, null);
+            return null;
+        }
+        const packageJson = options.readPackageJson(item.path);
+        const target = options.createTarget(item, packageJson);
+        cache.set(item.name, target);
+        return target;
+    };
+    return { create };
+};
+const includeWorkspaceDependencies = (matchedPackages, packages, targetFactory, options) => {
+    const packageMap = new Map(packages.map((item) => [item.name, item]));
+    const included = new Map();
+    const include = (item) => {
+        const target = targetFactory.create(item);
+        if (!target || included.has(target.packageName))
+            return;
+        included.set(target.packageName, target);
+        for (const dependency of options.getDependencies(target)) {
+            const dependencyItem = packageMap.get(dependency);
+            if (dependencyItem)
+                include(dependencyItem);
+        }
+    };
+    for (const item of matchedPackages) {
+        include(item);
+    }
+    return [...included.values()];
+};
+const requireWorkspaceRoot = (cwd, scope) => {
+    const root = findWorkspaceRoot(cwd);
+    if (!root) {
+        throw new Error(`[${scope}] --filter requires a pnpm workspace root.`);
+    }
+    return root;
+};
+const readWorkspacePackageInfo = async (root, options) => {
+    try {
+        return await readPnpmWorkspacePackageInfo(root, {
+            env: options.env,
+        });
+    }
+    catch (error) {
+        if (!options.readErrorMessage)
+            throw error;
+        throw new Error(options.readErrorMessage, {
+            cause: error,
+        });
+    }
+};
+const filterWorkspacePackages = (packages, filters, scope) => {
+    const matched = packages.filter((item) => filters.some((filter) => matchesWorkspacePackageFilter(item.name, filter)));
+    if (!matched.length) {
+        throw new Error(`[${scope}] no workspace package matched filter: ${filters.join(', ')}`);
+    }
+    return matched;
+};
+const matchesWorkspacePackageFilter = (packageName, filter) => {
+    if (filter === '*')
+        return true;
+    if (filter.endsWith('/*')) {
+        const scope = filter.slice(0, -2);
+        return packageName.startsWith(`${scope}/`);
+    }
+    return packageName === filter;
+};
+const sortWorkspaceTargets = (targets, options) => {
+    const targetNames = new Set(targets.map((target) => target.packageName));
+    const targetMap = new Map(targets.map((target) => [target.packageName, target]));
+    const sorted = [];
+    const visited = new Set();
+    const visiting = new Set();
+    const visit = (target) => {
+        if (visited.has(target.packageName))
+            return;
+        if (visiting.has(target.packageName)) {
+            throw new Error(`[${options.scope}] circular workspace dependency detected at ${target.packageName}.`);
+        }
+        visiting.add(target.packageName);
+        for (const dependency of options.getDependencies(target)) {
+            if (!targetNames.has(dependency))
+                continue;
+            const dependencyTarget = targetMap.get(dependency);
+            if (dependencyTarget)
+                visit(dependencyTarget);
+        }
+        visiting.delete(target.packageName);
+        visited.add(target.packageName);
+        sorted.push(target);
+    };
+    for (const target of targets) {
+        visit(target);
+    }
+    return sorted;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auklet",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "type": "module",
   "author": "chentao.arthur",
   "description": "Build utilities for TypeScript packages and module CSS output.",

package/dist/cli/buildArgs.d.ts

@@ -1,9 +0,0 @@
-import { AukletEnvContext } from '#auklet/env';
-import type { AukletConfig } from '#auklet/types';
-export declare function resolveBuildCliArgs(args: Array<string>, envContext?: AukletEnvContext): {
-    args: string[];
-    config: AukletConfig;
-};
-export declare function createBuildEnv(config: AukletConfig): {
-    AUKLET_CONFIG_OVERRIDES: string;
-} | undefined;

package/dist/cli/publish.d.ts

@@ -1,2 +0,0 @@
-export declare function runPublish(args: Array<string>): Promise<number>;
-export declare function runOwner(args: Array<string>): Promise<number>;

package/dist/cli/publish.js

@@ -1,9 +0,0 @@
-import { runOwnerCli, runPublishCli } from '#auklet/publish/cli';
-export async function runPublish(args) {
-    await runPublishCli(args);
-    return 0;
-}
-export async function runOwner(args) {
-    await runOwnerCli(args);
-    return 0;
-}