@loopress/cli 0.20.1 → 0.21.0

package/dist/commands/snippet/push.js

@@ -12,6 +12,7 @@ export default class Push extends PushCommand {
         path: Args.string({ description: 'Path to snippets directory (overrides project config)' }),
     };
     static description = 'Push snippets to WordPress. Local snippet files created or updated remotely are renamed on disk to the `<id>-<slug>` convention.';
+    static enableJsonFlag = true;
     static examples = ['$ lps snippet push', '$ lps snippet push --path ./snippets'];
     static flags = {
         ...PushCommand.dryRunFlag,
@@ -25,17 +26,22 @@ export default class Push extends PushCommand {
         this.log(`Snippets path: ${path}`);
         const snippets = await this.loadSnippets(path);
         this.log(`Found ${snippets.length} snippet${snippets.length === 1 ? '' : 's'} to push`);
+        const pushed = [];
         await new Listr(snippets.map((snippet) => ({
-            task: async (_ctx, task) => this.pushSnippet(snippet, task),
+            task: async (_ctx, task) => {
+                const id = await this.pushSnippet(snippet, task);
+                pushed.push({ id, name: snippet.name });
+            },
             title: `Push ${snippet.name}`,
-        })), { concurrent: false, exitOnError: false }).run();
+        })), { concurrent: false, exitOnError: false, renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
         if (this.failedCount > 0) {
             this.error(`${this.failedCount} snippet${this.failedCount === 1 ? '' : 's'} failed to push.`);
         }
         if (this.dryRun)
-            return;
+            return { pushed, status: 'dry-run' };
         await this.recordSuccess();
         this.log('All snippets pushed.');
+        return { pushed, status: 'success' };
     }
     // Renames the local file pair to the `<id>-<slug>` convention used by `snippet pull` whenever
     // it doesn't already match (e.g. a hand-created `demo.php` with no id, or a stale slug after a rename).
