@loopress/cli 0.21.0 → 0.23.0

package/dist/utils/plugins.js

@@ -14,9 +14,18 @@ export function mergePluginManifest(existing, incoming) {
 }
 // WordPress core identifies each plugin by a `<folder>/<file>` id (or a bare `<file>` for a
 // single-file plugin) with the `.php` extension stripped; the WordPress.org slug is just the
-// folder name (or the bare id itself for a single-file plugin).
-function slugFromPluginFile(file) {
-    return file.split('/', 1)[0];
+// folder name (or the bare id itself for a single-file plugin). Composer + composer/installers
+// installs a WPackagist plugin into `wp-content/plugins/<slug>/`, so folder name and slug stay
+// aligned for anything Loopress manages.
+//
+// A single-file plugin's bare id isn't always its real slug though: Hello Dolly ships as
+// `hello.php` but its WordPress.org (and WPackagist) slug is `hello-dolly`. When that happens,
+// trust the plugin's own `Plugin URI` header over the guessed id.
+const WP_ORG_PLUGIN_URI = /^https?:\/\/wordpress\.org\/plugins\/([^/]+)\/?$/;
+function slugFromPluginFile(file, pluginUri) {
+    if (file.includes('/'))
+        return file.split('/', 1)[0];
+    return WP_ORG_PLUGIN_URI.exec(pluginUri)?.[1] ?? file;
 }
 export function parseInstalledPlugins(raw) {
     return raw
@@ -24,27 +33,63 @@ export function parseInstalledPlugins(raw) {
         active: item.status !== 'inactive',
         file: item.plugin,
         name: item.name,
-        slug: slugFromPluginFile(item.plugin),
+        slug: slugFromPluginFile(item.plugin, item.plugin_uri),
         version: item.version,
     }))
         .filter((plugin) => !LOOPRESS_PLUGIN_SLUGS.has(plugin.slug));
 }
