@loopress/cli 0.33.0 → 0.34.0

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

@@ -0,0 +1,9 @@
+import { Flags } from '@oclif/core';
+export declare const RESOURCE_IDS: readonly ["plugin", "composer", "cpt", "taxonomy", "meta", "role", "acf", "api", "hook", "block", "form", "pattern", "template", "part", "css", "theme-style", "page", "menu", "option", "snippet"];
+export type ResourceId = (typeof RESOURCE_IDS)[number];
+export declare function selectionFlags(noun: string, valid: readonly string[]): {
+    only: ReturnType<typeof Flags.string>;
+    skip: ReturnType<typeof Flags.string>;
+};
+export declare function parseSelectionFlag(raw: string[] | undefined, flagName: 'only' | 'skip', valid: readonly string[], fail: (message: string) => never): string[];
+export declare function selectResources<T extends string>(all: readonly T[], only?: readonly string[], skip?: readonly string[]): T[];

package/dist/lib/resource-selection.js

@@ -0,0 +1,49 @@
+import { Flags } from '@oclif/core';
+// One singular id per resource, shared by every command taking `--only` / `--skip`
+// (`lps dev`, `lps diff`, `lps push`). Each command accepts the subset it can act on.
+export const RESOURCE_IDS = [
+    'plugin',
+    'composer',
+    'cpt',
+    'taxonomy',
+    'meta',
+    'role',
+    'acf',
+    'api',
+    'hook',
+    'block',
+    'form',
+    'pattern',
+    'template',
+    'part',
+    'css',
+    'theme-style',
+    'page',
+    'menu',
+    'option',
+    'snippet',
+];
+// Comma-separated or repeated: `--only a,b`, `--only a --only b`, or both.
+export function selectionFlags(noun, valid) {
+    return {
+        only: Flags.string({ description: `Only ${noun} these resources (comma-separated or repeated): ${valid.join(', ')}`, multiple: true }),
+        skip: Flags.string({ description: `${noun.charAt(0).toUpperCase()}${noun.slice(1)} every resource except these (comma-separated or repeated)`, multiple: true }),
+    };
+}
+// Splits the raw flag values and rejects any id outside `valid`.
+export function parseSelectionFlag(raw, flagName, valid, fail) {
+    return (raw ?? [])
+        .flatMap((value) => value.split(','))
+        .map((value) => value.trim())
+        .filter(Boolean)
+        .map((value) => {
+        if (!valid.includes(value))
+            fail(`Unknown resource "${value}" in --${flagName}. Valid resources: ${valid.join(', ')}`);
+        return value;
+    });
+}
+// `only` narrows `all`, `skip` then removes from whatever that is, so a combined
+// `--only=a,b --skip=b` reads as: a, b, then drop b. The result always follows `all`'s order.
+export function selectResources(all, only = [], skip = []) {
+    return all.filter((id) => (only.length === 0 || only.includes(id)) && !skip.includes(id));
+}

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

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

package/dist/lib/resource-state.js

@@ -1,7 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { basename, join, relative, sep } from 'node:path';
 import { ACF_OBJECT_TYPES, acfEndpoint, acfNormalizeEndpoint, getAcfKey } from '../utils/acf-format.js';