@@ -73,7 +79,7 @@ export default class Push extends PushCommand {
     }
     async loadSnippets(path) {
         try {
-            return await loadSnippetsFromDisk(path, (message) => this.warn(message));
+            return await loadSnippetsFromDisk(path, (message) => { this.warn(message); });
         }
         catch (error) {
             this.error(error.message);
@@ -83,10 +89,11 @@ export default class Push extends PushCommand {
         if (this.dryRun) {
             if (task)
                 task.output = `[dry-run] Would push: ${snippet.name}`;
-            return;
+            return snippet.id;
         }
         try {
             const payload = this.toPayload(snippet);
+            let { id } = snippet;
             if (snippet.id) {
                 try {
                     await this.wp.put(`${SNIPPETS_ENDPOINT}/${snippet.id}`, payload);
@@ -99,16 +106,19 @@ export default class Push extends PushCommand {
                         throw error;
                     const response = await this.wp.post(SNIPPETS_ENDPOINT, payload);
                     const created = normalizeSnippet(response);
+                    id = created.id;
                     await this.ensureCanonicalFilename(snippet, created.id, created.name);
                 }
             }
             else {
                 const response = await this.wp.post(SNIPPETS_ENDPOINT, payload);
                 const created = normalizeSnippet(response);
+                id = created.id;
                 await this.ensureCanonicalFilename(snippet, created.id, created.name);
             }
             if (task)
                 task.output = `Pushed: ${snippet.name}`;
+            return id;
         }
         catch (error) {
             this.reportTaskFailure(`Failed to push ${snippet.name}: ${error.message}`, error, task);

package/dist/commands/status.d.ts

@@ -1,12 +1,24 @@
 import { Command } from '@oclif/core';
+type StatusInfo = {
+    environments?: string[];
+    note?: string;
+    project?: string;
+    url?: string;
+};
+type StatusResult = StatusInfo & {
+    configDir: string;
+    dataDir: string;
+};
 export default class Status extends Command {
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         env: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
-    run(): Promise<void>;
+    run(): Promise<StatusResult>;
     private reportActiveProject;
     private reportEnvOverride;
     private reportPinnedProject;
 }
+export {};

package/dist/commands/status.js

@@ -4,6 +4,7 @@ import { readLocalConfig } from '../utils/loopress-config.js';
 const c = ux.colorize;
 export default class Status extends Command {
     static description = 'Show which WordPress project and environment commands will target';
+    static enableJsonFlag = true;
     static examples = ['$ lps status', '$ lps status --env staging'];
     static flags = {
         env: Flags.string({ description: 'Show what would be targeted with this environment, as other commands do with --env' }),
@@ -11,40 +12,41 @@ export default class Status extends Command {
     async run() {
         const { flags } = await this.parse(Status);
         const localConfig = await readLocalConfig();
+        let info;
         if (flags.env) {
-            this.reportEnvOverride(localConfig.projectId, flags.env);
+            info = this.reportEnvOverride(localConfig.projectId, flags.env);
         }
         else if (localConfig.projectId) {
-            this.reportPinnedProject(localConfig.projectId);
+            info = this.reportPinnedProject(localConfig.projectId);
         }
         else {
-            this.reportActiveProject();
+            info = this.reportActiveProject();
         }
         this.log('');
         this.log(`Config dir: ${this.config.configDir}`);
         this.log(`Data dir:   ${this.config.dataDir}`);
+        return { ...info, configDir: this.config.configDir, dataDir: this.config.dataDir };
     }
     reportActiveProject() {
         const env = configManager.getCurrentEnv();
-        if (!env) {
-            this.log('No project configured. Run `lps project config` first.');
-            return;
-        }
-        const project = configManager.getCurrentProject();
-        if (!project) {
-            this.log('No project configured. Run `lps project config` first.');
-            return;
+        const project = env ? configManager.getCurrentProject() : undefined;
+        if (!env || !project) {
+            const note = 'No project configured. Run `lps project config` first.';
+            this.log(note);
+            return { note };
         }
         this.log(`Project:  ${project.name} (${env.name})`);
         this.log(`URL:      ${env.url}`);
+        return { project: `${project.name} (${env.name})`, url: env.url };
     }
     // Mirrors base.ts:resolveEnvironment with --env: the targeted project comes from
     // loopress.json when pinned, from the globally active project otherwise.
     reportEnvOverride(pinnedProjectId, envName) {
         const project = pinnedProjectId ? configManager.getProject(pinnedProjectId) : configManager.getCurrentProject();
         if (!project) {
-            this.log('No project configured. Run `lps project config` first.');
-            return;
+            const note = 'No project configured. Run `lps project config` first.';
+            this.log(note);
+            return { note };
         }
         const env = project.environments[envName];
         if (!env) {
@@ -52,29 +54,33 @@ export default class Status extends Command {
         }
         this.log(`Project:  ${project.name} (${env.name}, via --env)`);
         this.log(`URL:      ${env.url}`);
+        return { project: `${project.name} (${env.name}, via --env)`, url: env.url };
     }
     reportPinnedProject(projectId) {
         const project = configManager.getProject(projectId);
         if (!project) {
+            const note = `loopress.json pins project "${projectId}", but it no longer exists. Run \`lps project config\` to configure it.`;
             this.log(`loopress.json pins project "${projectId}", but it no longer exists.`);
             this.log('Run `lps project config` to configure it.');
-            return;
+            return { note };
         }
         const envNames = Object.keys(project.environments);
         if (envNames.length === 0) {
+            const note = 'No environments configured for this project. Run `lps project config` to add one.';
             this.log(`Project:  ${project.name}`);
-            this.log('No environments configured for this project. Run `lps project config` to add one.');
-            return;
+            this.log(note);
+            return { note, project: project.name };
         }
         if (envNames.length === 1) {
             const env = project.environments[envNames[0]];
             this.log(`Project:  ${project.name} (${env.name})`);
             this.log(`URL:      ${env.url}`);
-            return;
+            return { project: `${project.name} (${env.name})`, url: env.url };
         }
         const current = configManager.getCurrentProject();
         const currentEnv = current?.id === projectId ? configManager.getCurrentEnv() : null;
         if (!currentEnv) {
+            const note = `"${project.name}" has multiple environments and isn't the globally active project. Run \`lps project switch\` to pick one.`;
             this.log(`Project:  ${project.name} ${c('yellow', '(ambiguous)')}`);
             this.log(`Environments: ${envNames.join(', ')}`);
             this.log('');
@@ -83,9 +89,10 @@ export default class Status extends Command {
             if (current) {
                 this.log(`(Globally active project right now: "${current.name}")`);
             }
-            return;
+            return { environments: envNames, note, project: project.name };
         }
         this.log(`Project:  ${project.name} (${currentEnv.name})`);
         this.log(`URL:      ${currentEnv.url}`);
+        return { project: `${project.name} (${currentEnv.name})`, url: currentEnv.url };
     }
 }

package/dist/config/auth.manager.d.ts

@@ -1,8 +1,8 @@
-export interface ConsoleAuth {
+export type ConsoleAuth = {
     email?: string;
     savedAt: string;
     token: string;
-}
+};
 export declare class AuthManager {
     private dataDir?;
     constructor(dataDir?: string | undefined);

package/dist/config/project-config.manager.d.ts

@@ -1,4 +1,4 @@
-import { EnvironmentConfig, LoopressConfig, ProjectConfig } from '../types/config.js';
+import { type EnvironmentConfig, type LoopressConfig, type ProjectConfig } from '../types/config.js';
 export declare class ProjectConfigManager {
     private configDir?;
     constructor(configDir?: string | undefined);

package/dist/config/project-config.manager.js

@@ -12,7 +12,7 @@ export class ProjectConfigManager {
         const base = toSlug(name, 'project');
         let id = base;
         let suffix = 2;
-        while (config.projects[id]) {
+        while (Object.hasOwn(config.projects, id)) {
             id = `${base}-${suffix}`;
             suffix++;
         }
@@ -100,7 +100,7 @@ export class ProjectConfigManager {
         const project = config.projects[projectId];
         if (!project)
             return;
-        delete project.environments[envName];
+        Reflect.deleteProperty(project.environments, envName);
         if (config.currentProject?.id === projectId && config.currentProject.env === envName) {
             const remaining = Object.keys(project.environments);
             config.currentProject = remaining.length > 0 ? { env: remaining[0], id: projectId } : null;
@@ -109,7 +109,7 @@ export class ProjectConfigManager {
     }
     removeProject(id) {
         const config = this.readConfig();
-        delete config.projects[id];
+        Reflect.deleteProperty(config.projects, id);
         if (config.currentProject?.id === id) {
             const [nextId] = Object.keys(config.projects);
             const nextProject = nextId ? config.projects[nextId] : undefined;
@@ -126,7 +126,7 @@ export class ProjectConfigManager {
     }
     setCurrent(projectId, envName) {
         const config = this.readConfig();
-        if (!config.projects[projectId])
+        if (!Object.hasOwn(config.projects, projectId))
             return;
         config.currentProject = { env: envName, id: projectId };
         this.writeConfig(config);
@@ -137,8 +137,7 @@ export class ProjectConfigManager {
         if (!project)
             return;
         project.environments[envName] = env;
-        if (!config.currentProject)
-            config.currentProject = { env: envName, id: projectId };
+        config.currentProject ??= { env: envName, id: projectId };
         this.writeConfig(config);
     }
     setEnvironmentApiId(projectId, envName, apiEnvironmentId) {

package/dist/lib/base.d.ts

@@ -1,6 +1,6 @@
 import { Command } from '@oclif/core';
-import { EnvironmentConfig } from '../types/config.js';
-import { LoopressLocalConfig } from '../utils/loopress-config.js';
+import { type EnvironmentConfig } from '../types/config.js';
+import { type LoopressLocalConfig } from '../utils/loopress-config.js';
 import { WpClient } from './wp-client.js';
 export declare abstract class LoopressCommand extends Command {
     static baseFlags: {

package/dist/lib/base.js

@@ -45,6 +45,7 @@ export class LoopressCommand extends Command {
         const { flags } = (await this.parse({
             args: this.ctor.args,
             baseFlags: this.ctor.baseFlags,
+            enableJsonFlag: this.ctor.enableJsonFlag,
             flags: this.ctor.flags,
             strict: this.ctor.strict,
         }));
@@ -85,8 +86,8 @@ export class LoopressCommand extends Command {
             return;
         const description = `${orphans.length} local file${orphans.length === 1 ? '' : 's'} ${reason}: ${orphans.join(', ')}`;
         if (!this.yes && isInteractive()) {
-            const proceed = await confirm({ default: true, message: `Remove ${description}?` });
-            if (!proceed) {
+            const isProceed = await confirm({ default: true, message: `Remove ${description}?` });
+            if (!isProceed) {
                 this.log(`Kept ${description}`);
                 return;
             }

package/dist/lib/bootstrap-full-install.d.ts

@@ -1,4 +1,4 @@
-import { WpClient } from './wp-client.js';
+import { type WpClient } from './wp-client.js';
 /**
  * Installs and activates Loopress Full on a site that doesn't have it yet: downloads the
  * latest release zip, creates a temporary admin (the only way to get `install_plugins` from

package/dist/lib/dev-watch.d.ts

@@ -0,0 +1,16 @@
+import { type LoopressLocalConfig } from '../utils/loopress-config.js';
+export type ResourceType = 'api' | 'pages' | 'plugins' | 'snippets';
+export declare const RESOURCE_TYPES: ResourceType[];
+export type WatchTarget = {
+    commandId: string;
+    path: string;
+    type: ResourceType;
+};
+export declare function resolveResourceTypes(only?: ResourceType[], skip?: ResourceType[]): ResourceType[];
+export declare function buildWatchTargets(types: ResourceType[], localConfig: LoopressLocalConfig, cwd: string): WatchTarget[];
+export declare function resourceTypeForPath(filePath: string, targets: WatchTarget[]): ResourceType | undefined;
+export type DebouncedBatcher = {
+    cancel: () => void;
+    queue: (path: string) => void;
+};
+export declare function createDebouncedBatcher(flush: (paths: string[]) => Promise<void>, debounceMs: number): DebouncedBatcher;

package/dist/lib/dev-watch.js

@@ -0,0 +1,71 @@
+import { existsSync } from 'node:fs';
+import { join, sep } from 'node:path';
+export const RESOURCE_TYPES = ['snippets', 'pages', 'api', 'plugins'];
+// `only` narrows the default set, `skip` then removes from whatever that set is, same
+// precedence a combined `--only=a,b --skip=b` reads as: watch a, b, then drop b.
+export function resolveResourceTypes(only, skip = []) {
+    const base = only && only.length > 0 ? only : RESOURCE_TYPES;
+    return base.filter((type) => !skip.includes(type));
+}
+// One target per requested type that actually has something to watch: a missing directory (no
+// `api/` folder yet) or an empty plugin manifest is left out silently, matching `push`'s own
+// directories which are all optional. `plugins` watches the whole `loopress.json` lockfile since
+// the plugin manifest is a field in it, not its own directory.
+export function buildWatchTargets(types, localConfig, cwd) {
+    const rootDir = join(cwd, localConfig.rootDir ?? '.');
+    const candidates = {
+        api: { commandId: 'api:push', path: join(rootDir, localConfig.apiDir ?? 'api'), type: 'api' },
+        pages: { commandId: 'page:push', path: join(rootDir, localConfig.pageDir ?? 'pages'), type: 'pages' },
+        plugins: { commandId: 'plugin:push', path: join(cwd, 'loopress.json'), type: 'plugins' },
+        snippets: { commandId: 'snippet:push', path: join(rootDir, localConfig.snippetsDir ?? 'snippets'), type: 'snippets' },
+    };
+    return types
+        .map((type) => candidates[type])
+        .filter((target) => {
+        if (target.type === 'plugins')
+            return Object.keys(localConfig.plugins ?? {}).length > 0;
+        return existsSync(target.path);
+    });
+}
+// A changed file belongs to whichever target's path is a prefix of it (directory targets) or
+// equals it (the `loopress.json` file target for `plugins`).
+export function resourceTypeForPath(filePath, targets) {
+    return targets.find((target) => filePath === target.path || filePath.startsWith(target.path + sep))?.type;
+}
+// Groups file events that land within `debounceMs` of each other into one `flush` call. If a
+// flush is still running when the timer fires again (a slow push outlasting the next debounce
+// window), the new paths just accumulate in `pending` instead of starting a second, overlapping
+// flush; once the in-flight one finishes it immediately flushes whatever queued up meanwhile.
+export function createDebouncedBatcher(flush, debounceMs) {
+    const pending = new Set();
+    let timer;
+    let isBusy = false;
+    const schedule = () => {
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            runFlush().catch(() => { });
+        }, debounceMs);
+    };
+    const runFlush = async () => {
+        if (isBusy || pending.size === 0)
+            return;
+        isBusy = true;
+        const paths = [...pending];
+        pending.clear();
+        try {
+            await flush(paths);
+        }
+        finally {
+            isBusy = false;
+            if (pending.size > 0)
+                schedule();
+        }
+    };
+    return {
+        cancel() { clearTimeout(timer); },
+        queue(path) {
+            pending.add(path);
+            schedule();
+        },
+    };
+}

package/dist/lib/find-orphaned-files.d.ts

@@ -1,7 +1,8 @@
-export interface OrphanMatcher {
+export type OrphanMatcher = {
     extensions: string[];
     key(base: string): null | string;
-}
+    recursive?: boolean;
+};
 export declare function findOrphanedFiles(dir: string, keep: Set<string>, matcher: OrphanMatcher): Promise<string[]>;
 export declare function numericPrefixKey(base: string): null | string;
 export declare function basenameKey(base: string): string;

package/dist/lib/find-orphaned-files.js

@@ -1,15 +1,51 @@
 import { readdir } from 'node:fs/promises';
-import { extname } from 'node:path';
-export async function findOrphanedFiles(dir, keep, matcher) {
-    let files;
+import { extname, join } from 'node:path';
+// Same shape as load-files.ts's own walker, kept separate rather than shared: this one
+// filters against a list of extensions (page/snippet pull need more than one), that one
+// against a single extension, and reconciling the two would cost more than the ~15 duplicated
+// lines it would save.
+async function walk(dir, extensions) {
+    let entries;
     try {
-        files = await readdir(dir);
+        entries = await readdir(dir, { withFileTypes: true });
     }
     catch (error) {
         if (error.code === 'ENOENT')
             return [];
         throw error;
     }
+    const relativePaths = [];
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            // join() builds the real OS path to actually walk, but the returned identity is always
+            // '/'-joined regardless of platform: it's matched against `keep`, filenames the server
+            // sends with '/', never the OS separator. join() here (backslash on Windows) would make
+            // every nested file's identity never match, findOrphanedFiles() would then report a
+            // live, kept file as orphaned and pull.ts would delete it.
+            const nested = await walk(join(dir, entry.name), extensions);
+            relativePaths.push(...nested.map((relativePath) => `${entry.name}/${relativePath}`));
+        }
+        else if (extensions.includes(extname(entry.name))) {
+            relativePaths.push(entry.name);
+        }
+    }
+    return relativePaths;
+}
+export async function findOrphanedFiles(dir, keep, matcher) {
+    let files;
+    if (matcher.recursive) {
+        files = await walk(dir, matcher.extensions);
+    }
+    else {
+        try {
+            files = await readdir(dir);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+    }
     return files.filter((file) => {
         const ext = extname(file);
         if (!matcher.extensions.includes(ext))

package/dist/lib/github-release.js

@@ -22,7 +22,7 @@ export async function downloadLatestFullZip() {
         headers: { accept: 'application/vnd.github+json', 'user-agent': 'loopress-cli' },
         searchParams: { 'per_page': 30 },
     }).json();
-    const pluginRelease = releases.find((release) => RELEASE_TAG_PATTERN.test(release.tag_name));
+    const pluginRelease = releases.find((release) => release.tag_name.startsWith("wordpress-plugin@"));
     if (!pluginRelease) {
         throw new Error(`No "wordpress-plugin@*" release found in ${REPO}.`);
     }

package/dist/lib/interactive.js

@@ -3,5 +3,5 @@
 // Every command that prompts routes its decision through this so the CLI never hangs on a
 // question nobody can answer.
 export function isInteractive() {
-    return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY) && !process.env.CI;
+    return process.stdin.isTTY && process.stdout.isTTY && !process.env.CI;
 }

package/dist/lib/load-files.d.ts

@@ -2,4 +2,5 @@ export declare function loadFiles<T>(dir: string, options: {
     extension: string;
     onSkip(message: string): void;
     parse(raw: string, filePath: string): T;
+    recursive?: boolean;
 }): Promise<T[]>;

package/dist/lib/load-files.js

@@ -1,25 +1,54 @@
 import { readdir, readFile } from 'node:fs/promises';
 import { extname, join } from 'node:path';
-// Loads every `<extension>` file of a flat directory through `parse`. One file is read in
-// isolation: a corrupted or hand-broken file (unreadable, bad JSON, failed validation) must
-// only skip that file, never abort loading the rest of the directory, so `parse` throwing is
-// reported through `onSkip` and the loop moves on. ENOENT on the directory itself means
-// "nothing to load", not an error.
-export async function loadFiles(dir, options) {
+// Recursion for the api resource type only (path-param route files can live in
+// subdirectories, e.g. api/invoice-pdf/[order_id].php); every other resource type stays
+// flat. withFileTypes avoids a second stat() per entry to tell files from directories.
+async function walk(dir, extension) {
     let entries;
     try {
-        entries = await readdir(dir);
+        entries = await readdir(dir, { withFileTypes: true });
     }
     catch (error) {
         if (error.code === 'ENOENT')
             return [];
         throw error;
     }
-    const items = [];
+    const filePaths = [];
     for (const entry of entries) {
-        if (extname(entry) !== options.extension)
-            continue;
-        const filePath = join(dir, entry);
+        const entryPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            filePaths.push(...(await walk(entryPath, extension)));
+        }
+        else if (extname(entry.name) === extension) {
+            filePaths.push(entryPath);
+        }
+    }
+    return filePaths;
+}
+// Loads every `<extension>` file of a directory through `parse`. One file is read in
+// isolation: a corrupted or hand-broken file (unreadable, bad JSON, failed validation) must
+// only skip that file, never abort loading the rest of the directory, so `parse` throwing is
+// reported through `onSkip` and the loop moves on. ENOENT on the directory itself means
+// "nothing to load", not an error.
+export async function loadFiles(dir, options) {
+    let filePaths;
+    if (options.recursive) {
+        filePaths = await walk(dir, options.extension);
+    }
+    else {
+        let entries;
+        try {
+            entries = await readdir(dir);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+        filePaths = entries.filter((entry) => extname(entry) === options.extension).map((entry) => join(dir, entry));
+    }
+    const items = [];
+    for (const filePath of filePaths) {
         try {
             items.push(options.parse(await readFile(filePath, 'utf8'), filePath));
         }

package/dist/lib/load-snippets.d.ts

@@ -1,2 +1,2 @@
-import { Snippet } from '../types/snippet.js';
+import { type Snippet } from '../types/snippet.js';
 export declare function loadSnippets(path: string, onSkip?: (message: string) => void): Promise<Snippet[]>;

package/dist/lib/load-snippets.js

@@ -19,11 +19,11 @@ export async function loadSnippets(path, onSkip) {
         files = await readdir(path);
     }
     catch (error) {
-        throw new Error(`Error loading snippets: ${error.message}`);
+        throw new Error(`Error loading snippets: ${error.message}`, { cause: error });
     }
     for (const file of files) {
         const ext = extname(file);
-        if (!(ext in TYPE_BY_EXTENSION))
+        if (!Object.hasOwn(TYPE_BY_EXTENSION, ext))
             continue;
         const filePath = join(path, file);
         const metaPath = join(path, `${basename(file, ext)}.json`);
@@ -40,7 +40,7 @@ export async function loadSnippets(path, onSkip) {
         let id;
         let name;
         let type;
-        let active = false;
+        let isActive = false;
         let tags = [];
         let location = null;
         let insertMethod = null;
@@ -49,14 +49,16 @@ export async function loadSnippets(path, onSkip) {
         try {
             const metaContent = await readFile(metaPath, 'utf8');
             const meta = JSON.parse(metaContent);
-            id = meta.id === undefined ? undefined : Number(meta.id);
-            name = meta.name ? String(meta.name) : undefined;
+            id = meta.id;
+            // `||`, not `??`: an empty-string name in the sidecar JSON counts as absent too.
+            // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+            name = meta.name || undefined;
             type = parseType(meta.type) ?? undefined;
-            active = Boolean(meta.active);
+            isActive = Boolean(meta.active);
             tags = Array.isArray(meta.tags) ? meta.tags.map(String) : [];
             location = parseLocation(meta.location);
             insertMethod = parseInsertMethod(meta.insertMethod);
-            priority = meta.priority === undefined ? 10 : Number(meta.priority);
+            priority = meta.priority ?? 10;
             shortcodeAttributes = Array.isArray(meta.shortcodeAttributes) ? meta.shortcodeAttributes.map(String) : [];
         }
         catch (error) {
@@ -65,9 +67,9 @@ export async function loadSnippets(path, onSkip) {
                 continue;
             }
         }
-        const resolvedType = type ?? (ext in TYPE_BY_EXTENSION ? TYPE_BY_EXTENSION[ext] : 'php');
+        const resolvedType = type ?? (Object.hasOwn(TYPE_BY_EXTENSION, ext) ? TYPE_BY_EXTENSION[ext] : 'php');
         snippets.push({
-            active,
+            active: isActive,
             code: content,
             id,
             insertMethod: insertMethod ?? 'auto',