@loopress/cli 0.24.1 → 0.26.0

package/dist/utils/page-format.js

@@ -0,0 +1,111 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { basename, extname, join } from 'node:path';
+export const PAGES_ENDPOINT = 'loopress/v1/pages';
+// Mirrored server-side in PagesController. No leading, trailing or doubled hyphen: WordPress's
+// sanitize_title() would rewrite those, and the page would no longer match its file name.
+export const PAGE_SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+export const PAGE_STATUSES = ['draft', 'publish'];
+const HEADER_KEYS = ['title', 'status', 'full-width', 'hide-title', 'template'];
+function parseBoolean(key, value) {
+    if (value === undefined)
+        return false;
+    if (value !== 'true' && value !== 'false')
+        throw new Error(`"${key}" must be "true" or "false", got "${value}"`);
+    return value === 'true';
+}
+export function formatPageProblems(problems) {
+    return problems.map((problem) => `${problem.file}: ${problem.message}`).join('\n  ');
+}
+// `legal-notice` -> `Legal notice`.
+export function titleFromSlug(slug) {
+    const words = slug.split('-').filter(Boolean).join(' ');
+    return words.charAt(0).toUpperCase() + words.slice(1);
+}
+// A page file is plain HTML, optionally opened by an HTML comment of `key: value` lines:
+//
+//   <!--
+//   title: Legal notice
+//   status: publish
+//   template: page-no-title
+//   -->
+//
+// A comment rather than YAML front matter so the file stays valid HTML, previewable as is in a
+// browser. The header is stripped from what gets pushed. Throws on an unknown key or status so a
+// typo never silently falls back to a default. `template` is the active theme's own template
+// slug (a block theme's templates/<slug>.html, or a classic theme's page-<slug>.php); unlike
+// `status`, it's never validated here, an unknown slug just makes WordPress fall back to the
+// default template, the same silent no-op as `full-width`/`hide-title` on a theme that doesn't
+// support them.
+export function parsePageFile(slug, raw) {
+    const header = /^\s*<!--([\s\S]*?)-->\r?\n?/.exec(raw);
+    const meta = {};
+    if (header) {
+        for (const line of header[1].split(/\r?\n/)) {
+            if (line.trim() === '')
+                continue;
+            const colon = line.indexOf(':');
+            if (colon === -1)
+                throw new Error(`header line "${line.trim()}" is not a "key: value" pair`);
+            const key = line.slice(0, colon).trim();
+            if (!HEADER_KEYS.includes(key))
+                throw new Error(`unknown header key "${key}" (allowed: ${HEADER_KEYS.join(', ')})`);
+            meta[key] = line.slice(colon + 1).trim();
+        }
+    }
+    const status = meta.status ?? 'draft';
+    if (!PAGE_STATUSES.includes(status)) {
+        throw new Error(`status "${status}" is not one of ${PAGE_STATUSES.join(', ')}`);
+    }
+    return {
+        fullWidth: parseBoolean('full-width', meta['full-width']),
+        hideTitle: parseBoolean('hide-title', meta['hide-title']),
+        html: header ? raw.slice(header[0].length) : raw,
+        slug,
+        status: status,
+        template: meta.template ?? '',
+        title: meta.title || titleFromSlug(slug),
+    };
+}
+// Reads every page of `dir` and reports every problem at once instead of skipping bad files
+// like the other resources do: a page push is declarative, so anything unexpected in the
+// directory (a `.php`, a subdirectory, a bad header) must stop it before any network call.
+// Dotfiles (.DS_Store, editor droppings) are ignored. A missing directory is "no pages".
+export async function readLocalPages(dir) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { pages: [], problems: [] };
+        throw error;
+    }
+    const pages = [];
+    const problems = [];
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+        if (entry.name.startsWith('.'))
+            continue;
+        const filePath = join(dir, entry.name);
+        if (!entry.isFile()) {
+            problems.push({ file: filePath, message: `subdirectories are not supported, keep every page at the top of ${dir}` });
+            continue;
+        }
+        if (extname(entry.name) !== '.html') {
+            problems.push({ file: filePath, message: `only .html files are allowed in ${dir}` });
+            continue;
+        }
+        const slug = basename(entry.name, '.html');
+        if (!PAGE_SLUG_PATTERN.test(slug)) {
+            problems.push({ file: filePath, message: 'the file name must be lowercase letters and digits separated by single hyphens (e.g. "legal-notice.html")' });
+            continue;
+        }
+        try {
+            pages.push(parsePageFile(slug, await readFile(filePath, 'utf8')));
+        }
+        catch (error) {
+            problems.push({ file: filePath, message: error.message });
+        }
+    }
+    return { pages, problems };
+}

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

@@ -5,9 +5,12 @@ export declare const RESOURCE_DIR_DEFAULTS: {
     readonly apps: "apps";
     readonly form: "forms";
     readonly hooks: "hooks";
+    readonly menu: "menus";
     readonly options: "options";
+    readonly page: "pages";
     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,12 @@ export const RESOURCE_DIR_DEFAULTS = {
     apps: 'apps',
     form: 'forms',
     hooks: 'hooks',
+    menu: 'menus',
     options: 'options',
+    page: 'pages',
     seo: 'seo',
     snippets: 'snippets',
+    themeStyles: 'theme',
 };
 const CONFIG_KEY = {
     acf: 'acfDir',
@@ -17,9 +20,12 @@ const CONFIG_KEY = {
     apps: 'appsDir',
     form: 'formDir',
     hooks: 'hooksDir',
+    menu: 'menuDir',
     options: 'optionsDir',
+    page: 'pageDir',
     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 ?? {} };
+}