@loopress/cli 0.24.1 → 0.25.0

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

@@ -1,4 +1,5 @@
 export declare const ACF_OBJECT_TYPES: readonly ["field-groups", "post-types", "taxonomies", "options-pages"];
 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 getAcfKey(data: Record<string, unknown>): null | string;

package/dist/utils/acf-format.js

@@ -2,6 +2,12 @@ export const ACF_OBJECT_TYPES = ['field-groups', 'post-types', 'taxonomies', 'op
 export function acfEndpoint(type) {
     return `loopress/v1/acf/${type}`;
 }
+// GET/DELETE route for a single object by key, used by `acf push` to read the object's current
+// revision right before writing it (see acf/push.ts, #234). Create/update both go through
+// acfEndpoint() (a POST), the controller resolves create-vs-update server-side via `key`.
+export function acfObjectEndpoint(type, key) {
+    return `${acfEndpoint(type)}/${key}`;
+}
 // 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/form-format.d.ts

@@ -1,3 +1,7 @@
 export declare const FORM_ENDPOINT = "loopress/v1/forms";
+export declare function formEndpoint(id: number): string;
+export type RemoteForm = Record<string, unknown> & {
+    revision: string;
+};
 export declare function getFormId(data: Record<string, unknown>): null | number;
 export declare function getFormTitle(data: Record<string, unknown>): string;

package/dist/utils/form-format.js

@@ -1,11 +1,7 @@
 export const FORM_ENDPOINT = 'loopress/v1/forms';
-// Deliberately loose, same reasoning as getAcfKey in acf-format.ts: a form plugin's own data
-// format (WPForms today: fields, settings, notifications, confirmations, providers, meta; other
-// WordPress form plugins may be supported later, same shape as snippet-format.ts's Code
-// Snippets/WPCode split) is large, deeply nested, and versioned by whichever plugin release
-// wrote it. We only need `id` for filenames/identity and `settings.form_title` for display
-// (the field WPForms itself uses; a future provider may differ), everything else round-trips
-// through pull/push untouched.
+export function formEndpoint(id) {
+    return `${FORM_ENDPOINT}/${id}`;
+}
 export function getFormId(data) {
     const id = Number(data.id);
     return Number.isSafeInteger(id) && id > 0 ? id : null;

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

@@ -0,0 +1,24 @@
+export declare const MENU_ENDPOINT = "loopress/v1/menus";
+export declare const MENU_LOCATIONS_ENDPOINT = "loopress/v1/menu-locations";
+export declare function menuEndpoint(slug: string): string;
+export type MenuItem = {
+    children: MenuItem[];
+    classes: string[];
+    description: string;
+    object: null | string;
+    objectSlug: null | string;
+    target: string;
+    title: string;
+    type: 'custom' | 'post_type' | 'taxonomy';
+    url: null | string;
+    xfn: string;
+};
+export type Menu = {
+    items: MenuItem[];
+    name: string;
+    revision: string;
+    slug: string;
+    warnings: string[];
+};
+export type MenuLocations = Record<string, null | string>;
+export declare function getMenuSlug(data: Record<string, unknown>): null | string;

package/dist/utils/menu-format.js

@@ -0,0 +1,8 @@
+export const MENU_ENDPOINT = 'loopress/v1/menus';
+export const MENU_LOCATIONS_ENDPOINT = 'loopress/v1/menu-locations';
+export function menuEndpoint(slug) {
+    return `${MENU_ENDPOINT}/${encodeURIComponent(slug)}`;
+}
+export function getMenuSlug(data) {
+    return typeof data.slug === 'string' && data.slug.trim() !== '' ? data.slug : null;
+}

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

@@ -11,6 +11,7 @@ export type LocalOption = {
 export type RemoteOption = {
     autoload: string;
     name: string;
+    revision: string;
     value: unknown;
 };
 export type ListedOption = {

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

@@ -5,9 +5,11 @@ export declare const RESOURCE_DIR_DEFAULTS: {
     readonly apps: "apps";
     readonly form: "forms";
     readonly hooks: "hooks";
+    readonly menu: "menus";
     readonly options: "options";
     readonly seo: "seo";
     readonly snippets: "snippets";
+    readonly themeStyles: "theme";
 };
 export type ResourceDirKind = keyof typeof RESOURCE_DIR_DEFAULTS;
 export declare function resolveResourceDir(kind: ResourceDirKind, localConfig: LoopressLocalConfig, override?: string): string;

package/dist/utils/resource-dirs.js

@@ -7,9 +7,11 @@ export const RESOURCE_DIR_DEFAULTS = {
     apps: 'apps',
     form: 'forms',
     hooks: 'hooks',
+    menu: 'menus',
     options: 'options',
     seo: 'seo',
     snippets: 'snippets',
+    themeStyles: 'theme',
 };
 const CONFIG_KEY = {
     acf: 'acfDir',
@@ -17,9 +19,11 @@ const CONFIG_KEY = {
     apps: 'appsDir',
     form: 'formDir',
     hooks: 'hooksDir',
+    menu: 'menuDir',
     options: 'optionsDir',
     seo: 'seoDir',
     snippets: 'snippetsDir',
+    themeStyles: 'themeStylesDir',
 };
 // Resolves where a resource's files live: an explicit override wins, otherwise the
 // loopress.json `<kind>Dir` setting, otherwise the built-in default, all under `rootDir`.

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

@@ -3,11 +3,19 @@ export declare const SEO_SETTINGS_ENDPOINT = "loopress/v1/seo/settings";
 export declare const SEO_REDIRECTS_ENDPOINT = "loopress/v1/seo/redirects";
 export declare function seoRedirectEndpoint(id: number): string;
 export declare function seoPostMetaEndpoint(postType: string): string;
+export declare function seoPostMetaItemEndpoint(postType: string, slug: string): string;
 export type SeoPostMeta = {
     meta: Record<string, unknown>;
     slug: string;
     title: string;
 };
+export type RemoteSeoPostMeta = SeoPostMeta & {
+    revision: string;
+};
+export type RemoteSeoSettings = {
+    revision: string;
+    settings: Record<string, unknown>;
+};
 export type SeoRedirect = {
     createdAt: string | undefined;
     headerCode: number;

package/dist/utils/seo-format.js

@@ -9,6 +9,9 @@ export function seoRedirectEndpoint(id) {
 export function seoPostMetaEndpoint(postType) {
     return `loopress/v1/seo/post-meta/${postType}`;
 }
+export function seoPostMetaItemEndpoint(postType, slug) {
+    return `${seoPostMetaEndpoint(postType)}/${encodeURIComponent(slug)}`;
+}
 // The `<id>-<slug>.json` on-disk convention shared by `seo pull` and `seo push`.
 export function redirectFileBase(redirect) {
     return `${redirect.id}-${toSlug(redirect.urlTo, 'redirect')}`;

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

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

package/dist/utils/snippet-format.js

@@ -81,6 +81,7 @@ export function normalizeSnippet(data) {
         location: parseLocation(data.location) ?? defaultLocationForType(parseType(data.type) ?? 'php'),
         name: coerceString(data.name),
         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 : [],
         type: parseType(data.type) ?? 'php',

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

@@ -0,0 +1,26 @@
+import { type WpClient } from '../lib/wp-client.js';
+export declare const THEME_STYLES_FILE_SUFFIX = "-global-styles.json";
+export declare function themeStylesFileName(stylesheet: string): string;
+export declare function globalStylesEndpoint(id: number): string;
+export type WpThemeSupportInfo = {
+    _links?: Record<string, Array<{
+        href: string;
+    }>>;
+    status: 'active' | 'inactive';
+    stylesheet: string;
+    theme_supports?: Record<string, unknown>;
+};
+export declare function isBlockTheme(theme: Pick<WpThemeSupportInfo, 'theme_supports'>): boolean;
+export declare function getUserGlobalStylesId(theme: Pick<WpThemeSupportInfo, '_links'>): null | number;
+export declare function getActiveThemeGlobalStyles(wp: WpClient): Promise<{
+    id: number;
+    stylesheet: string;
+}>;
+export type GlobalStylesRecord = {
+    settings?: Record<string, unknown>;
+    styles?: Record<string, unknown>;
+};
+export declare function canonicalGlobalStyles(record: {
+    settings?: unknown;
+    styles?: unknown;
+}): Record<string, unknown>;

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

@@ -0,0 +1,55 @@
+// 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
+// out of scope here. Only block themes (Full Site Editing) have a Styles screen at all.
+export const THEME_STYLES_FILE_SUFFIX = '-global-styles.json';
+export function themeStylesFileName(stylesheet) {
+    return `${stylesheet}${THEME_STYLES_FILE_SUFFIX}`;
+}
+export function globalStylesEndpoint(id) {
+    return `wp/v2/global-styles/${id}`;
+}
+// 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
+// block templates. No Loopress-side controller is needed to detect this.
+export function isBlockTheme(theme) {
+    return theme.theme_supports?.['block-templates'] === true;
+}
+// The `wp/v2/themes` list item links to its theme's editable `wp_global_styles` post under this
+// core-defined relation rather than exposing the id as a plain field (the same relation
+// @wordpress/e2e-test-utils-playwright's `getCurrentThemeGlobalStylesPostId()` reads). The href
+// itself varies with the site's permalink structure (`?rest_route=/wp/v2/global-styles/123` vs
+// `/wp-json/wp/v2/global-styles/123`), so the id is pulled out with a regex rather than assumed
+// to be the URL's last path segment.
+const USER_GLOBAL_STYLES_REL = 'wp:user-global-styles';
+export function getUserGlobalStylesId(theme) {
+    const href = theme._links?.[USER_GLOBAL_STYLES_REL]?.[0]?.href;
+    if (!href)
+        return null;
+    const match = /\/wp\/v2\/global-styles\/(\d+)/.exec(href);
+    return match ? Number(match[1]) : null;
+}
+// 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
+// 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 themes = await wp.get('wp/v2/themes');
+    const active = themes.find((theme) => theme.status === 'active');
+    if (!active)
+        throw new Error('Could not determine the active theme on WordPress.');
+    if (!isBlockTheme(active)) {
+        throw new Error(`Global Styles sync only supports block themes (Full Site Editing). The active theme "${active.stylesheet}" is a classic theme.`);
+    }
+    const id = getUserGlobalStylesId(active);
+    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 };
+}
+// 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.
+export function canonicalGlobalStyles(record) {
+    return { settings: record.settings ?? {}, styles: record.styles ?? {} };
+}