@loopress/cli 0.32.2 → 0.33.0

package/dist/utils/plugin-sync.d.ts

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 export declare const SYNC_TIMEOUT_MS = 600000;
 export type SyncIntent = {
     libraries?: Record<string, string>;
@@ -20,13 +21,12 @@ export type SyncResponse = {
     lockDrift?: LockDriftEntry[];
     message: string;
     output: string;
-    removed: string[];
-};
-export type Collision = {
-    installedVersion: string;
-    path: string;
-    slug: string;
-    type: 'plugin' | 'theme';
+    removed?: string[];
 };
+declare const COLLISIONS: z.ZodArray<z.ZodObject<{
+    slug: z.ZodString;
+}, z.core.$loose>>;
+export type Collision = z.infer<typeof COLLISIONS>[number];
 export declare function parseCollisions(error: unknown): Collision[] | null;
 export declare function isDowngrade(from: string, to: string): boolean;
+export {};

package/dist/utils/plugin-sync.js

@@ -2,26 +2,26 @@
 // `lps plugin push`, `lps theme version push` and `lps composer push`. The endpoint runs Composer +
 // WPackagist inside WordPress; the CLI only ever sends intent (which slugs at which versions),
 // never a composer.json, so the plugin stays the single authority on that file's shape.
+import { z } from 'zod';
+import { causeOf } from '../lib/narrow.js';
+import { parseBody, responseOf } from '../lib/wp-client.js';
 import { compareVersions } from './version.js';
 // A cold `composer update` on a fresh site easily exceeds the global 30s WpClient timeout.
 export const SYNC_TIMEOUT_MS = 600_000;
+// The server also sends installedVersion, path and type, only the slug is read here.
+const COLLISIONS = z.array(z.looseObject({ slug: z.string() }));
 // 422 from the sync endpoint when the intent references a plugin/theme whose folder already
 // exists on the site but isn't tracked in composer.lock (installed by hand through wp-admin).
 // Re-running with --force lets the server remove the folder so Composer can take it over.
 export function parseCollisions(error) {
-    const body = error.cause?.response;
-    if (body?.statusCode !== 422 || !body.body)
+    const { body, statusCode } = responseOf(causeOf(error));
+    if (statusCode !== 422)
         return null;
-    try {
-        const parsed = JSON.parse(body.body);
-        if (parsed.error === 'unmanaged_plugins_present' && Array.isArray(parsed.collisions)) {
-            return parsed.collisions;
-        }
-    }
-    catch {
+    const parsed = parseBody(body);
+    if (parsed.error !== 'unmanaged_plugins_present')
         return null;
-    }
-    return null;
+    const collisions = COLLISIONS.safeParse(parsed.collisions);
+    return collisions.success ? collisions.data : null;
 }
 // Only gates whether a version change needs --force. Unorderable inputs ("latest", a
 // constraint) count as "not a downgrade" so they don't block the push.

package/dist/utils/plugins.js

@@ -1,3 +1,4 @@
+import { isRecord } from '../lib/narrow.js';
 import { pinActive, pinVersion, } from '../types/plugin.js';
 import { isExactVersion } from './version.js';
 // "1.7.2", or "1.7.2 (inactive)" for a pin that keeps the plugin inactive.
@@ -13,9 +14,10 @@ const LOOPRESS_PLUGIN_SLUGS = new Set(['loopress', 'loopress-full', 'loopress-li
 export function mergePluginManifest(existing, incoming) {
     const merged = { ...existing, ...incoming };
     const added = Object.keys(incoming).filter((s) => !Object.hasOwn(existing, s));
-    const updated = Object.keys(incoming)
-        .filter((s) => Object.hasOwn(existing, s) && describePin(existing[s]) !== describePin(incoming[s]))
-        .map((s) => ({ from: describePin(existing[s]), slug: s, to: describePin(incoming[s]) }));
+    const updated = Object.entries(incoming).flatMap(([slug, pin]) => {
+        const before = Object.hasOwn(existing, slug) ? existing[slug] : undefined;
+        return before !== undefined && describePin(before) !== describePin(pin) ? [{ from: describePin(before), slug, to: describePin(pin) }] : [];
+    });
     return { added, merged, updated };
 }
 // WordPress core identifies each plugin by a `<folder>/<file>` id (or a bare `<file>` for a
@@ -30,7 +32,7 @@ export function mergePluginManifest(existing, incoming) {
 const WP_ORG_PLUGIN_URI = /^https?:\/\/wordpress\.org\/plugins\/([^/]+)\/?$/;
 function slugFromPluginFile(file, pluginUri) {
     if (file.includes('/'))
-        return file.split('/', 1)[0];
+        return file.slice(0, file.indexOf('/'));
     return WP_ORG_PLUGIN_URI.exec(pluginUri)?.[1] ?? file;
 }
 export function parseInstalledPlugins(raw) {
@@ -93,8 +95,9 @@ export function lockedWpackagistSlugs(composerLock, kind) {
     const prefix = `wpackagist-${kind}/`;
     try {
         const parsed = JSON.parse(composerLock);
-        return new Set((parsed.packages ?? [])
-            .map((p) => p.name ?? '')
+        const packages = isRecord(parsed) && Array.isArray(parsed.packages) ? parsed.packages : [];
+        return new Set(packages
+            .map((p) => (isRecord(p) && typeof p.name === 'string' ? p.name : ''))
             .filter((name) => name.startsWith(prefix))
             .map((name) => name.slice(prefix.length)));
     }

package/dist/utils/resource-dirs.d.ts

@@ -3,6 +3,7 @@ export declare const RESOURCE_DIR_DEFAULTS: {
     readonly acf: "acf";
     readonly api: "api";
     readonly apps: "apps";
+    readonly block: "blocks";
     readonly blockCss: "theme/blocks";
     readonly cpt: "cpt";
     readonly css: "theme/css";
@@ -23,3 +24,4 @@ export declare const RESOURCE_DIR_DEFAULTS: {
 export type ResourceDirKind = keyof typeof RESOURCE_DIR_DEFAULTS;
 export declare function resolveResourceDir(kind: ResourceDirKind, localConfig: LoopressLocalConfig, override?: string): string;
 export declare function projectUses(kind: ResourceDirKind, localConfig: LoopressLocalConfig): boolean;
+export declare function projectHasChildThemeFiles(localConfig: LoopressLocalConfig): boolean;

package/dist/utils/resource-dirs.js

@@ -1,11 +1,13 @@
 import { existsSync } from 'node:fs';
 import { join, resolve } from 'node:path';
+import {} from './loopress-config.js';
 // The default subdirectory for each file-backed resource, relative to rootDir. Used whenever
 // loopress.json has no `<kind>Dir` key, which is the case for a fresh `lps init`.
 export const RESOURCE_DIR_DEFAULTS = {
     acf: 'acf',
     api: 'api',
     apps: 'apps',
+    block: 'blocks',
     blockCss: 'theme/blocks',
     cpt: 'cpt',
     css: 'theme/css',
@@ -27,6 +29,7 @@ const CONFIG_KEY = {
     acf: 'acfDir',
     api: 'apiDir',
     apps: 'appsDir',
+    block: 'blockDir',
     blockCss: 'blockCssDir',
     cpt: 'cptDir',
     css: 'cssDir',
@@ -53,10 +56,15 @@ export function resolveResourceDir(kind, localConfig, override) {
         return override;
     const rootDir = localConfig.rootDir ?? '.';
     const configured = localConfig[CONFIG_KEY[kind]];
-    return join(rootDir, configured ?? RESOURCE_DIR_DEFAULTS[kind]);
+    return join(rootDir, typeof configured === 'string' ? configured : RESOURCE_DIR_DEFAULTS[kind]);
 }
 // Whether the project uses a resource at all: its directory exists. What the aggregate `lps push`,
 // `lps pull` and `lps diff` go by for a resource backed by a plugin the site may not have.
 export function projectUses(kind, localConfig) {
     return existsSync(resolve(resolveResourceDir(kind, localConfig)));
 }
+// The project has files for the Loopress child theme to hold: templates, parts or CSS. Without
+// them the child would be empty, activateChildTheme or not: `lps theme activate` covers that.
+export function projectHasChildThemeFiles(localConfig) {
+    return ['template', 'part', 'css', 'blockCss'].some((kind) => projectUses(kind, localConfig));
+}

package/dist/utils/snippet-format.d.ts

@@ -11,7 +11,7 @@ export type NormalizedSnippet = {
     location: SnippetLocation;
     name: string;
     priority: number;
-    revision?: string;
+    revision?: string | undefined;
     shortcodeAttributes: string[];
     tags: string[];
     type: SnippetType;

package/dist/utils/snippet-format.js

@@ -1,3 +1,5 @@
+import { isOneOf } from '../lib/narrow.js';
+import {} from '../types/snippet.generated.js';
 export const SNIPPETS_ENDPOINT = 'loopress/v1/snippets';
 // Coerces server JSON that should be a string but, being unknown, could in principle be an
 // object; a plain String() on that would print "[object Object]" instead of falling back.
@@ -7,12 +9,12 @@ function coerceString(value, fallback = '') {
 export function parseType(raw) {
     const valid = ['css', 'html', 'js', 'php', 'text'];
     const value = coerceString(raw).toLowerCase();
-    return valid.includes(value) ? value : null;
+    return isOneOf(valid, value) ? value : null;
 }
 const VALID_LOCATIONS = new Set(['admin', 'body', 'everywhere', 'footer', 'frontend', 'header', 'once']);
 export function parseLocation(raw) {
     const value = coerceString(raw).toLowerCase();
-    return VALID_LOCATIONS.has(value) ? value : null;
+    return isOneOf(VALID_LOCATIONS, value) ? value : null;
 }
 export function parseInsertMethod(raw) {
     return raw === 'auto' || raw === 'shortcode' ? raw : null;
@@ -83,7 +85,7 @@ export function normalizeSnippet(data) {
         priority: resolvePriority(data.priority),
         revision: typeof data.revision === 'string' ? data.revision : undefined,
         shortcodeAttributes: Array.isArray(data.shortcodeAttributes) ? data.shortcodeAttributes.map(String) : [],
-        tags: Array.isArray(data.tags) ? data.tags : [],
+        tags: Array.isArray(data.tags) ? data.tags.map(String) : [],
         type: parseType(data.type) ?? 'php',
     };
 }

package/dist/utils/template-format.js

@@ -32,8 +32,8 @@ export function parseTemplateFile(slug, raw) {
 // `area` defaults from the name, the way themes name their parts: header, header-large-title...
 export function parsePartFile(slug, raw) {
     const { body, meta } = parseFile(raw, ['title', 'area']);
-    const nameArea = /^(header|footer)(-|$)/.exec(slug)?.[1] ?? 'uncategorized';
-    return { area: meta.area || nameArea, html: body, slug, title: meta.title || titleFromSlug(slug) };
+    const nameArea = /^(header|footer)(?:-|$)/.exec(slug)?.[1] ?? 'uncategorized';
+    return { area: (meta.area ?? '') || nameArea, html: body, slug, title: (meta.title ?? '') || titleFromSlug(slug) };
 }
 // Same directory rules as pages/ (flat, `.html` only), with template slugs, every problem at once.
 export async function readLocalTemplates(templatesDir, partsDir) {

package/dist/utils/theme-css.js

@@ -3,6 +3,9 @@ import { Buffer } from 'node:buffer';
 import { existsSync } from 'node:fs';
 import { readdir } from 'node:fs/promises';
 import { extname, join, relative, resolve, sep } from 'node:path';
+import { z } from 'zod';
+import { errorCode } from '../lib/narrow.js';
+import {} from './page-format.js';
 // The global stylesheet's entry: it @imports the rest of theme/css/ in cascade order.
 export const STYLE_ENTRY = 'style.css';
 // WordPress's own block name rule (register_block_type): lowercase letters, digits and dashes,
@@ -18,7 +21,7 @@ async function listFiles(dir) {
             .toSorted((a, b) => a.localeCompare(b));
     }
     catch (error) {
-        if (error.code === 'ENOENT')
+        if (errorCode(error) === 'ENOENT')
             return [];
         throw error;
     }
@@ -27,8 +30,9 @@ async function readBlockEntries(blocksDir, problems) {
     const entries = [];
     for (const file of await listFiles(blocksDir)) {
         const segments = relative(blocksDir, file).split(sep);
-        const [namespace, block] = [segments[0], segments[1]?.replace(/\.css$/, '')];
-        if (segments.length !== 2 || extname(file) !== '.css' || !BLOCK_SEGMENT.test(namespace) || !BLOCK_SEGMENT.test(block)) {
+        const [namespace, fileName] = segments;
+        const block = fileName?.replace(/\.css$/, '');
+        if (namespace === undefined || block === undefined || segments.length !== 2 || extname(file) !== '.css' || !BLOCK_SEGMENT.test(namespace) || !BLOCK_SEGMENT.test(block)) {
             problems.push({ file, message: `must be <namespace>/<block>.css, named after a block (e.g. ${join(blocksDir, 'core', 'button.css')})` });
             continue;
         }
@@ -36,11 +40,15 @@ async function readBlockEntries(blocksDir, problems) {
     }
     return entries;
 }
+const BUILD_LOCATION = z.object({ file: z.string(), line: z.number() });
+const BUILD_MESSAGE = z.object({ location: BUILD_LOCATION.nullable(), text: z.string() });
+const BUILD_FAILURE = z.object({ errors: z.array(BUILD_MESSAGE) });
 function buildProblems(error) {
-    const { errors } = error;
-    if (!Array.isArray(errors))
+    // esbuild's BuildFailure, the only part of it read here. Anything else is not a CSS problem.
+    const failure = BUILD_FAILURE.safeParse(error);
+    if (!failure.success)
         throw error;
-    return errors.map((message) => ({
+    return failure.data.errors.map((message) => ({
         file: message.location ? `${message.location.file}:${message.location.line}` : 'esbuild',
         message: message.text,
     }));

package/dist/utils/theme-styles-format.d.ts

@@ -8,8 +8,11 @@ export type WpThemeSupportInfo = {
     }>>;
     status: 'active' | 'inactive';
     stylesheet: string;
+    template?: string;
     theme_supports?: Record<string, unknown>;
 };
+export declare const CHILD_THEME_SUFFIX = "-loopress";
+export declare function projectStylesheet(theme: Pick<WpThemeSupportInfo, 'stylesheet' | 'template'>): string;
 export declare function isBlockTheme(theme: Pick<WpThemeSupportInfo, 'theme_supports'>): boolean;
 export declare function getUserGlobalStylesId(theme: Pick<WpThemeSupportInfo, '_links'>): null | number;
 export declare function globalStylesFiles(dir: string): Promise<string[]>;

package/dist/utils/theme-styles-format.js

@@ -1,5 +1,6 @@
 import { resolve } from 'node:path';
 import { readdirTolerant } from '../lib/readdir-tolerant.js';
+import {} from '../lib/wp-client.js';
 // Global Styles are the user's customizations from the Site Editor's "Styles" screen (colors,
 // typography, spacing), stored by WordPress core in a `wp_global_styles` post, one per theme.
 // This is separate from the theme's own theme.json file, which lives in the theme's repo and is
@@ -11,6 +12,15 @@ export function themeStylesFileName(stylesheet) {
 export function globalStylesEndpoint(id) {
     return `wp/v2/global-styles/${id}`;
 }
+// Appended to the parent's stylesheet by the plugin's ChildThemeController.
+export const CHILD_THEME_SUFFIX = '-loopress';
+// The stylesheet a project's Global Styles file is named after: the parent's when the Loopress
+// child is active, so the tracked file stays the same whether or not the child was activated
+// (the plugin copies the parent's Global Styles into the child when activating it).
+export function projectStylesheet(theme) {
+    const { stylesheet, template } = theme;
+    return template && stylesheet === `${template}${CHILD_THEME_SUFFIX}` ? template : stylesheet;
+}
 // WordPress core surfaces `wp_is_block_theme()` over the `wp/v2/themes` REST response as
 // `theme_supports['block-templates']` (see `_add_default_theme_supports()` in
 // wp-includes/theme.php): core adds that feature flag itself exactly when the theme has its own
@@ -56,13 +66,13 @@ export async function globalStylesSkipNote(wp, dir, action) {
     const active = await getActiveTheme(wp);
     if (!isBlockTheme(active))
         return `the active theme "${active.stylesheet}" is a classic theme, skipped`;
-    if (action === 'push' && !files.includes(themeStylesFileName(active.stylesheet))) {
-        return `no file for the active theme "${active.stylesheet}", skipped`;
+    if (action === 'push' && !files.includes(themeStylesFileName(projectStylesheet(active)))) {
+        return `no file for the active theme "${projectStylesheet(active)}", skipped`;
     }
     return undefined;
 }
-// Resolves the active theme's stylesheet slug and the id of its editable Global Styles post in
-// one call, failing clearly (rather than with a raw REST error later) when the active theme
+// Resolves the active theme's stylesheet slug, as the project names it (see projectStylesheet),
+// and the id of its editable Global Styles post in one call, failing clearly (rather than with a raw REST error later) when the active theme
 // isn't a block theme: classic themes have no Styles screen and no `wp_global_styles` post at all.
 export async function getActiveThemeGlobalStyles(wp) {
     const active = await getActiveTheme(wp);
@@ -73,7 +83,7 @@ export async function getActiveThemeGlobalStyles(wp) {
     if (id === null) {
         throw new Error(`Could not resolve the editable Global Styles post for "${active.stylesheet}". Requires an admin-capable account (edit_theme_options) on WordPress 5.9+.`);
     }
-    return { id, stylesheet: active.stylesheet };
+    return { id, stylesheet: projectStylesheet(active) };
 }
 // The compared/stored value: `settings` and `styles` only. `id` and `_links` are WordPress
 // bookkeeping, not part of the tracked configuration (a fresh install resolves to a different

package/dist/utils/version.js

@@ -10,7 +10,7 @@ import { compareVersions as cmp, validate } from 'compare-versions';
 // 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.]+$/;
+const EXACT_VERSION = /^\d+(?:\.\d+){0,3}$|^\d+(?:\.\d+){2,3}-[\d.a-z]+$/i;
 export function isExactVersion(value) {
     return EXACT_VERSION.test(value);
 }