@loopress/cli 0.32.0 → 0.32.2

package/dist/lib/diff-command.js

@@ -40,7 +40,7 @@ export class DiffCommand extends LoopressCommand {
         return {
             left: async () => provider.remote(this.wp, sides.warn, dir),
             resource: provider.resource,
-            right: sides.againstWp ? async () => provider.remote(sides.againstWp, sides.warn, dir) : async () => provider.local(dir, sides.warn),
+            right: sides.againstWp ? async () => provider.remote(sides.againstWp, sides.warn, dir) : async () => provider.local(dir, sides.warn, this.wp),
             title: provider.title,
         };
     }

package/dist/lib/push-command.js

@@ -65,7 +65,7 @@ export class PushCommand extends LoopressCommand {
             const remote = await this.previewRemote(provider, dir);
             await this.guardOutsideEdits(provider, dir, remote, writes);
             try {
-                const local = await provider.local(dir, () => { });
+                const local = await provider.local(dir, () => { }, this.wp);
                 this.previewStates = { local, remote };
                 this.previewChanges = pushChanges(local, remote, { writes });
             }
@@ -236,12 +236,19 @@ export class PushCommand extends LoopressCommand {
             const snapshot = await readSnapshot(resolve(process.cwd(), this.rootDir), provider.resource, this.siteConfig.name);
             expected = recordToState(snapshot.afterState);
             pushedAt = snapshot.createdAt;
-            local = await provider.local(dir, () => { });
         }
         catch {
-            // No earlier push from this machine, or unreadable local files the push reports itself.
+            // No earlier push from this machine.
             return;
         }
+        // Unreadable files are skipped with a warning, so a failure here is the site's (ACF's
+        // normalize route): the check can't run, and a push must not go on unchecked.
+        try {
+            local = await provider.local(dir, () => { }, this.wp);
+        }
+        catch (error) {
+            this.error(`Could not check for changes made on ${this.siteConfig.url} outside Loopress: ${error.message}. Retry, or pass --overwrite.`);
+        }
         const overwritten = [...local.keys()].filter((id) => (writes?.(id) ?? true) &&
             remote.get(id) !== undefined &&
             !sameEntry(remote, expected, id) &&

package/dist/lib/resource-state.d.ts

@@ -3,7 +3,7 @@ import { type ResourceState } from './diff-state.js';
 import { type WpClient } from './wp-client.js';
 export type ResourceStateProvider = {
     dirKind: ResourceDirKind;
-    local(dir: string, onWarn: (message: string) => void): Promise<ResourceState>;
+    local(dir: string, onWarn: (message: string) => void, wp?: WpClient): Promise<ResourceState>;
     remote(wp: WpClient, onWarn: (message: string) => void, dir: string): Promise<ResourceState>;
     resource: string;
     title: string;

package/dist/lib/resource-state.js

@@ -1,6 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import { basename, join, relative, sep } from 'node:path';
-import { ACF_OBJECT_TYPES, acfEndpoint, getAcfKey } from '../utils/acf-format.js';
+import { ACF_OBJECT_TYPES, acfEndpoint, acfNormalizeEndpoint, getAcfKey } from '../utils/acf-format.js';
 import { CPT_SPEC, fileExtension, META_SPEC, parseDeclaredFile, PATTERN_SPEC, ROLE_SPEC, TAXONOMY_SPEC, } from '../utils/declared-type-format.js';
 import { FORM_ENDPOINT, getFormId } from '../utils/form-format.js';
 import { getMenuSlug, MENU_ENDPOINT, MENU_LOCATIONS_ENDPOINT } from '../utils/menu-format.js';
@@ -115,19 +115,33 @@ const formProvider = {
 };
 // ---- ACF --------------------------------------------------------------------------------
 // ACF's export JSON is large, deeply nested, and versioned by ACF itself; `key` is the stable
-// identity and the whole object (minus the `modified` timestamp) round-trips untouched, so it
-// is all compared. Ids are namespaced by object type (`field-groups/group_x`) since keys are
-// only unique within a type.
+// identity and the whole object (minus the `modified` timestamp) is compared. Ids are
+// namespaced by object type (`field-groups/group_x`) since keys are only unique within a type.
+// The site stores every setting, defaults included, while a hand- or agent-written file holds
+// only what its author wrote: given the site, the local side is what the site would store
+// (ACF's own normalization, nothing saved), or every such file would read as drift forever.
+async function normalizeAcf(wp, type, objects) {
+    try {
+        return await wp.post(acfNormalizeEndpoint(type), { objects });
+    }
+    catch (error) {
+        // A plugin older than the route: compared as written, as before it existed.
+        if (isNotFoundError(error))
+            return objects;
+        throw error;
+    }
+}
 const acfProvider = {
     dirKind: 'acf',
-    async local(dir, onWarn) {
+    async local(dir, onWarn, wp) {
         const state = new Map();
         for (const type of ACF_OBJECT_TYPES) {
-            const objects = await loadFiles(join(dir, type), {
+            const files = await loadFiles(join(dir, type), {
                 extension: '.json',
                 onSkip: onWarn,
                 parse: readJson,
             });
+            const objects = wp && files.length > 0 ? await normalizeAcf(wp, type, files) : files;
             for (const object of objects) {
                 const key = getAcfKey(object);
                 if (key !== null)

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

@@ -2,6 +2,7 @@ export declare const ACF_OBJECT_TYPES: readonly ["field-groups", "post-types", "
 export type AcfObjectType = (typeof ACF_OBJECT_TYPES)[number];
 export declare function acfEndpoint(type: AcfObjectType): string;
 export declare function acfObjectEndpoint(type: AcfObjectType, key: string): string;
+export declare function acfNormalizeEndpoint(type: AcfObjectType): string;
 export declare function getAcfKey(data: Record<string, unknown>): null | string;
 export declare function acfFieldChanges(before: unknown, after: unknown): {
     added: string[];

package/dist/utils/acf-format.js

@@ -9,6 +9,11 @@ export function acfEndpoint(type) {
 export function acfObjectEndpoint(type, key) {
     return `${acfEndpoint(type)}/${key}`;
 }
+// POST route returning local objects the way the site would store them, defaults filled in,
+// nothing saved (see resource-state.ts's acfProvider).
+export function acfNormalizeEndpoint(type) {
+    return `loopress/v1/acf/normalize/${type}`;
+}
 // Deliberately loose: ACF's own export JSON is large, deeply nested, and versioned by ACF
 // itself (new settings appear across ACF releases). We only need `key` for filenames/identity;
 // everything else round-trips through pull/push untouched, so there's no generated type for it

package/dist/utils/php-top-level.js

@@ -34,10 +34,8 @@ export function startsWithStrictTypes(content) {
 // Advances the brace depth and "a statement starts here" flag past one token; returns the token
 // when it starts a top-level statement that isn't a declaration.
 function step(state, token) {
-    if (token.type === 'html') {
-        state.atStart = true;
-        return token.text === '' ? null : 'inline HTML after ?>';
-    }
+    if (token.type === 'html')
+        return inlineHtml(state, token);
     const statementStart = state.depth === 0 && state.atStart;
     switch (token.text) {
         case ';': {
@@ -66,6 +64,13 @@ function step(state, token) {
         }
     }
 }
+// A template inside a class or function body (`?> <p>...</p> <?php`) only runs when it is called.
+function inlineHtml(state, token) {
+    if (state.depth > 0)
+        return null;
+    state.atStart = true;
+    return token.text === '' ? null : 'inline HTML after ?>';
+}
 function openBrace(state, statementStart) {
     if (state.namespaceHeader) {
         state.namespaceHeader = false;

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

@@ -78,6 +78,34 @@ export async function getActiveThemeGlobalStyles(wp) {
 // 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
 // id for the same content), so they're dropped rather than becoming spurious drift.
+// WordPress also rewrites two things on save, so both sides take its stored form, or a file
+// pushed as is would read as drift right after its push:
+// - a preset list (`palette: [...]`) is keyed by its origin, `palette: {custom: [...]}`, and
+// - a `var:preset|color|base` reference becomes `var(--wp--preset--color--base)`.
 export function canonicalGlobalStyles(record) {
-    return { settings: record.settings ?? {}, styles: record.styles ?? {} };
+    return { settings: expandVarReferences(unwrapPresets(record.settings ?? {})), styles: expandVarReferences(record.styles ?? {}) };
+}
+const PRESET_KEYS = new Set(['aspectRatios', 'duotone', 'fontFamilies', 'fontSizes', 'gradients', 'palette', 'presets', 'radiusSizes', 'spacingSizes']);
+function unwrapPresets(value) {
+    if (typeof value !== 'object' || value === null)
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => unwrapPresets(item));
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => {
+        const custom = PRESET_KEYS.has(key) && isOnlyCustom(item) ? item.custom : item;
+        return [key, unwrapPresets(custom)];
+    }));
+}
+function isOnlyCustom(value) {
+    return typeof value === 'object' && value !== null && Object.keys(value).length === 1 && Array.isArray(value.custom);
+}
+// WP_Theme_JSON::convert_custom_properties()'s rule.
+function expandVarReferences(value) {
+    if (typeof value === 'string')
+        return value.startsWith('var:') ? `var(--wp--${value.slice(4).replaceAll('|', '--')})` : value;
+    if (typeof value !== 'object' || value === null)
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => expandVarReferences(item));
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, expandVarReferences(item)]));
 }