-import { BLOCKS_ENDPOINT, formatBlockProblems, readLocalBlocks } from '../utils/block-format.js';
+import { blockFilesToPush, BLOCKS_ENDPOINT, excludedBlockFiles, formatBlockProblems, readLocalBlocks } from '../utils/block-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';
@@ -91,6 +91,7 @@ const snippetProvider = {
 // stance as form-format.ts.
 const formProvider = {
     dirKind: 'form',
+    fileExtension: '.json',
     async local(dir, onWarn) {
         const entries = await loadFiles(dir, {
             extension: '.json',
@@ -137,6 +138,7 @@ async function normalizeAcf(wp, type, objects) {
 }
 const acfProvider = {
     dirKind: 'acf',
+    fileExtension: '.json',
     async local(dir, onWarn, wp) {
         const state = new Map();
         for (const type of ACF_OBJECT_TYPES) {
@@ -182,6 +184,7 @@ function filesToState(files) {
 function phpFilesProvider(spec) {
     return {
         dirKind: spec.dirKind,
+        fileExtension: '.php',
         async local(dir, onWarn) {
             return filesToState(await loadFiles(dir, {
                 extension: '.php',
@@ -217,11 +220,17 @@ const hookProvider = phpFilesProvider({
 // resource, the same stance as pages: pushing would stop on it anyway.
 const blockProvider = {
     dirKind: 'block',
-    async local(dir) {
+    // A block is a folder: only the bare `blocks/<slug>` path names a site-only block.
+    fileExtension: '',
+    // A file the environment excludes inside a block folder keeps the site's copy, as the push
+    // sends it back: without `wp`, that file is just left out.
+    async local(dir, _onWarn, wp) {
         const { blocks, problems } = await readLocalBlocks(dir);
         if (problems.length > 0)
             throw new Error(formatBlockProblems(problems));
-        return new Map(blocks.map((block) => [block.slug, block.files]));
+        const withExcluded = wp !== undefined && blocks.some((block) => excludedBlockFiles(dir, block.slug).length > 0);
+        const site = withExcluded ? new Map((await wp.get(BLOCKS_ENDPOINT)).map((block) => [block.slug, block.files])) : undefined;
+        return new Map(blocks.map((block) => [block.slug, site ? blockFilesToPush(dir, block, site.get(block.slug)) : block.files]));
     },
     async remote(wp) {
         const blocks = await wp.get(BLOCKS_ENDPOINT);
@@ -271,6 +280,7 @@ async function childThemeState(wp, kind) {
 }
 const templateProvider = {
     dirKind: 'template',
+    fileExtension: '.html',
     async local(dir) {
         const { files, problems } = await readLocalHtmlFiles(dir, parseTemplateFile, TEMPLATE_SLUG_RULE);
         if (problems.length > 0)
@@ -283,6 +293,7 @@ const templateProvider = {
 };
 const partProvider = {
     dirKind: 'part',
+    fileExtension: '.html',
     async local(dir) {
         const { files, problems } = await readLocalHtmlFiles(dir, parsePartFile, TEMPLATE_SLUG_RULE);
         if (problems.length > 0)
@@ -311,6 +322,12 @@ function canonicalMenu(menu) {
 }
 const menuProvider = {
     dirKind: 'menu',
+    fileExtension: '.json',
+    fileName(id) {
+        if (id === MENU_LOCATIONS_FILE)
+            return `${id}.json`;
+        return id.startsWith('menu/') ? `${id.slice('menu/'.length)}.json` : undefined;
+    },
     async local(dir, onWarn) {
         const state = new Map();
         const entries = await loadFiles(dir, {
@@ -348,6 +365,7 @@ const menuProvider = {
 function declaredTypeProvider(spec, title) {
     return {
         dirKind: spec.dirKind,
+        fileExtension: fileExtension(spec),
         async local(dir, onWarn) {
             const entries = await loadFiles(dir, {
                 extension: fileExtension(spec),
@@ -377,6 +395,7 @@ const patternProvider = declaredTypeProvider(PATTERN_SPEC, 'Patterns');
 // sides so it can never itself show up as drift.
 const optionsProvider = {
     dirKind: 'options',
+    fileExtension: '.json',
     async local(dir, onWarn) {
         const entries = await loadFiles(dir, {
             extension: '.json',
@@ -422,6 +441,8 @@ const optionsProvider = {
 // individually rather than colliding on a single key.
 const themeStylesProvider = {
     dirKind: 'themeStyles',
+    fileExtension: '.json',
+    fileName: (stylesheet) => `${stylesheet}${THEME_STYLES_FILE_SUFFIX}`,
     async local(dir, onWarn) {
         const entries = await loadFiles(dir, {
             extension: '.json',
@@ -445,7 +466,7 @@ const themeStylesProvider = {
         const item = await wp.get(globalStylesEndpoint(id));
         return new Map([[stylesheet, canonicalGlobalStyles(item)]]);
     },
-    resource: 'theme-styles',
+    resource: 'theme-style',
     title: 'Theme styles',
 };
 export const RESOURCE_STATE_PROVIDERS = [

package/dist/lib/rollback-command.js

@@ -34,7 +34,7 @@ function indentPatch(patch) {
 // anything, this runs the equivalent of `lps <resource> diff` between the environment's current
 // state and the state the original push expected to leave behind, and requires explicit
 // confirmation (the same interactive/`--yes` shape as guardProductionPush) when they differ.
-// `command` is the CLI topic when it isn't the resource key (e.g. `theme style` for theme-styles).
+// `command` is the CLI topic when it isn't the resource key (e.g. `theme style` for theme-style).
 export function resourceRollbackCommand(resource, options) {
     const command = options.command ?? resource;
     class ResourceRollback extends LoopressCommand {

package/dist/lib/rollback-materialize.js

@@ -115,7 +115,7 @@ const MATERIALIZERS = {
     role: declaredType(ROLE_SPEC),
     snippet,
     taxonomy: declaredType(TAXONOMY_SPEC),
-    'theme-styles': themeStyles,
+    'theme-style': themeStyles,
 };
 // Writes a snapshot's state back to `dir` in the exact on-disk layout `<resource> pull` would
 // have produced, so the existing `<resource> push` command can push it unmodified: a rollback

package/dist/lib/validate-local.d.ts

@@ -6,5 +6,6 @@ export type ValidateResult = {
     checked: number;
     problems: Problem[];
     valid: boolean;
+    warnings: Problem[];
 };
 export declare function validateLocal(cwd: string): Promise<ValidateResult>;

package/dist/lib/validate-local.js

@@ -1,4 +1,4 @@
-import { readFile } from 'node:fs/promises';
+import { readdir, readFile } from 'node:fs/promises';
 import { join, relative, sep } from 'node:path';
 import { z } from 'zod';
 import { configManager } from '../config/project-config.manager.js';
@@ -11,23 +11,24 @@ import { readLocalHtmlFiles, readLocalPages } from '../utils/page-format.js';
 import { RESOURCE_DIR_DEFAULTS } from '../utils/resource-dirs.js';
 import { parseType } from '../utils/snippet-format.js';
 import { readLocalTemplates } from '../utils/template-format.js';
+import { globToRegExp, matchesAny } from './exclude.js';
 import { loadSnippets } from './load-snippets.js';
 import { errorCode, errorMessage, isRecord } from './narrow.js';
 import { API_FILES_RESOURCE, HOOK_FILES_RESOURCE, phpFileProblems } from './php-files-command.js';
 import { readdirTolerant } from './readdir-tolerant.js';
 // Directories holding one JSON document per resource. Snippets (code file plus JSON sidecar)
 // and api routes (`.php`, not JSON) are checked separately, options too (a stricter shape).
-const JSON_RESOURCE_DIRS = ['acfDir', 'formDir', 'menuDir', 'themeStylesDir'];
+const JSON_RESOURCE_DIRS = ['acfDir', 'formDir', 'menuDir', 'themeStyleDir'];
 const DEFAULT_DIR = {
     acfDir: 'acf',
     apiDir: 'api',
     blockDir: RESOURCE_DIR_DEFAULTS.block,
     cptDir: 'cpt',
     formDir: 'forms',
-    hooksDir: 'hooks',
+    hookDir: 'hooks',
     menuDir: 'menus',
     metaDir: 'meta',
-    optionsDir: 'options',
+    optionDir: 'options',
     pageDir: 'pages',
     partDir: RESOURCE_DIR_DEFAULTS.part,
     patternDir: RESOURCE_DIR_DEFAULTS.pattern,
@@ -35,7 +36,7 @@ const DEFAULT_DIR = {
     snippetsDir: 'snippets',
     taxonomyDir: 'taxonomies',
     templateDir: RESOURCE_DIR_DEFAULTS.template,
-    themeStylesDir: 'theme',
+    themeStyleDir: 'theme',
 };
 // Inspects the local tracked files under `cwd` without contacting WordPress: JSON files parse
 // and have the right shape, snippet sidecars use a known type, `loopress.json` points at a
@@ -58,7 +59,7 @@ export async function validateLocal(cwd) {
     }
     // Same reader `option push` uses: a file missing "name", "autoload" or "value" is skipped
     // there with a warning, so it's a problem here.
-    checked += await checkJsonDir(resolve('optionsDir'), problems, parseLocalOption);
+    checked += await checkJsonDir(resolve('optionDir'), problems, parseLocalOption);
     checked += await checkJsonDir(resolve('cptDir'), problems, declaredFileChecker(CPT_SPEC));
     checked += await checkJsonDir(resolve('taxonomyDir'), problems, declaredFileChecker(TAXONOMY_SPEC));
     checked += await checkJsonDir(resolve('metaDir'), problems, declaredFileChecker(META_SPEC));
@@ -66,7 +67,7 @@ export async function validateLocal(cwd) {
     checked += await checkPatterns(resolve('patternDir'), problems);
     checked += await checkSnippets(resolve('snippetsDir'), problems);
     checked += await checkPhpDir(resolve('apiDir'), problems, 'API route file is empty', API_FILES_RESOURCE);
-    checked += await checkPhpDir(resolve('hooksDir'), problems, 'Hook file is empty', HOOK_FILES_RESOURCE);
+    checked += await checkPhpDir(resolve('hookDir'), problems, 'Hook file is empty', HOOK_FILES_RESOURCE);
     const blocks = await readLocalBlocks(resolve('blockDir'));
     checked += blocks.blocks.length;
     problems.push(...blocks.problems);
@@ -76,7 +77,65 @@ export async function validateLocal(cwd) {
     const templates = await readLocalTemplates(resolve('templateDir'), resolve('partDir'));
     checked += templates.templates.length + templates.parts.length + templates.problems.length;
     problems.push(...templates.problems);
-    return { checked, problems, valid: problems.length === 0 };
+    const warnings = await checkExcludes(localConfig, join(cwd, rootDir), problems);
+    return { checked, problems, valid: problems.length === 0, warnings };
+}
+// `environments.<name>.exclude` (lib/exclude.ts): a list of globs per environment. A glob that
+// matches no file is a warning, not a problem: likely a typo or a renamed file, so the feature it
+// was meant to hold back would reach that environment.
+async function checkExcludes(localConfig, root, problems) {
+    const { environments } = localConfig;
+    if (environments === undefined)
+        return [];
+    if (!isRecord(environments) || Array.isArray(environments)) {
+        problems.push({ file: 'loopress.json', message: '"environments" must be an object of environment name -> settings' });
+        return [];
+    }
+    const warnings = [];
+    let files;
+    for (const [name, settings] of Object.entries(environments)) {
+        const parsed = ENVIRONMENT_SETTINGS.safeParse(settings);
+        if (!parsed.success) {
+            problems.push({ file: 'loopress.json', message: `environments.${name} must be an object with an optional "exclude" list of glob strings` });
+            continue;
+        }
+        for (const pattern of parsed.data.exclude ?? []) {
+            files ??= await projectFiles(root);
+            const matcher = globToRegExp(pattern);
+            if (files.every((segments) => !matchesAny([matcher], segments))) {
+                warnings.push({ file: 'loopress.json', message: `environments.${name}.exclude: "${pattern}" matches no file` });
+            }
+        }
+    }
+    return warnings;
+}
+const ENVIRONMENT_SETTINGS = z.strictObject({ exclude: z.array(z.string()).optional() });
+// Every file under `root` as '/'-split segments, without node_modules and .git.
+async function projectFiles(root) {
+    const files = [];
+    const walk = async (dir) => {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch (error) {
+            if (errorCode(error) === 'ENOENT')
+                return;
+            throw error;
+        }
+        for (const entry of entries) {
+            const path = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name !== 'node_modules' && entry.name !== '.git')
+                    await walk(path);
+            }
+            else {
+                files.push(relative(root, path).split(sep));
+            }
+        }
+    };
+    await walk(root);
+    return files;
 }
 // Same directory rules as pages (flat, .html only), then the same checks as `pattern push`.
 async function checkPatterns(dir, problems) {

package/dist/lib/wp-client.d.ts

@@ -24,6 +24,7 @@ type RequestOptions = {
 };
 export declare function isNotFoundError(error: unknown): boolean;
 export declare function isForbiddenError(error: unknown): boolean;
+export declare function isApplicationPasswordsDisabled(error: unknown): boolean;
 export declare function isApplicative404(error: unknown, marker: string): boolean;
 export declare function isConflictCode(error: unknown, code: string): boolean;
 export declare function isTimeoutError(error: unknown): boolean;

package/dist/lib/wp-client.js

@@ -100,6 +100,12 @@ export function isNotFoundError(error) {
 export function isForbiddenError(error) {
     return responseOf(causeOf(error)).statusCode === 403;
 }
+// WordPress core answers the authenticated request with this `code` when Application
+// Passwords are turned off for the user (a security plugin, `wp_is_application_passwords_available`
+// filter or the user's role), as opposed to `incorrect_password`/`invalid_username` for bad credentials.
+export function isApplicationPasswordsDisabled(error) {
+    return parseBody(responseOf(causeOf(error)).body).code === 'application_passwords_disabled_for_user';
+}
 // A 404 a Loopress controller raises on purpose, identified by its JSON body's `error` field
 // (e.g. `{"error": "composer.lock not found"}` from ComposerController). Narrower than
 // isNotFoundError: a bare 404 also covers the route being absent because the plugin isn't

package/dist/types/project-config.generated.d.ts

@@ -30,11 +30,11 @@ export interface LoopressProjectConfiguration {
     /**
      * Directory where hook files (WordPress actions, filters, and scheduled tasks) are read from and written to, relative to rootDir.
      */
-    hooksDir?: string;
+    hookDir?: string;
     /**
      * Directory where single-page app bundles are read from and written to, relative to rootDir. Each subdirectory is one app: a loopress.app.json plus a built dist/ folder.
      */
-    appsDir?: string;
+    appDir?: string;
     /**
      * Directory where static HTML pages (one <slug>.html per WordPress page, managed by Loopress) are read from, relative to rootDir.
      */
@@ -58,7 +58,7 @@ export interface LoopressProjectConfiguration {
     /**
      * Directory where explicitly tracked WordPress options (wp_options rows) are read from and written to, relative to rootDir. Only options added via `lps option add` live here, this is never the whole options table.
      */
-    optionsDir?: string;
+    optionDir?: string;
     /**
      * Directory where custom post types (one JSON file of register_post_type() arguments per post type, named <slug>.json) are read from and written to, relative to rootDir.
      */
@@ -86,7 +86,7 @@ export interface LoopressProjectConfiguration {
     /**
      * Directory where the active block theme's Global Styles customizations (Site Editor > Styles: colors, typography, spacing) are read from and written to, relative to rootDir. Classic (non-block) themes are not supported.
      */
-    themeStylesDir?: string;
+    themeStyleDir?: string;
     /**
      * Project identifier from the global Loopress config. When set, takes precedence over the currently active project in the global config.
      */
@@ -106,6 +106,17 @@ export interface LoopressProjectConfiguration {
             active?: boolean;
         };
     };
+    /**
+     * Per-environment settings, keyed by environment name (as in `lps project config`).
+     */
+    environments?: {
+        [k: string]: {
+            /**
+             * Globs relative to rootDir (`*`, `**`, `?`) of files this environment never receives. `lps push`, `lps diff` and `lps promote` leave them alone on it: never pushed, never pruned or mirrored away, reported as held back instead of drift. A glob matching a directory covers everything inside. `lps pull` and `lps dev` ignore it.
+             */
+            exclude?: string[];
+        };
+    };
     /**
      * Keep the Loopress child theme (<parent>-loopress) active: `lps theme template push`, and so `lps push`, activates it when it isn't. Off by default, a theme switch changes the settings WordPress stores per theme.
      */

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

@@ -15,6 +15,8 @@ export declare function readLocalBlocks(dir: string): Promise<{
     blocks: LocalBlock[];
     problems: BlockProblem[];
 }>;
+export declare function excludedBlockFiles(dir: string, slug: string): string[];
+export declare function blockFilesToPush(dir: string, block: LocalBlock, site: BlockFiles | undefined): BlockFiles;
 export declare function formatBlockProblems(problems: BlockProblem[]): string;
 export declare function assertSafeBlock(block: LocalBlock): void;
 export declare function writeBlock(dir: string, block: LocalBlock): Promise<void>;

package/dist/utils/block-format.js

@@ -1,5 +1,6 @@
 import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { isExcluded, withoutExcluded } from '../lib/exclude.js';
 import { errorCode, isRecord } from '../lib/narrow.js';
 // A dynamic block: blocks/<slug>/ in WordPress's own block format, registered on the site as
 // loopress/<slug> (the plugin's BlocksDirectory and BlockFilesController).
@@ -53,7 +54,7 @@ export function blockProblems(slug, files) {
 export async function readLocalBlocks(dir) {
     let entries;
     try {
-        entries = await readdir(dir, { withFileTypes: true });
+        entries = withoutExcluded(dir, await readdir(dir, { withFileTypes: true }), (entry) => entry.name);
     }
     catch (error) {
         if (errorCode(error) === 'ENOENT')
@@ -69,12 +70,27 @@ export async function readLocalBlocks(dir) {
             if (file.isFile() && !file.name.startsWith('.'))
                 files[file.name] = await readFile(join(dir, slug, file.name), 'utf8');
         }
+        // Checked whole, then the environment's excluded files are dropped: a push keeps the site's
+        // copy of those (see blockFilesToPush), a diff holds the block back.
         for (const message of blockProblems(slug, files))
             problems.push({ file: join(dir, slug), message });
-        blocks.push({ files, slug });
+        const kept = new Set(withoutExcluded(join(dir, slug), Object.keys(files), (name) => name));
+        blocks.push({ files: Object.fromEntries(Object.entries(files).filter(([name]) => kept.has(name))), slug });
     }
     return { blocks, problems };
 }
+// Block files the environment excludes: never sent, so the site's copy of each one goes back in
+// the PUT (a block is replaced as a whole).
+export function excludedBlockFiles(dir, slug) {
+    return BLOCK_FILES.filter((name) => isExcluded(join(dir, slug, name)));
+}
+// What a push sends for `block`: its local files plus the site's copy of its excluded ones.
+export function blockFilesToPush(dir, block, site) {
+    const excluded = new Set(excludedBlockFiles(dir, block.slug));
+    const kept = Object.entries(block.files).filter(([name]) => !excluded.has(name));
+    const fromSite = Object.entries(site ?? {}).filter(([name]) => excluded.has(name));
+    return Object.fromEntries([...kept, ...fromSite]);
+}
 export function formatBlockProblems(problems) {
     return problems.map((problem) => `${problem.file}: ${problem.message}`).join('\n');
 }

package/dist/utils/page-format.js

@@ -1,5 +1,6 @@
 import { readdir, readFile } from 'node:fs/promises';
 import { basename, extname, join } from 'node:path';
+import { withoutExcluded } from '../lib/exclude.js';
 import { errorCode, errorMessage, isOneOf } from '../lib/narrow.js';
 export const PAGES_ENDPOINT = 'loopress/v1/pages';
 // Mirrored server-side in PagesController. No leading, trailing or doubled hyphen: WordPress's
@@ -90,7 +91,7 @@ export async function readLocalPages(dir) {
 export async function readLocalHtmlFiles(dir, parse, slugRule = PAGE_SLUG_RULE) {
     let entries;
     try {
-        entries = await readdir(dir, { withFileTypes: true });
+        entries = withoutExcluded(dir, await readdir(dir, { withFileTypes: true }), (entry) => entry.name);
     }
     catch (error) {
         if (errorCode(error) === 'ENOENT')

package/dist/utils/resource-dirs.js

@@ -28,16 +28,16 @@ export const RESOURCE_DIR_DEFAULTS = {
 const CONFIG_KEY = {
     acf: 'acfDir',
     api: 'apiDir',
-    apps: 'appsDir',
+    apps: 'appDir',
     block: 'blockDir',
     blockCss: 'blockCssDir',
     cpt: 'cptDir',
     css: 'cssDir',
     form: 'formDir',
-    hooks: 'hooksDir',
+    hooks: 'hookDir',
     menu: 'menuDir',
     meta: 'metaDir',
-    options: 'optionsDir',
+    options: 'optionDir',
     page: 'pageDir',
     part: 'partDir',
     pattern: 'patternDir',
@@ -45,7 +45,7 @@ const CONFIG_KEY = {
     snippets: 'snippetsDir',
     taxonomy: 'taxonomyDir',
     template: 'templateDir',
-    themeStyles: 'themeStylesDir',
+    themeStyles: 'themeStyleDir',
 };
 // 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`.