@pagepocket/cli 0.11.1 → 0.13.0

package/dist/commands/archive.js

@@ -1,139 +1,11 @@
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
 import { Args, Command, Flags } from "@oclif/core";
 import { ga, ns, PagePocket } from "@pagepocket/lib";
 import chalk from "chalk";
-import { loadConfiguredPlugins } from "../services/load-configured-plugins.js";
+import ora from "ora";
 import { ConfigService } from "../services/config-service.js";
-import { readBuiltinStrategy, listBuiltinStrategyNames } from "../services/strategy/builtin-strategy-registry.js";
+import { loadConfiguredPlugins } from "../services/load-configured-plugins.js";
 import { StrategyService } from "../services/strategy/strategy-service.js";
-import { normalizeStrategyUnits } from "../services/strategy/strategy-normalize.js";
-import { parsePinnedSpec } from "../services/user-packages/parse-pinned-spec.js";
-import { isUnitLike, resolveUnitConstructor } from "../services/units/unit-validate.js";
-import { UnitStore } from "../services/units/unit-store.js";
-import { uniq } from "../utils/array.js";
-import { withSpinner } from "../utils/with-spinner.js";
-const buildMissingStrategyError = (input) => {
-    const available = uniq([...input.installedNames, ...listBuiltinStrategyNames()])
-        .filter((name) => name.trim().length > 0)
-        .sort((left, right) => left.localeCompare(right));
-    const suffix = available.length > 0
-        ? ` Available strategies: ${available.join(", ")}`
-        : " No strategies found.";
-    return new Error(`Strategy not found: ${input.strategyName}.${suffix}`);
-};
-const resolveStrategy = (input) => {
-    const installedNames = input.strategyService.listInstalledStrategyNames();
-    if (installedNames.includes(input.strategyName)) {
-        return {
-            name: input.strategyName,
-            strategyFile: input.strategyService.readStrategy(input.strategyName),
-            source: "installed"
-        };
-    }
-    const builtin = readBuiltinStrategy(input.strategyName);
-    if (builtin) {
-        return {
-            name: input.strategyName,
-            strategyFile: builtin,
-            source: "builtin"
-        };
-    }
-    throw buildMissingStrategyError({
-        strategyName: input.strategyName,
-        installedNames
-    });
-};
-const assertNoDuplicateUnitIds = (input) => {
-    const seen = new Set();
-    const dup = input.units.find((u) => {
-        if (seen.has(u.id)) {
-            return true;
-        }
-        seen.add(u.id);
-        return false;
-    });
-    if (dup) {
-        throw new Error(`Duplicate unit id detected in strategy ${input.strategyName}: ${dup.id}`);
-    }
-};
-const loadInstalledStrategyUnits = async (input) => {
-    const strategyService = new StrategyService(input.configService);
-    const unitStore = new UnitStore(input.configService);
-    strategyService.ensureConfigFileExists();
-    const strategyFile = strategyService.readStrategy(input.strategyName);
-    const normalized = normalizeStrategyUnits(strategyFile);
-    const installed = unitStore.readInstalledDependencyVersions();
-    const drift = normalized.flatMap((u) => {
-        const pinned = parsePinnedSpec(u.ref);
-        const installedVersion = installed[pinned.name];
-        if (!installedVersion || installedVersion !== pinned.version) {
-            return [
-                {
-                    name: pinned.name,
-                    pinned: pinned.version,
-                    installed: installedVersion
-                }
-            ];
-        }
-        return [];
-    });
-    if (drift.length > 0) {
-        const details = drift
-            .map((d) => {
-            const installedText = typeof d.installed === "string" ? d.installed : "(not installed)";
-            return `${d.name}: pinned ${d.pinned}, installed ${installedText}`;
-        })
-            .join("; ");
-        throw new Error(`Strategy drift detected (${input.strategyName}). ${details}. ` +
-            `Fix: pp strategy update ${input.strategyName} OR pp strategy pin ${input.strategyName}`);
-    }
-    const units = await Promise.all(normalized.map(async (u) => unitStore.instantiateFromRef(u.ref, u.args)));
-    assertNoDuplicateUnitIds({
-        strategyName: input.strategyName,
-        units
-    });
-    return units;
-};
-const instantiateBuiltinUnit = async (input) => {
-    const req = createRequire(import.meta.url);
-    const pinned = parsePinnedSpec(input.ref);
-    const resolved = req.resolve(pinned.name);
-    const mod = (await import(pathToFileURL(resolved).href));
-    const ctor = resolveUnitConstructor(mod);
-    if (!ctor) {
-        throw new Error(`Unit ${pinned.name} does not export a Unit constructor.`);
-    }
-    const instance = new ctor(...input.args);
-    if (!isUnitLike(instance)) {
-        throw new Error(`Unit ${pinned.name} exported constructor did not produce a Unit.`);
-    }
-    return instance;
-};
-const loadBuiltinStrategyUnits = async (input) => {
-    const normalized = normalizeStrategyUnits(input.strategyFile);
-    const units = await Promise.all(normalized.map(async (u) => instantiateBuiltinUnit({
-        ref: u.ref,
-        args: u.args
-    })));
-    assertNoDuplicateUnitIds({
-        strategyName: input.strategyName,
-        units
-    });
-    return units;
-};
-const loadStrategyUnits = async (input) => {
-    if (input.strategy.source === "installed") {
-        return loadInstalledStrategyUnits({
-            strategyName: input.strategy.name,
-            configService: input.configService
-        });
-    }
-    return loadBuiltinStrategyUnits({
-        strategyName: input.strategy.name,
-        strategyFile: input.strategy.strategyFile
-    });
-};
+import { loadStrategyUnits, resolveStrategy } from "../utils/archive-strategy.js";
 export default class ArchiveCommand extends Command {
     static description = "Archive a web page as an offline snapshot.";
     static args = {
@@ -165,38 +37,51 @@ export default class ArchiveCommand extends Command {
         const timeoutMs = typeof flags.timeout === "number" ? flags.timeout : undefined;
         const maxDurationMs = typeof flags.maxDuration === "number" ? flags.maxDuration : undefined;
         const strategyName = typeof flags.strategy === "string" ? flags.strategy.trim() : undefined;
+        const configService = new ConfigService();
+        const name = strategyName && strategyName.length > 0 ? strategyName : "default";
+        const strategyService = new StrategyService(configService);
+        strategyService.ensureConfigFileExists();
+        const strategy = resolveStrategy({ strategyName: name, strategyService });
+        const units = await loadStrategyUnits({ strategy, configService });
+        const strategyFile = strategy.strategyFile;
+        const captureOptions = strategyFile.pipeline.captureOptions;
+        const effectiveTimeoutMs = typeof timeoutMs === "number" ? timeoutMs : captureOptions?.timeoutMs;
+        const effectiveMaxDurationMs = typeof maxDurationMs === "number" ? maxDurationMs : captureOptions?.maxDurationMs;
         const pagepocket = PagePocket.fromURL(targetUrl);
-        const result = await withSpinner(async (spinner) => {
-            {
-                const configService = new ConfigService();
-                const name = strategyName && strategyName.length > 0 ? strategyName : "default";
-                const strategyService = new StrategyService(configService);
-                strategyService.ensureConfigFileExists();
-                const strategy = resolveStrategy({
-                    strategyName: name,
-                    strategyService
-                });
-                const units = await loadStrategyUnits({
-                    strategy,
-                    configService
-                });
-                const entryTarget = pagepocket;
-                const strategyFile = strategy.strategyFile;
-                const captureOptions = strategyFile.pipeline.captureOptions;
-                const effectiveTimeoutMs = typeof timeoutMs === "number" ? timeoutMs : captureOptions?.timeoutMs;
-                const effectiveMaxDurationMs = typeof maxDurationMs === "number" ? maxDurationMs : captureOptions?.maxDurationMs;
-                const result = await entryTarget.capture({
-                    ...(typeof effectiveTimeoutMs === "number" ? { timeoutMs: effectiveTimeoutMs } : {}),
-                    ...(typeof effectiveMaxDurationMs === "number"
-                        ? { maxDurationMs: effectiveMaxDurationMs }
-                        : {}),
-                    blacklist: [...ga, ...ns],
-                    units,
-                    plugins: await loadConfiguredPlugins().catch(() => [])
-                });
-                return result;
+        let spinner = ora();
+        let activeUnitId = "";
+        let activeUnitLabel = "";
+        const formatUnitLabel = (index, total, unitDescription) => `[${index + 1}/${total}] ${unitDescription}`;
+        pagepocket.on("unit:start", (e) => {
+            activeUnitId = e.unitId;
+            activeUnitLabel = formatUnitLabel(e.index, e.total, e.unitDescription);
+            spinner = ora(activeUnitLabel).start();
+        });
+        pagepocket.on("unit:log", (e) => {
+            if (e.unitId !== activeUnitId) {
+                return;
             }
-        }, "Freezing page");
+            spinner.text = `${activeUnitLabel} ${chalk.gray(e.message)}`;
+        });
+        pagepocket.on("unit:end", (e) => {
+            spinner.succeed(formatUnitLabel(e.index, e.total, e.unitDescription));
+        });
+        let result;
+        try {
+            result = await pagepocket.capture({
+                ...(typeof effectiveTimeoutMs === "number" ? { timeoutMs: effectiveTimeoutMs } : {}),
+                ...(typeof effectiveMaxDurationMs === "number"
+                    ? { maxDurationMs: effectiveMaxDurationMs }
+                    : {}),
+                blacklist: [...ga, ...ns],
+                units,
+                plugins: await loadConfiguredPlugins().catch(() => [])
+            });
+        }
+        catch (error) {
+            spinner.fail();
+            throw error;
+        }
         this.log(chalk.green("All done! Snapshot created."));
         if (result.kind === "zip") {
             this.log(`Snapshot saved to ${chalk.cyan(result.zip.outputPath)}`);

package/dist/commands/plugin/set.js

@@ -38,9 +38,7 @@ export default class PluginSetCommand extends Command {
         const configService = new ConfigService();
         configService.ensureConfigFileExists();
         const config = configService.readConfigOrDefault();
-        const targetIndex = config.plugins.findIndex((entry) => {
-            return (typeof entry === "string" ? entry : entry.name) === targetName;
-        });
+        const targetIndex = config.plugins.findIndex((entry) => (typeof entry === "string" ? entry : entry.name) === targetName);
         if (targetIndex < 0) {
             this.log(chalk.gray(`Plugin not found in config: ${targetName}`));
             return;

package/dist/commands/strategy/doctor.js

@@ -6,15 +6,15 @@ export default class StrategyDoctorCommand extends Command {
     async run() {
         const service = new StrategyService();
         const report = service.doctor();
-        report.conflicts.forEach((c) => {
-            this.log(chalk.red(`[CONFLICT] ${c.name}`));
-            Object.entries(c.versions).forEach(([version, strategies]) => {
+        report.conflicts.forEach((conflict) => {
+            this.log(chalk.red(`[CONFLICT] ${conflict.name}`));
+            Object.entries(conflict.versions).forEach(([version, strategies]) => {
                 this.log(chalk.red(`  ${version}: ${strategies.join(", ")}`));
             });
         });
-        report.drift.forEach((d) => {
-            this.log(chalk.yellow(`[DRIFT] ${d.strategy}`));
-            d.items.forEach((item) => {
+        report.drift.forEach((drift) => {
+            this.log(chalk.yellow(`[DRIFT] ${drift.strategy}`));
+            drift.items.forEach((item) => {
                 const installed = typeof item.installed === "string" ? item.installed : "(not installed)";
                 this.log(chalk.yellow(`  ${item.name}: pinned ${item.pinned}, installed ${installed}`));
             });

package/dist/commands/strategy/ls.js

@@ -1,22 +1,46 @@
 import { Command } from "@oclif/core";
-import { listBuiltinStrategyNames } from "../../services/strategy/builtin-strategy-registry.js";
+import chalk from "chalk";
+import { listBuiltinStrategyNames, readBuiltinStrategy } from "../../services/strategy/builtin-strategy-registry.js";
+import { normalizeBuiltinStrategyUnits, normalizeStrategyUnits } from "../../services/strategy/strategy-normalize.js";
 import { StrategyService } from "../../services/strategy/strategy-service.js";
 import { uniq } from "../../utils/array.js";
+const formatInstalledStrategy = (name, strategyFile) => {
+    const units = normalizeStrategyUnits(strategyFile);
+    const pipeline = units.map((unit) => unit.ref).join(" -> ");
+    return pipeline.length > 0 ? `${name}${chalk.dim(`(${pipeline})`)}` : name;
+};
+const formatBuiltinStrategy = (name, strategyFile) => {
+    const units = normalizeBuiltinStrategyUnits(strategyFile);
+    const pipeline = units.map((unit) => unit.name).join(" -> ");
+    return pipeline.length > 0 ? `${name}${chalk.dim(`(${pipeline})`)}` : name;
+};
 export default class StrategyLsCommand extends Command {
     static description = "List available strategies.";
     async run() {
         const service = new StrategyService();
         service.ensureConfigFileExists();
-        const builtin = listBuiltinStrategyNames();
-        const installed = service.listInstalledStrategyNames();
-        const names = uniq([...builtin, ...installed])
-            .map((n) => n.trim())
-            .filter((n) => n.length > 0)
-            .sort((a, b) => a.localeCompare(b));
+        const builtinNames = listBuiltinStrategyNames();
+        const installedNames = service.listInstalledStrategyNames();
+        const names = uniq([...builtinNames, ...installedNames])
+            .map((name) => name.trim())
+            .filter((name) => name.length > 0)
+            .sort((left, right) => left.localeCompare(right));
         if (names.length === 0) {
             this.log("No strategies available.");
             return;
         }
-        names.forEach((n) => this.log(n));
+        for (const name of names) {
+            const isInstalled = installedNames.includes(name);
+            const strategyFile = isInstalled ? service.readStrategy(name) : readBuiltinStrategy(name);
+            if (strategyFile) {
+                const formatted = isInstalled
+                    ? formatInstalledStrategy(name, strategyFile)
+                    : formatBuiltinStrategy(name, strategyFile);
+                this.log(formatted);
+            }
+            else {
+                this.log(name);
+            }
+        }
     }
 }

package/dist/commands/view.js

@@ -51,7 +51,7 @@ export default class ViewCommand extends Command {
             host: flags.host,
             port
         });
-        this.log(`Serving ${chalk.cyan(rootDir)}`);
+        this.log(`Serving ${chalk.cyan(rootDir)} ${chalk.dim(`(${server.snapshotType})`)}`);
         this.log(chalk.green(server.url));
     }
 }

package/dist/services/config-service.js

@@ -15,8 +15,8 @@ export class ConfigService {
     }
     getConfigDir() {
         if (process.platform === "win32") {
-            const p = envPaths(this.appName, { suffix: "" });
-            return p.config;
+            const envPathsResult = envPaths(this.appName, { suffix: "" });
+            return envPathsResult.config;
         }
         const homeDir = os.homedir();
         const xdgConfigHome = process.env.XDG_CONFIG_HOME;
@@ -24,8 +24,8 @@ export class ConfigService {
         return path.join(base, this.appName);
     }
     getDataDir() {
-        const p = envPaths(this.appName, { suffix: "" });
-        return p.data;
+        const envPathsResult = envPaths(this.appName, { suffix: "" });
+        return envPathsResult.data;
     }
     getConfigPath() {
         return path.join(this.getConfigDir(), "config.json");
@@ -73,13 +73,13 @@ export class ConfigService {
                 }
                 return undefined;
             })
-                .filter((x) => typeof x !== "undefined")
+                .filter((pluginEntry) => typeof pluginEntry !== "undefined")
             : [];
         const strategiesRaw = value.strategies;
         const strategies = Array.isArray(strategiesRaw)
             ? strategiesRaw
-                .map((x) => (typeof x === "string" ? x.trim() : ""))
-                .filter((x) => x.length > 0)
+                .map((strategyName) => (typeof strategyName === "string" ? strategyName.trim() : ""))
+                .filter((strategyName) => strategyName.length > 0)
             : [];
         const packsRaw = value.strategyPacks;
         const strategyPacks = Array.isArray(packsRaw)
@@ -98,7 +98,7 @@ export class ConfigService {
                 }
                 return undefined;
             })
-                .filter((x) => Boolean(x))
+                .filter((strategyPackEntry) => Boolean(strategyPackEntry))
             : [];
         return {
             plugins,

package/dist/services/plugin-installer.js

@@ -7,16 +7,16 @@ import { spawnSync } from "node:child_process";
  */
 const tryInstallWithFallback = (installDir, packageSpec) => {
     const tryRun = (cmd, args) => {
-        const r = spawnSync(cmd, args, {
+        const result = spawnSync(cmd, args, {
             cwd: installDir,
             stdio: "inherit",
             shell: false
         });
-        if (r.error) {
-            return { ok: false, error: r.error };
+        if (result.error) {
+            return { ok: false, error: result.error };
         }
-        if (typeof r.status === "number" && r.status !== 0) {
-            return { ok: false, error: new Error(`${cmd} exited with code ${r.status}`) };
+        if (typeof result.status === "number" && result.status !== 0) {
+            return { ok: false, error: new Error(`${cmd} exited with code ${result.status}`) };
         }
         return { ok: true };
     };
@@ -51,16 +51,16 @@ export const uninstallPluginPackage = (store, input) => {
     store.ensurePluginPackageJson();
     const installDir = store.getInstallDir();
     const tryRun = (cmd, args) => {
-        const r = spawnSync(cmd, args, {
+        const result = spawnSync(cmd, args, {
             cwd: installDir,
             stdio: "inherit",
             shell: false
         });
-        if (r.error) {
-            return { ok: false, error: r.error };
+        if (result.error) {
+            return { ok: false, error: result.error };
         }
-        if (typeof r.status === "number" && r.status !== 0) {
-            return { ok: false, error: new Error(`${cmd} exited with code ${r.status}`) };
+        if (typeof result.status === "number" && result.status !== 0) {
+            return { ok: false, error: new Error(`${cmd} exited with code ${result.status}`) };
         }
         return { ok: true };
     };

package/dist/services/plugin-store.js

@@ -15,17 +15,13 @@ export const normalizePluginConfigEntry = (entry) => {
     };
 };
 export const getPluginNameFromSpec = (spec) => spec.name;
-const isRecord = (value) => {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-};
-const isCallable = (value) => {
-    return typeof value === "function";
-};
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const isCallable = (value) => typeof value === "function";
 const isStringRecord = (value) => {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return false;
     }
-    return Object.values(value).every((v) => typeof v === "string");
+    return Object.values(value).every((entryValue) => typeof entryValue === "string");
 };
 export class PluginStore {
     configService;
@@ -80,11 +76,13 @@ export class PluginStore {
             if (!json.ok || !json.value || typeof json.value !== "object") {
                 return { name: pluginName };
             }
-            const o = json.value;
+            const packageJsonRecord = json.value;
             return {
-                name: typeof o.name === "string" ? o.name : pluginName,
-                description: typeof o.description === "string" ? o.description : undefined,
-                version: typeof o.version === "string" ? o.version : undefined
+                name: typeof packageJsonRecord.name === "string" ? packageJsonRecord.name : pluginName,
+                description: typeof packageJsonRecord.description === "string"
+                    ? packageJsonRecord.description
+                    : undefined,
+                version: typeof packageJsonRecord.version === "string" ? packageJsonRecord.version : undefined
             };
         }
         catch {
@@ -146,7 +144,7 @@ export class PluginStore {
         this.configService.writeConfig(next);
     }
     hasPlugin(config, pluginName) {
-        return config.plugins.some((e) => getPluginNameFromSpec(normalizePluginConfigEntry(e)) === pluginName);
+        return config.plugins.some((pluginEntry) => getPluginNameFromSpec(normalizePluginConfigEntry(pluginEntry)) === pluginName);
     }
     addPluginToConfig(config, entry) {
         const spec = normalizePluginConfigEntry(entry);
@@ -157,7 +155,7 @@ export class PluginStore {
     }
     removePluginFromConfig(config, pluginName) {
         const before = config.plugins;
-        const after = before.filter((e) => getPluginNameFromSpec(normalizePluginConfigEntry(e)) !== pluginName);
+        const after = before.filter((pluginEntry) => getPluginNameFromSpec(normalizePluginConfigEntry(pluginEntry)) !== pluginName);
         return {
             config: { ...config, plugins: after },
             removed: after.length !== before.length

package/dist/services/strategy/builtin-strategy-registry.js

@@ -1,23 +1,14 @@
-import path from "node:path";
 import { createRequire } from "node:module";
+import path from "node:path";
+import { MemoryCache } from "@pagepocket/shared";
 import { readStrategiesFromPackRoot } from "./strategy-pack-read.js";
-const readBuiltinStrategiesUnsafe = () => {
-    const req = createRequire(import.meta.url);
-    const pkgJsonPath = req.resolve("@pagepocket/builtin-strategy/package.json");
-    const packRoot = path.dirname(pkgJsonPath);
-    return readStrategiesFromPackRoot(packRoot);
-};
-export const readBuiltinStrategies = () => {
-    try {
-        return readBuiltinStrategiesUnsafe();
-    }
-    catch {
-        return [];
-    }
-};
-export const listBuiltinStrategyNames = () => {
-    return readBuiltinStrategies().map((strategy) => strategy.name);
-};
-export const readBuiltinStrategy = (name) => {
-    return readBuiltinStrategies().find((strategy) => strategy.name === name);
-};
+const BUILTIN_KEY = "builtin";
+const cache = new MemoryCache();
+const resolveBuiltinPackRoot = () => {
+    const require = createRequire(import.meta.url);
+    const packageJsonPath = require.resolve("@pagepocket/builtin-strategy/package.json");
+    return path.dirname(packageJsonPath);
+};
+const loadBuiltinStrategies = () => cache.getOrSet(BUILTIN_KEY, () => readStrategiesFromPackRoot(resolveBuiltinPackRoot()));
+export const listBuiltinStrategyNames = () => loadBuiltinStrategies().map((strategy) => strategy.name);
+export const readBuiltinStrategy = (name) => loadBuiltinStrategies().find((strategy) => strategy.name === name);

package/dist/services/strategy/strategy-analyze.js

@@ -1,12 +1,12 @@
 import { parsePinnedSpec } from "../user-packages/parse-pinned-spec.js";
 export const collectWantedVersions = (strategies) => {
     const wanted = {};
-    for (const s of strategies) {
-        for (const u of s.units) {
-            const pinned = parsePinnedSpec(u.ref);
+    for (const strategy of strategies) {
+        for (const unit of strategy.units) {
+            const pinned = parsePinnedSpec(unit.ref);
             wanted[pinned.name] ??= {};
             wanted[pinned.name][pinned.version] ??= [];
-            wanted[pinned.name][pinned.version].push(s.name);
+            wanted[pinned.name][pinned.version].push(strategy.name);
         }
     }
     return wanted;
@@ -23,8 +23,8 @@ export const computeConflicts = (wanted) => {
     return conflicts;
 };
 export const computeDrift = (input) => {
-    const items = input.units.flatMap((u) => {
-        const pinned = parsePinnedSpec(u.ref);
+    const items = input.units.flatMap((unit) => {
+        const pinned = parsePinnedSpec(unit.ref);
         const installedVersion = input.installed[pinned.name];
         if (!installedVersion || installedVersion !== pinned.version) {
             return [

package/dist/services/strategy/strategy-config.js

@@ -1,7 +1,7 @@
 import { uniq } from "../../utils/array.js";
-export const listStrategyNamesFromConfig = (config) => {
-    return uniq((config.strategies ?? []).map((s) => s.trim()).filter((s) => s.length > 0));
-};
+export const listStrategyNamesFromConfig = (config) => uniq((config.strategies ?? [])
+    .map((strategyName) => strategyName.trim())
+    .filter((strategyName) => strategyName.length > 0));
 export const requireStrategyInstalled = (config, name) => {
     const installed = listStrategyNamesFromConfig(config);
     if (!installed.includes(name)) {
@@ -13,6 +13,6 @@ export const withStrategyInConfig = (config, name) => {
     return { ...config, strategies };
 };
 export const withoutStrategyInConfig = (config, name) => {
-    const strategies = (config.strategies ?? []).filter((s) => s !== name);
+    const strategies = (config.strategies ?? []).filter((strategyName) => strategyName !== name);
     return { ...config, strategies };
 };

package/dist/services/strategy/strategy-fetch.js

@@ -1,10 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
-import { parseJson } from "../../utils/parse-json.js";
 import { isUrlLike } from "../../utils/normalize-argv.js";
-const isRecord = (value) => {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-};
+import { parseJson } from "../../utils/parse-json.js";
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 const isStrategyFile = (value) => {
     if (!isRecord(value)) {
         return false;

package/dist/services/strategy/strategy-io.js

@@ -1,9 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parseJson } from "../../utils/parse-json.js";
-const isRecord = (value) => {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-};
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 const isStrategyFile = (value) => {
     if (!isRecord(value)) {
         return false;
@@ -23,12 +21,8 @@ const isStrategyFile = (value) => {
     }
     return true;
 };
-export const getStrategiesDir = (configService) => {
-    return path.join(configService.getConfigDir(), "strategies");
-};
-export const getStrategyPath = (configService, name) => {
-    return path.join(getStrategiesDir(configService), `${name}.json`);
-};
+export const getStrategiesDir = (configService) => path.join(configService.getConfigDir(), "strategies");
+export const getStrategyPath = (configService, name) => path.join(getStrategiesDir(configService), `${name}.json`);
 export const readStrategyFile = (filePath) => {
     const text = fs.readFileSync(filePath, "utf8");
     const parsed = parseJson(text);