@loopress/cli 0.26.0 → 0.28.0

package/dist/utils/composer.js

@@ -1,6 +1,8 @@
 import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import writeFileAtomic from 'write-file-atomic';
+import { isExactVersion } from './version.js';
 export async function readComposerJson() {
     const path = join(process.cwd(), 'composer.json');
     if (!existsSync(path))
@@ -31,3 +33,137 @@ export function getComposerManagedSlugs(composerJson) {
         .filter((pkg) => pkg.startsWith('wpackagist-plugin/'))
         .map((pkg) => pkg.slice('wpackagist-plugin/'.length));
 }
+// A slug WPackagist can't serve makes `composer update` fail for the whole file, libraries
+// included. WPackagist mirrors WordPress.org, whose API answers a clean 404 for premium and
+// custom plugins/themes. Any other failure throws before composer.json is written.
+async function isOnWordPressOrg(kind, slug) {
+    const url = `https://api.wordpress.org/${kind}s/info/1.2/?action=${kind}_information&slug=${encodeURIComponent(slug)}`;
+    const fail = (why) => new Error(`Could not check whether the ${kind} "${slug}" is on WordPress.org (${why}), so composer.json was not modified. ` +
+        'Loopress only adds packages WPackagist can serve. Retry once api.wordpress.org is reachable.');
+    let response;
+    try {
+        response = await fetch(url);
+    }
+    catch (error) {
+        throw fail(`network error: ${error.message}`);
+    }
+    if (response.status === 404)
+        return false;
+    if (!response.ok)
+        throw fail(`HTTP ${response.status}`);
+    return true;
+}
+// Rewrites a JSON file the way it was indented (Composer itself writes 4 spaces), so a pull only
+// shows the entries it changed in the git diff. A file with no indentation to copy gets 4 spaces.
+function stringifyLike(original, value) {
+    const indent = /^([ \t]+)"/m.exec(original)?.[1] ?? ' '.repeat(4);
+    return JSON.stringify(value, null, indent) + (original.endsWith('\n') ? '\n' : '');
+}
+// A package already declared in composer.json: `pin` means the pull may move it (an exact pin,
+// or already live), `skip` gives the reason it must stay as is.
+function classifyDeclared(declared, live, inRequire) {
+    if (!inRequire)
+        return { skip: 'declared in require-dev' };
+    if (declared === live || isExactVersion(declared))
+        return { pin: declared };
+    return { skip: `keeps constraint ${declared}, live ${live}` };
+}
+// Sorts every installed package into the result, and returns the undeclared slugs that still
+// need a WordPress.org lookup before they can be added.
+function planComposerPull(composerJson, prefix, incoming) {
+    const require = composerJson.require ?? {};
+    const allPackages = { ...require, ...composerJson['require-dev'] };
+    const providedBy = new Map(Object.keys(allPackages)
+        .filter((name) => !name.startsWith(prefix) && name.includes('/'))
+        .map((name) => [name.split('/', 2)[1], name]));
+    const result = { added: [], merged: {}, skipped: [], updated: [] };
+    const candidates = [];
+    for (const [slug, version] of Object.entries(incoming)) {
+        const name = prefix + slug;
+        const provider = providedBy.get(slug);
+        if (Object.hasOwn(allPackages, name)) {
+            const outcome = classifyDeclared(allPackages[name], version, Object.hasOwn(require, name));
+            if ('skip' in outcome) {
+                result.skipped.push({ reason: outcome.skip, slug });
+                continue;
+            }
+            result.merged[slug] = version;
+            if (outcome.pin !== version)
+                result.updated.push({ from: outcome.pin, slug, to: version });
+        }
+        else if (provider) {
+            result.skipped.push({ reason: `provided by ${provider}`, slug });
+        }
+        else {
+            candidates.push(slug);
+        }
+    }
+    return { candidates, result };
+}
+// `lps plugin pull` / `lps theme pull` on a project that has a composer.json: pin installed
+// packages to their live versions as `wpackagist-<kind>/<slug>` under `require`, leaving every
+// other key untouched. The server adds the WPackagist repository and composer/installers on push.
+// - A declared version constraint (^9.4, *, ...) is the user's intent: never overwritten, only an
+//   exact pin moves to the live version.
+// - Slugs already declared in require-dev stay there instead of being duplicated into require.
+// - A slug provided by another package (acme/<slug>) or absent from WordPress.org is skipped.
+export async function pullIntoComposerJson(path, kind, incoming, { dryRun, log }) {
+    const raw = await readFile(path, 'utf8');
+    const composerJson = JSON.parse(raw);
+    const prefix = `wpackagist-${kind}/`;
+    const { candidates, result } = planComposerPull(composerJson, prefix, incoming);
+    const found = await Promise.all(candidates.map(async (slug) => isOnWordPressOrg(kind, slug)));
+    for (const [i, slug] of candidates.entries()) {
+        if (found[i]) {
+            result.added.push(slug);
+            result.merged[slug] = incoming[slug];
+        }
+        else {
+            result.skipped.push({ reason: 'not on WordPress.org', slug });
+        }
+    }
+    if (!dryRun) {
+        const require = { ...composerJson.require };
+        for (const [slug, version] of Object.entries(result.merged))
+            require[prefix + slug] = version;
+        // Atomic: an interrupted write must never leave the user's committed composer.json truncated.
+        await writeFileAtomic(path, stringifyLike(raw, { ...composerJson, require }), 'utf8');
+    }
+    log(`${dryRun ? '[dry-run] Would pin' : 'Pinned'} ${Object.keys(result.merged).length} ${kind}s in composer.json`);
+    if (result.added.length > 0)
+        log(`  + Added: ${result.added.join(', ')}`);
+    for (const u of result.updated)
+        log(`  ~ Updated: ${u.slug} ${u.from} → ${u.to}`);
+    for (const s of result.skipped)
+        log(`  - Skipped: ${s.slug} (${s.reason})`);
+    if (!dryRun && (result.added.length > 0 || result.updated.length > 0))
+        log('Run `lps composer push` to apply.');
+    return result;
+}
+// Split a composer.json `require` map into the three intent namespaces the sync endpoint
+// understands. `composer/installers` is owned by the server scaffold, never sent.
+export function toIntent(require) {
+    const intent = { libraries: {}, plugins: {}, themes: {} };
+    for (const [name, constraint] of Object.entries(require)) {
+        if (name === 'composer/installers')
+            continue;
+        if (name.startsWith('wpackagist-plugin/')) {
+            intent.plugins[name.slice('wpackagist-plugin/'.length)] = constraint;
+        }
+        else if (name.startsWith('wpackagist-theme/')) {
+            intent.themes[name.slice('wpackagist-theme/'.length)] = constraint;
+        }
+        else {
+            intent.libraries[name] = constraint;
+        }
+    }
+    return intent;
+}
+// The `wpackagist-<kind>/<slug>` entries of a composer.json `require`, keyed by slug, with the
+// version or constraint as written.
+export function wpackagistRequire(composerJson, kind) {
+    const prefix = `wpackagist-${kind}/`;
+    return Object.fromEntries(Object.entries(composerJson.require ?? {})
+        .filter(([name]) => name.startsWith(prefix))
+        .map(([name, version]) => [name.slice(prefix.length), version]));
+}

package/dist/utils/loopress-config.d.ts

@@ -2,3 +2,4 @@ import { type LoopressProjectConfiguration } from '../types/project-config.gener
 export type LoopressLocalConfig = LoopressProjectConfiguration;
 export declare function readLocalConfig(): Promise<LoopressLocalConfig>;
 export declare function writeLocalConfig(config: LoopressLocalConfig): Promise<void>;
+export declare function ensureLfGitattributes(): Promise<boolean>;

package/dist/utils/loopress-config.js

@@ -20,3 +20,17 @@ export async function writeLocalConfig(config) {
     const configPath = join(process.cwd(), 'loopress.json');
     await writeFile(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
 }
+// Git for Windows checks text files out as CRLF by default (core.autocrlf=true), so the same
+// snippet would differ byte for byte between a Windows checkout and what `pull` writes (LF).
+// Pinning LF in the repo keeps synced files identical on every OS. Returns false when the rule
+// is already there, so re-running `lps init` never duplicates it. The rule goes first: in
+// .gitattributes a later line wins, so existing exceptions (`*.bat text eol=crlf`) keep theirs.
+const LF_RULE = '* text=auto eol=lf';
+export async function ensureLfGitattributes() {
+    const path = join(process.cwd(), '.gitattributes');
+    const current = existsSync(path) ? await readFile(path, 'utf8') : '';
+    if (current.split(/\r?\n/).some((line) => line.trim() === LF_RULE))
+        return false;
+    await writeFile(path, `${LF_RULE}\n${current}`, 'utf8');
+    return true;
+}

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

@@ -14,6 +14,9 @@ export type Page = {
 export type RemotePage = Page & {
     link: string;
 };
+export type PushedPage = RemotePage & {
+    frontPage?: 'set' | 'unset';
+};
 export type PageProblem = {
     file: string;
     message: string;
@@ -21,7 +24,16 @@ export type PageProblem = {
 export declare function formatPageProblems(problems: PageProblem[]): string;
 export declare function titleFromSlug(slug: string): string;
 export declare function parsePageFile(slug: string, raw: string): Page;
+export declare function parseHtmlHeader(raw: string, keys: readonly string[]): {
+    body: string;
+    meta: Record<string, string>;
+};
 export declare function readLocalPages(dir: string): Promise<{
     pages: Page[];
     problems: PageProblem[];
 }>;
+export declare function readLocalHtmlFiles<T>(dir: string, parse: (slug: string, raw: string) => T): Promise<{
+    files: T[];
+    problems: PageProblem[];
+}>;
+export declare function frontPageNote(page: PushedPage): string;

package/dist/utils/page-format.js

@@ -13,6 +13,10 @@ function parseBoolean(key, value) {
         throw new Error(`"${key}" must be "true" or "false", got "${value}"`);
     return value === 'true';
 }
+const FRONT_PAGE_NOTES = {
+    set: 'now the site front page',
+    unset: 'no longer the front page, the site shows its latest posts',
+};
 export function formatPageProblems(problems) {
     return problems.map((problem) => `${problem.file}: ${problem.message}`).join('\n  ');
 }
@@ -31,27 +35,11 @@ export function titleFromSlug(slug) {
 //
 // 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.
+// typo never silently falls back to a default. `template` is a template slug the active theme
+// offers for pages (one it ships, or a custom one from templates/); it isn't validated here,
+// WordPress itself refuses an unknown one ("Invalid page template") and fails that page's push.
 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 { body, meta } = parseHtmlHeader(raw, HEADER_KEYS);
     const status = meta.status ?? 'draft';
     if (!PAGE_STATUSES.includes(status)) {
         throw new Error(`status "${status}" is not one of ${PAGE_STATUSES.join(', ')}`);
@@ -59,28 +47,52 @@ export function parsePageFile(slug, raw) {
     return {
         fullWidth: parseBoolean('full-width', meta['full-width']),
         hideTitle: parseBoolean('hide-title', meta['hide-title']),
-        html: header ? raw.slice(header[0].length) : raw,
+        html: body,
         slug,
         status: status,
         template: meta.template ?? '',
         title: meta.title || titleFromSlug(slug),
     };
 }
+// Splits the optional `key: value` HTML comment header off `raw`. Shared with templates/.
+export function parseHtmlHeader(raw, keys) {
+    const header = /^\s*<!--([\s\S]*?)-->\r?\n?/.exec(raw);
+    const meta = {};
+    if (!header)
+        return { body: raw, meta };
+    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 (!keys.includes(key))
+            throw new Error(`unknown header key "${key}" (allowed: ${keys.join(', ')})`);
+        meta[key] = line.slice(colon + 1).trim();
+    }
+    return { body: raw.slice(header[0].length), meta };
+}
 // 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) {
+    const { files, problems } = await readLocalHtmlFiles(dir, parsePageFile);
+    return { pages: files, problems };
+}
+// The directory rules of readLocalPages(), for any flat folder of `<slug>.html` files.
+export async function readLocalHtmlFiles(dir, parse) {
     let entries;
     try {
         entries = await readdir(dir, { withFileTypes: true });
     }
     catch (error) {
         if (error.code === 'ENOENT')
-            return { pages: [], problems: [] };
+            return { files: [], problems: [] };
         throw error;
     }
-    const pages = [];
+    const files = [];
     const problems = [];
     entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
@@ -88,7 +100,7 @@ export async function readLocalPages(dir) {
             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}` });
+            problems.push({ file: filePath, message: `subdirectories are not supported, keep every file at the top of ${dir}` });
             continue;
         }
         if (extname(entry.name) !== '.html') {
@@ -101,11 +113,14 @@ export async function readLocalPages(dir) {
             continue;
         }
         try {
-            pages.push(parsePageFile(slug, await readFile(filePath, 'utf8')));
+            files.push(parse(slug, await readFile(filePath, 'utf8')));
         }
         catch (error) {
             problems.push({ file: filePath, message: error.message });
         }
     }
-    return { pages, problems };
+    return { files, problems };
+}
+export function frontPageNote(page) {
+    return page.frontPage === undefined ? '' : ` (${FRONT_PAGE_NOTES[page.frontPage]})`;
 }

package/dist/utils/plugins.d.ts

@@ -1,4 +1,4 @@
-import { type InstalledPlugin, type PluginManifest, type WpNativePlugin } from '../types/plugin.js';
+import { type InstalledPlugin, type PluginManifest, type PluginPin, type WpNativePlugin } from '../types/plugin.js';
 export type PluginDiff = {
     collisions: Array<{
         installedVersion: string;
@@ -9,6 +9,10 @@ export type PluginDiff = {
         file: string;
         slug: string;
     }>;
+    toDeactivate: Array<{
+        file: string;
+        slug: string;
+    }>;
     toInstall: Array<{
         slug: string;
         version: string;
@@ -21,16 +25,17 @@ export type PluginDiff = {
     toRemove: string[];
     untrackedActive: string[];
 };
-export type MergeResult = {
+export type MergeResult<P extends PluginPin = PluginPin> = {
     added: string[];
-    merged: PluginManifest;
+    merged: Record<string, P>;
     updated: Array<{
         from: string;
         slug: string;
         to: string;
     }>;
 };
-export declare function mergePluginManifest(existing: PluginManifest, incoming: PluginManifest): MergeResult;
+export declare function describePin(pin: PluginPin): string;
+export declare function mergePluginManifest<P extends PluginPin>(existing: Record<string, P>, incoming: Record<string, P>): MergeResult<P>;
 export declare function parseInstalledPlugins(raw: WpNativePlugin[]): InstalledPlugin[];
 export declare function diffPlugins(manifest: PluginManifest, installed: InstalledPlugin[], managedSlugs?: Set<string>): PluginDiff;
 export declare function lockedWpackagistSlugs(composerLock: null | string, kind: 'plugin' | 'theme'): Set<string>;

package/dist/utils/plugins.js

@@ -1,3 +1,9 @@
+import { pinActive, pinVersion, } from '../types/plugin.js';
+import { isExactVersion } from './version.js';
+// "1.7.2", or "1.7.2 (inactive)" for a pin that keeps the plugin inactive.
+export function describePin(pin) {
+    return pinActive(pin) ? pinVersion(pin) : `${pinVersion(pin)} (inactive)`;
+}
 // Loopress must never manage itself: pulling it into loopress.json would make a later
 // `plugin push` try to reinstall it from WordPress.org, where it doesn't exist, potentially
 // clobbering the plugin's own directory in the process. Checked against every slug this
@@ -8,8 +14,8 @@ export function mergePluginManifest(existing, incoming) {
     const merged = { ...existing, ...incoming };
     const added = Object.keys(incoming).filter((s) => !Object.hasOwn(existing, s));
     const updated = Object.keys(incoming)
-        .filter((s) => Object.hasOwn(existing, s) && existing[s] !== incoming[s])
-        .map((s) => ({ from: existing[s], slug: s, to: incoming[s] }));
+        .filter((s) => Object.hasOwn(existing, s) && describePin(existing[s]) !== describePin(incoming[s]))
+        .map((s) => ({ from: describePin(existing[s]), slug: s, to: describePin(incoming[s]) }));
     return { added, merged, updated };
 }
 // WordPress core identifies each plugin by a `<folder>/<file>` id (or a bare `<file>` for a
@@ -47,9 +53,11 @@ managedSlugs = new Set()) {
     const toInstall = [];
     const toPin = [];
     const toActivate = [];
+    const toDeactivate = [];
     const collisions = [];
     const inSync = [];
-    for (const [slug, wanted] of Object.entries(manifest)) {
+    for (const [slug, pin] of Object.entries(manifest)) {
+        const wanted = pinVersion(pin);
         const live = installedMap.get(slug);
         if (!live) {
             toInstall.push({ slug, version: wanted });
@@ -61,12 +69,13 @@ managedSlugs = new Set()) {
             collisions.push({ installedVersion: live.version, slug });
             continue;
         }
-        if (wanted !== 'latest' && live.version !== wanted) {
+        if (isExactVersion(wanted) && live.version !== wanted) {
             toPin.push({ from: live.version, slug, to: wanted });
             continue;
         }
-        if (!live.active) {
-            toActivate.push({ file: live.file, slug });
+        if (live.active !== pinActive(pin)) {
+            ;
+            (live.active ? toDeactivate : toActivate).push({ file: live.file, slug });
             continue;
         }
         inSync.push(slug);
@@ -75,7 +84,7 @@ managedSlugs = new Set()) {
     const untrackedActive = installed
         .filter((p) => p.active && !Object.hasOwn(manifest, p.slug) && !managedSlugs.has(p.slug))
         .map((p) => p.slug);
-    return { collisions, inSync, toActivate, toInstall, toPin, toRemove, untrackedActive };
+    return { collisions, inSync, toActivate, toDeactivate, toInstall, toPin, toRemove, untrackedActive };
 }
 // wpackagist-plugin/<slug> or wpackagist-theme/<slug> entries from a composer.lock string.
 export function lockedWpackagistSlugs(composerLock, kind) {

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

@@ -8,8 +8,10 @@ export declare const RESOURCE_DIR_DEFAULTS: {
     readonly menu: "menus";
     readonly options: "options";
     readonly page: "pages";
+    readonly part: "parts";
     readonly seo: "seo";
     readonly snippets: "snippets";
+    readonly template: "templates";
     readonly themeStyles: "theme";
 };
 export type ResourceDirKind = keyof typeof RESOURCE_DIR_DEFAULTS;

package/dist/utils/resource-dirs.js

@@ -10,8 +10,10 @@ export const RESOURCE_DIR_DEFAULTS = {
     menu: 'menus',
     options: 'options',
     page: 'pages',
+    part: 'parts',
     seo: 'seo',
     snippets: 'snippets',
+    template: 'templates',
     themeStyles: 'theme',
 };
 const CONFIG_KEY = {
@@ -23,8 +25,10 @@ const CONFIG_KEY = {
     menu: 'menuDir',
     options: 'optionsDir',
     page: 'pageDir',
+    part: 'partDir',
     seo: 'seoDir',
     snippets: 'snippetsDir',
+    template: 'templateDir',
     themeStyles: 'themeStylesDir',
 };
 // Resolves where a resource's files live: an explicit override wins, otherwise the

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

@@ -17,13 +17,13 @@ export type RemoteSeoSettings = {
     settings: Record<string, unknown>;
 };
 export type SeoRedirect = {
-    createdAt: string | undefined;
+    createdAt: null | string;
     headerCode: number;
     hits: number;
     id: number;
     sources: unknown;
     status: string;
-    updatedAt: string | undefined;
+    updatedAt: null | string;
     urlTo: string;
 };
 export declare function redirectFileBase(redirect: SeoRedirect): string;

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

@@ -0,0 +1,30 @@
+import { type PageProblem } from './page-format.js';
+export declare const CHILD_THEME_ENDPOINT = "loopress/v1/child-theme";
+export type Template = {
+    html: string;
+    postTypes?: string[];
+    slug: string;
+    title?: string;
+};
+export type Part = {
+    area: string;
+    html: string;
+    slug: string;
+    title: string;
+};
+export type ChildTheme = {
+    active: boolean;
+    customized: string[];
+    exists: boolean;
+    parent: string;
+    parts: Part[];
+    stylesheet: string;
+    templates: Template[];
+};
+export declare function parseTemplateFile(slug: string, raw: string): Template;
+export declare function parsePartFile(slug: string, raw: string): Part;
+export declare function readLocalTemplates(templatesDir: string, partsDir: string): Promise<{
+    parts: Part[];
+    problems: PageProblem[];
+    templates: Template[];
+}>;

package/dist/utils/template-format.js

@@ -0,0 +1,36 @@
+import { parseHtmlHeader, readLocalHtmlFiles, titleFromSlug } from './page-format.js';
+export const CHILD_THEME_ENDPOINT = 'loopress/v1/child-theme';
+// A block delimiter as the first line (`<!-- wp:template-part ... /-->`, the usual one) is markup,
+// not a header.
+const BLOCK_START = /^\s*<!--\s*\/?wp:/;
+// `{"slug":"header","theme":"twentytwentyfive"}` makes WordPress load the named theme's part, so
+// the child's own parts/header.html would be silently ignored.
+const THEMED_PART = /<!--\s*wp:template-part\s+\{[^}]*"theme"\s*:/;
+function parseFile(raw, keys) {
+    const parsed = BLOCK_START.test(raw) ? { body: raw, meta: {} } : parseHtmlHeader(raw, keys);
+    if (THEMED_PART.test(parsed.body)) {
+        throw new Error('a template-part block has a "theme" attribute, remove it: WordPress would load that theme\'s part instead of the one in parts/');
+    }
+    return parsed;
+}
+export function parseTemplateFile(slug, raw) {
+    const { body, meta } = parseFile(raw, ['title', 'postTypes']);
+    const template = { html: body, slug };
+    if (meta.title)
+        template.title = meta.title;
+    if (meta.postTypes)
+        template.postTypes = meta.postTypes.split(',').map((type) => type.trim()).filter(Boolean);
+    return template;
+}
+// `area` defaults from the name, the way themes name their parts: header, header-large-title...
+export function parsePartFile(slug, raw) {
+    const { body, meta } = parseFile(raw, ['title', 'area']);
+    const nameArea = /^(header|footer)(-|$)/.exec(slug)?.[1] ?? 'uncategorized';
+    return { area: meta.area || nameArea, html: body, slug, title: meta.title || titleFromSlug(slug) };
+}
+// Same directory rules as pages/ (flat, `.html` only, strict slugs), every problem at once.
+export async function readLocalTemplates(templatesDir, partsDir) {
+    const templates = await readLocalHtmlFiles(templatesDir, parseTemplateFile);
+    const parts = await readLocalHtmlFiles(partsDir, parsePartFile);
+    return { parts: parts.files, problems: [...templates.problems, ...parts.problems], templates: templates.files };
+}