-export function diffPlugins(manifest, installed) {
+export function diffPlugins(manifest, installed, 
+// Slugs Loopress currently manages, from the local composer.lock's wpackagist-plugin/*
+// entries. Empty for a loopress.json-only project that doesn't keep a lockfile in the repo:
+// `toRemove` then stays empty (removals still happen server-side, they just aren't previewed).
+managedSlugs = new Set()) {
     const installedMap = new Map(installed.map((p) => [p.slug, p]));
     const toInstall = [];
+    const toPin = [];
     const toActivate = [];
-    const upToDate = [];
-    for (const slug of Object.keys(manifest)) {
+    const collisions = [];
+    const inSync = [];
+    for (const [slug, wanted] of Object.entries(manifest)) {
         const live = installedMap.get(slug);
         if (!live) {
-            toInstall.push({ slug });
+            toInstall.push({ slug, version: wanted });
+            continue;
         }
-        else if (live.active) {
-            upToDate.push(slug);
+        // Installed, but Loopress doesn't own the folder yet: nothing else can be done with it
+        // until `--force` lets Composer take it over.
+        if (!managedSlugs.has(slug)) {
+            collisions.push({ installedVersion: live.version, slug });
+            continue;
         }
-        else {
+        if (wanted !== 'latest' && live.version !== wanted) {
+            toPin.push({ from: live.version, slug, to: wanted });
+            continue;
+        }
+        if (!live.active) {
             toActivate.push({ file: live.file, slug });
+            continue;
         }
+        inSync.push(slug);
+    }
+    const toRemove = [...managedSlugs].filter((slug) => !Object.hasOwn(manifest, slug));
+    const untrackedActive = installed
+        .filter((p) => p.active && !Object.hasOwn(manifest, p.slug) && !managedSlugs.has(p.slug))
+        .map((p) => p.slug);
+    return { collisions, inSync, toActivate, toInstall, toPin, toRemove, untrackedActive };
+}
+// wpackagist-plugin/<slug> or wpackagist-theme/<slug> entries from a composer.lock string.
+export function lockedWpackagistSlugs(composerLock, kind) {
+    if (!composerLock)
+        return new Set();
+    const prefix = `wpackagist-${kind}/`;
+    try {
+        const parsed = JSON.parse(composerLock);
+        return new Set((parsed.packages ?? [])
+            .map((p) => p.name ?? '')
+            .filter((name) => name.startsWith(prefix))
+            .map((name) => name.slice(prefix.length)));
+    }
+    catch {
+        return new Set();
     }
-    return { toActivate, toInstall, upToDate };
 }

package/dist/utils/pluralize.d.ts

@@ -0,0 +1 @@
+export declare function pluralize(count: number, singular: string, plural?: string): string;

package/dist/utils/pluralize.js

@@ -0,0 +1,5 @@
+// `${pluralize(files.length, 'form')}` renders "1 form" or "3 forms"; pass an explicit
+// plural for irregular words (e.g. `pluralize(n, 'box', 'boxes')`).
+export function pluralize(count, singular, plural = `${singular}s`) {
+    return `${count} ${count === 1 ? singular : plural}`;
+}

package/dist/utils/themes.d.ts

@@ -0,0 +1,30 @@
+export type WpNativeTheme = {
+    status: 'active' | 'inactive';
+    stylesheet: string;
+    version: string;
+};
+export type InstalledTheme = {
+    active: boolean;
+    slug: string;
+    version: string;
+};
+export type ThemeManifest = Record<string, string>;
+export type ThemeDiff = {
+    collisions: Array<{
+        installedVersion: string;
+        slug: string;
+    }>;
+    inSync: string[];
+    toInstall: Array<{
+        slug: string;
+        version: string;
+    }>;
+    toPin: Array<{
+        from: string;
+        slug: string;
+        to: string;
+    }>;
+    toRemove: string[];
+};
+export declare function parseInstalledThemes(raw: WpNativeTheme[]): InstalledTheme[];
+export declare function diffThemes(manifest: ThemeManifest, installed: InstalledTheme[], managedSlugs?: Set<string>): ThemeDiff;

package/dist/utils/themes.js

@@ -0,0 +1,29 @@
+// Themes are version-managed only: Loopress never switches the active theme (that can break a
+// live site hard), so unlike plugins there is no activate / prune dimension here.
+export function parseInstalledThemes(raw) {
+    return raw.map((t) => ({ active: t.status === 'active', slug: t.stylesheet, version: t.version }));
+}
+export function diffThemes(manifest, installed, managedSlugs = new Set()) {
+    const map = new Map(installed.map((t) => [t.slug, t]));
+    const toInstall = [];
+    const toPin = [];
+    const collisions = [];
+    const inSync = [];
+    for (const [slug, wanted] of Object.entries(manifest)) {
+        const live = map.get(slug);
+        if (!live) {
+            toInstall.push({ slug, version: wanted });
+        }
+        else if (!managedSlugs.has(slug)) {
+            collisions.push({ installedVersion: live.version, slug });
+        }
+        else if (wanted !== 'latest' && live.version !== wanted) {
+            toPin.push({ from: live.version, slug, to: wanted });
+        }
+        else {
+            inSync.push(slug);
+        }
+    }
+    const toRemove = [...managedSlugs].filter((slug) => !Object.hasOwn(manifest, slug));
+    return { collisions, inSync, toInstall, toPin, toRemove };
+}

package/dist/utils/version.d.ts

@@ -0,0 +1,2 @@
+export declare function isExactVersion(value: string): boolean;
+export declare function compareVersions(a: string, b: string): null | number;

package/dist/utils/version.js

@@ -0,0 +1,21 @@
+import { compareVersions as cmp, validate } from 'compare-versions';
+// An exact version like 9.4.2 or 3.0.0-beta1, not a Composer constraint (^, ~, *, ranges,
+// ||, x-wildcards). loopress.json pins an exact version or the literal "latest"; a constraint
+// breaks the CLI's drift detection (it never string-equals the resolved version), so it is
+// rejected at `add` time. Not `compare-versions`' `validate()`: that accepts "9.4.x".
+//
+// A prerelease suffix is only allowed once there are at least 3 numeric segments
+// (major.minor.patch): compare-versions' own `validate()`, which compareVersions() below
+// defers to, rejects a suffix on a 1- or 2-segment version (e.g. "0.9-beta"). Accepting that
+// shape here would let it slip past `isExactVersion` at `add` time, then have
+// `compareVersions`/`isDowngrade` silently treat it as unorderable, bypassing the --force
+// gate on a real downgrade.
+const EXACT_VERSION = /^\d+(\.\d+){0,3}$|^\d+(\.\d+){2,3}-[0-9A-Za-z.]+$/;
+export function isExactVersion(value) {
+    return EXACT_VERSION.test(value);
+}
+// -1 / 0 / 1, or null when either side isn't a comparable version (e.g. "latest"). Wraps
+// compare-versions so callers never have to guard against the throw it does on bad input.
+export function compareVersions(a, b) {
+    return validate(a) && validate(b) ? cmp(a, b) : null;
+}