domma-cms 1.8.4 → 1.8.5

package/server/services/wpImport/index.js

@@ -25,6 +25,10 @@
  * is one the Shop's editor would have made. Without one they are listed as
  * skipped.
  *
+ * A theme's or plugin's own post types (./custom.js) go to collections made
+ * here (wp-<type>, with a list page at the type's old address), to pages, or
+ * nowhere - the person chooses per type in the preview.
+ *
  * The one request hook here answers WordPress's query addresses (/?p=12,
  * /?page_id=7, /?attachment_id=3) from the mapping; path redirects go into
  * SEO's redirect store.
@@ -37,7 +41,7 @@ import fp from 'fastify-plugin';
 import matter from 'gray-matter';
 import {readWxr} from './wxr.js';
 import {openZip, ZipError} from './zip.js';
-import {freeName, isoDate, mediaName, menuItems, originalUploadsPath, planImport, seoFields, uploadsPath} from './plan.js';
+import {freeName, isoDate, mediaName, menuItems, originalUploadsPath, planImport, seoFields, slugify, uploadsPath} from './plan.js';
 import {convertContent} from './convert.js';
 import {currencyDecimals, mergeForUpdate, productFingerprintParts, readWooProducts, shopProductInput} from './woo.js';
 import {fetchMedia, testHostsAllowed} from './fetch.js';
@@ -46,7 +50,8 @@ import {
     stagingMeta, stagingPath, updateStagingMeta
 } from './store.js';
 import {createPage, getPage, listMedia, listPages, resolveExistingFilePath, saveMedia, updatePage} from '../content.js';
-import {createEntry, getCollection, getEntry, listEntries, updateEntry} from '../collections.js';
+import {createCollection, createEntry, getCollection, getEntry, listCollections, listEntries, updateCollection, updateEntry} from '../collections.js';
+import {customEntryData, customFields, customTypesOf, entryFingerprintText, listPageBody, mediaContext, mergeFields, schemaFields, stripShortcodes} from './custom.js';
 import {getPluginStates} from '../plugins.js';
 import {createMenu, getMenu, listMenus, updateMenu} from '../menus.js';
 import {listUsers} from '../users.js';
@@ -183,6 +188,8 @@ async function pageFingerprint(urlPath) {
 }
 
 const postFingerprint = (d) => fingerprint(d?.title, d?.content, d?.excerpt);
+/** A custom type's entry: its non-empty values (a re-save that adds blank fields is not an edit). */
+export const customFingerprint = (d) => fingerprint(entryFingerprintText(d));
 const menuFingerprint = (items) => fingerprint(JSON.stringify(items || []));
 
 /** The site's state as the planner needs it. */
@@ -225,9 +232,18 @@ export async function siteState(mapping = {}) {
             if (d.slug) shop.productSlugs.add(d.slug);
         }
     }
+    // Collections: their slugs (a new one must not take one), and the entries of those an earlier run made.
+    const collections = new Set((await listCollections().catch(() => [])).map(c => c.slug));
+    const customEntries = new Map();
+    for (const m of Object.values(mapping.items || {})) {
+        if (m?.kind !== 'collection' || !m.slug || !collections.has(m.slug) || customEntries.has(m.slug)) continue;
+        const hashes = new Map();
+        for (const e of entriesOf(await listEntries(m.slug, {limit: 100000}).catch(() => []))) hashes.set(e.id, customFingerprint(e.data || {}));
+        customEntries.set(m.slug, hashes);
+    }
     const seo = seoEngine();
     return {
-        pagePaths, pageHashes, shop,
+        pagePaths, pageHashes, shop, collections, customEntries,
         mediaNames: new Set(media.map(m => String(m.name).toLowerCase())),
         menuSlugs: new Set(menus.map(m => m.slug)),
         menuHashes,
@@ -336,10 +352,20 @@ export function cleanOptions(o = {}) {
         redirects: o.redirects !== false,
         drafts: o.drafts !== false,
         products: o.products !== false,
+        types: cleanTypeChoices(o.types, ['collection', 'pages', 'skip']),
+        listPages: cleanTypeChoices(o.listPages, [false]),
         choices
     };
 }
 
+/** {postType: choice} - only real post type names, only the allowed values. */
+function cleanTypeChoices(map, allowed) {
+    const out = {};
+    if (!map || typeof map !== 'object') return out;
+    for (const [k, v] of Object.entries(map).slice(0, 200)) if (/^[a-z0-9_-]{1,40}$/.test(k) && allowed.includes(v)) out[k] = v;
+    return out;
+}
+
 // ---- The run ---------------------------------------------------------------
 
 const jobs = new Map();
@@ -480,8 +506,11 @@ async function runPhases(job, {plan, wxr, oldMapping, meta}, user, log, mapping,
     for (const [aid, m] of mediaById) mapping.query.attachment_id[aid] = m.url;
 
     // Address lookups for content and menus.
-    const targetOf = new Map(plan.items.filter(r => (r.kind === 'page' || r.kind === 'post' || r.kind === 'product') && r.target && r.action !== 'skip').map(r => [r.wpId, r.target]));
-    const oldPathTarget = new Map(plan.items.filter(r => r.oldPath && r.target && r.action !== 'skip').map(r => [r.oldPath, r.target]));
+    // A custom item kept in a collection is reached through its type's list page.
+    const addressOf = (r) => (r.kind === 'custom' && r.as === 'collection' ? r.listAt : r.target);
+    const targetOf = new Map(plan.items.filter(r => (r.kind === 'page' || r.kind === 'post' || r.kind === 'product' || r.kind === 'custom') && !r.listFor && addressOf(r) && r.action !== 'skip').map(r => [r.wpId, addressOf(r)]));
+    const oldPathTarget = new Map(plan.items.filter(r => r.oldPath && addressOf(r) && r.kind !== 'collection' && r.action !== 'skip').map(r => [r.oldPath, addressOf(r)]));
+    const listPageOf = new Map(plan.items.filter(r => r.listFor && r.action !== 'skip' && r.target).map(r => [r.listFor, r.target]));
     const {oldPathOf, basePathOf} = await import('./plan.js');
     const mediaFor = (url) => {
         const rel = uploadsPath(url).toLowerCase();
@@ -545,7 +574,8 @@ async function runPhases(job, {plan, wxr, oldMapping, meta}, user, log, mapping,
         const a = wxr.authors.find(x => x.login === it.creator);
         return (a?.email && userByEmail.get(a.email.toLowerCase())) || user?.id || users[0]?.id || 'import';
     };
-    const docRows = plan.items.filter(r => (r.kind === 'page' || (r.kind === 'post' && !blogMode)));
+    // Pages, posts as pages, and custom items as pages; a type's list page is made with its collection.
+    const docRows = plan.items.filter(r => !r.listFor && (r.kind === 'page' || (r.kind === 'post' && !blogMode) || (r.kind === 'custom' && r.as === 'pages')));
     for (const r of docRows) {
         if (!works(r)) {
             if (r.action === 'keep') { mapping.items[r.key] = oldMapping.items[r.key]; recordQuery(mapping, r); }
@@ -560,7 +590,7 @@ async function runPhases(job, {plan, wxr, oldMapping, meta}, user, log, mapping,
             if (exists && (r.action === 'update')) await updatePage(r.target, fm, conv.body, {author: user?.email || 'WordPress import'});
             else if (exists) throw new Error(`${r.target} was taken while the import ran.`);
             else await createPage(r.target, fm, conv.body);
-            mapping.items[r.key] = {kind: r.kind, path: r.target, hash: await pageFingerprint(r.target), at: new Date().toISOString()};
+            mapping.items[r.key] = {...entryPart(oldMapping.items[r.key]), kind: r.kind, path: r.target, hash: await pageFingerprint(r.target), at: new Date().toISOString()};
             recordQuery(mapping, r);
             set(r.key, {result: r.action === 'update' ? 'updated' : 'created', target: r.target, notes: conv.notes, format: conv.format});
         } catch (err) {
@@ -655,7 +685,93 @@ async function runPhases(job, {plan, wxr, oldMapping, meta}, user, log, mapping,
     }
 
     await checkpoint(true);
-    // ---- 6. Menus ----
+    // ---- 6. Custom post types: collections, their entries, their list pages ----
+    const collectionRows = plan.items.filter(x => x.kind === 'collection');
+    if (collectionRows.length) {
+        job.phase = 'Custom types';
+        const types = new Map(customTypesOf(wxr).content.map(t => [t.type, t.items]));
+        const mediaInfo = mediaContext(wxr);
+        const mediaUrl = (aid) => mediaById.get(aid)?.url || byId.get(aid)?.attachmentUrl || '';
+        for (const crow of collectionRows) {
+            const type = crow.postType;
+            const typeItems = types.get(type) || [];
+            const entryRows = plan.items.filter(x => x.kind === 'custom' && x.postType === type && x.as === 'collection');
+            const listRow = plan.items.find(x => x.listFor === type);
+            const fields = customFields(typeItems, mediaInfo);
+            let slug = '';
+            if (crow.action === 'skip') {
+                set(crow.key, {result: 'skipped', target: crow.target});
+            } else {
+                try {
+                    const offered = Array.isArray(oldMapping.items[crow.key]?.fields) ? oldMapping.items[crow.key].fields : [];
+                    slug = await ensureCollection(crow, type, fields, offered);
+                    // Every field ever offered, so one the person removes is not offered again.
+                    mapping.items[crow.key] = {kind: 'collection', slug, postType: type, fields: [...new Set([...offered, ...fields.map(f => f.name)])], at: new Date().toISOString()};
+                    set(crow.key, {result: crow.action === 'update' ? 'updated' : 'created', target: slug});
+                } catch (err) {
+                    set(crow.key, {result: 'failed', error: err.message || String(err)});
+                }
+                await step(crow.title);
+            }
+            for (const r of entryRows) {
+                if (!works(r)) {
+                    if (r.action === 'keep') { mapping.items[r.key] = oldMapping.items[r.key]; if (r.listAt) mapping.query.p[r.wpId] = r.listAt; }
+                    set(r.key, {result: r.action === 'keep' ? 'kept' : 'skipped', target: r.action === 'keep' ? r.listAt || '' : ''});
+                    continue;
+                }
+                try {
+                    if (!slug) throw new Error('Its collection could not be made.');
+                    const it = byId.get(r.wpId);
+                    const conv = convert(it);
+                    const {data, notes} = customEntryData(it, fields, {
+                        title: clip(titleText(it.title), 200) || `Untitled ${crow.title.toLowerCase()} ${it.id}`,
+                        slug: slugify(it.slug) || slugify(it.title) || String(it.id),
+                        body: conv.body,
+                        excerpt: clip(stripShortcodes(plainText(it.excerpt)), 1000),
+                        date: isoDate(it.dateGmt, it.date),
+                        status: r.status === 'published' ? 'published' : 'draft',
+                        mediaUrl, mediaFor
+                    });
+                    let entry;
+                    const now = r.action === 'update' && r.entryId ? await getEntry(slug, r.entryId) : null;
+                    if (now) entry = await updateEntry(slug, r.entryId, {...(now.data || {}), ...data});
+                    else entry = await createEntry(slug, data, {createdBy: user?.id || null, source: 'import'});
+                    mapping.items[r.key] = {...pagePart(oldMapping.items[r.key]), kind: 'custom', collection: slug, entryId: entry.id, entryHash: customFingerprint(entry.data), at: new Date().toISOString()};
+                    if (r.listAt) mapping.query.p[r.wpId] = r.listAt;
+                    set(r.key, {result: now ? 'updated' : 'created', target: r.listAt || '', entryId: entry.id, collection: slug, notes: [...conv.notes, ...notes], format: conv.format});
+                } catch (err) {
+                    set(r.key, {result: 'failed', error: err.message || String(err)});
+                }
+                await step(r.title);
+            }
+            if (!listRow) continue;
+            if (!works(listRow)) {
+                if (listRow.action === 'keep') mapping.items[listRow.key] = oldMapping.items[listRow.key];
+                set(listRow.key, {result: listRow.action === 'keep' ? 'kept' : 'skipped', target: listRow.target});
+                continue;
+            }
+            try {
+                if (!slug) throw new Error('Its collection could not be made.');
+                const fm = {
+                    title: clip(listRow.pageTitle || crow.title, 200), description: '', status: 'published', sortOrder: 99,
+                    importedFrom: {source: 'wordpress', postType: type, url: ''}
+                };
+                const body = listPageBody(slug, fields);
+                const exists = await getPage(listRow.target).catch(() => null);
+                if (exists && listRow.action === 'update') await updatePage(listRow.target, fm, body, {author: user?.email || 'WordPress import'});
+                else if (exists) throw new Error(`${listRow.target} was taken while the import ran.`);
+                else await createPage(listRow.target, fm, body);
+                mapping.items[listRow.key] = {kind: 'page', path: listRow.target, hash: await pageFingerprint(listRow.target), at: new Date().toISOString()};
+                set(listRow.key, {result: listRow.action === 'update' ? 'updated' : 'created', target: listRow.target});
+            } catch (err) {
+                set(listRow.key, {result: 'failed', error: err.message || String(err)});
+            }
+            await step(listRow.title);
+        }
+    }
+
+    await checkpoint(true);
+    // ---- 7. Menus ----
     job.phase = 'Menus';
     const categoryAddress = new Map(plan.items.filter(r => r.kind === 'category' && r.action !== 'skip').map(r => [r.slug, r.target]));
     for (const r of plan.redirects) if (r.key.startsWith('product_cat:')) categoryAddress.set(r.key, r.to);
@@ -667,7 +783,9 @@ async function runPhases(job, {plan, wxr, oldMapping, meta}, user, log, mapping,
         }
         try {
             const wpSlug = r.key.slice(5);
-            const items = menuItems(wxr, wpSlug, (wpId) => (wpId === 'archive' ? plan.blogBase : targetOf.get(wpId) || null), linkFor, categoryAddress);
+            const items = menuItems(wxr, wpSlug, (wpId) => (wpId === 'archive' ? plan.blogBase
+                : wpId === 'archive:product' ? (plan.summary.products?.shop?.available ? plan.shopBase : null)
+                    : String(wpId).startsWith('archive:') ? listPageOf.get(String(wpId).slice(8)) || null : targetOf.get(wpId) || null), linkFor, categoryAddress);
             const name = clip(r.title, 100) || r.slug;
             const existing = await getMenu(r.slug);
             if (existing && r.action === 'update') await updateMenu(r.slug, {...existing, items});
@@ -682,14 +800,29 @@ async function runPhases(job, {plan, wxr, oldMapping, meta}, user, log, mapping,
     }
 
     await checkpoint(true);
-    // ---- 7. Redirects ----
+    // ---- 8. Redirects ----
     job.phase = 'Redirects';
     const seo = seoEngine();
     const redirectResults = [];
     const failedTargets = new Set([...results.entries()].filter(([, v]) => v.result === 'failed').map(([k]) => rows.get(k)?.target).filter(Boolean));
+    // A redirect an earlier run added FROM an address this run gave a page (a custom type moved from a
+    // collection to pages, say) would hide that page: it goes, unless this run plans it again.
+    if (seo) {
+        const madeAt = new Set([...results.entries()].filter(([, v]) => ['created', 'updated', 'kept'].includes(v.result))
+            .map(([k, v]) => v.target || rows.get(k)?.target).filter(t => typeof t === 'string' && t.startsWith('/')));
+        const planned = new Set(plan.redirects.filter(r => r.action !== 'skip').map(r => r.key));
+        for (const [key, own] of Object.entries(mapping.redirects)) {
+            if (planned.has(key)) continue;
+            const rule = seo.store.rules().find(x => x.id === own?.id);
+            if (!rule || !madeAt.has(rule.from)) continue;
+            seo.removeRules([rule.id]);
+            delete mapping.redirects[key];
+            redirectResults.push({from: rule.from, to: rule.to, key, action: 'remove', result: 'removed', reason: 'An imported page has that address now.'});
+        }
+    }
     for (const r of plan.redirects) {
         if (r.action === 'skip' || !seo) { redirectResults.push({...r, result: 'skipped'}); continue; }
-        if (failedTargets.has(r.to)) { redirectResults.push({...r, result: 'skipped', reason: 'What it would lead to was not imported.'}); await step(r.from); continue; }
+        if (failedTargets.has(r.to) || results.get(r.key)?.result === 'failed') { redirectResults.push({...r, result: 'skipped', reason: 'What it would lead to was not imported.'}); await step(r.from); continue; }
         try {
             const own = mapping.redirects[r.key];
             const rule = own && seo.store.rules().find(x => x.id === own.id);
@@ -705,7 +838,7 @@ async function runPhases(job, {plan, wxr, oldMapping, meta}, user, log, mapping,
         await step(r.from);
     }
 
-    // ---- 8. Save the mapping, the report, the history ----
+    // ---- 9. Save the mapping, the report, the history ----
     job.phase = 'Finishing';
     await saveMapping(plan.source, mapping);
     forgetMapCache();
@@ -719,6 +852,42 @@ async function runPhases(job, {plan, wxr, oldMapping, meta}, user, log, mapping,
     log.info?.(`[wordpress-import] ${plan.site.title || plan.source}: ${JSON.stringify(report.run.summary)}`);
 }
 
+/**
+ * The collection a custom type goes to: made the first time, used again after.
+ * An existing one only gains fields - the person may have changed or removed
+ * the ones they did not want, and those are theirs.
+ *
+ * @returns {Promise<string>} its slug
+ */
+async function ensureCollection(row, type, fields, offered = []) {
+    const wanted = schemaFields(fields);
+    const existing = await getCollection(row.target);
+    if (existing && row.action === 'update') {
+        const {fields: next, added} = mergeFields(existing.fields || [], wanted, offered);
+        if (added.length) await updateCollection(row.target, {fields: next, ...(existing.bundled && {bundled: true})});
+        return existing.slug;
+    }
+    if (existing) throw new Error(`A collection called ${row.target} was made while the import ran.`);
+    const made = await createCollection({
+        title: row.title,
+        slug: row.target,
+        description: `Imported from WordPress (its "${type}" post type).`,
+        fields: wanted,
+        // Read through the site's own displays only: entries include drafts, and the list page shows the published ones.
+        api: {read: {enabled: false, access: 'admin'}},
+        meta: {importedFrom: {source: 'wordpress', postType: type}}
+    });
+    return made.slug;
+}
+
+/**
+ * A custom item can be a page in one run and an entry in the next (the person changed the type's
+ * choice). Its mapping keeps both halves, so switching back finds what was made before rather than
+ * making it twice: the page's {path, hash} and the entry's {collection, entryId, entryHash}.
+ */
+const pagePart = (m) => (m?.path ? {path: m.path, hash: m.hash} : {});
+const entryPart = (m) => (m?.entryId && m.collection ? {collection: m.collection, entryId: m.entryId, entryHash: m.entryHash} : {});
+
 /** ?p= for a product, and for each of its variations, leads to the product. */
 function recordProductQuery(mapping, target, p) {
     if (!target || !p) return;
@@ -727,7 +896,8 @@ function recordProductQuery(mapping, target, p) {
 }
 
 function recordQuery(mapping, r) {
-    if (!r.target) return;
+    if (!r.target || !r.wpId) return;
+    if (r.kind === 'custom') mapping.query.p[r.wpId] = r.target;
     if (r.kind === 'page') { mapping.query.page_id[r.wpId] = r.target; mapping.query.p[r.wpId] = r.target; }
     if (r.kind === 'post') mapping.query.p[r.wpId] = r.target;
 }
@@ -806,6 +976,14 @@ export function pageFrontmatter(it, r, plan, wxr) {
         seo: Object.fromEntries(Object.entries({...seo, description: seo.description || ''}).filter(([, v]) => v !== '')),
         importedFrom: {source: 'wordpress', id: it.id, url: clip(it.link, 500)}
     };
+    if (r.kind === 'custom') {
+        // A custom type's taxonomies (and any categories and tags) become the page's tags.
+        const tags = [...new Set(it.terms.filter(t => !['nav_menu', 'post_format'].includes(t.domain)).map(t => clip(t.name || t.slug, 60)).filter(Boolean))];
+        if (tags.length) fm.tags = tags.slice(0, 30);
+        const date = isoDate(it.dateGmt, it.date);
+        if (date) fm.date = date;
+        fm.importedFrom.postType = it.type;
+    }
     if (r.kind === 'post') {
         const tags = it.terms.filter(t => t.domain === 'post_tag').map(t => clip(t.name || t.slug, 60)).filter(Boolean);
         if (tags.length) fm.tags = tags;
@@ -875,7 +1053,9 @@ function buildReport({job, plan, results, redirectResults, meta, user, started,
             key: r.key, kind: r.kind, title: r.title, wpId: r.wpId, oldUrl: r.oldUrl || '', target: res.target || r.target || '',
             planned: r.action, result: res.result, reason: res.error || r.reason || '',
             shortcodes: r.shortcodes || [], builder: r.builder || '', needs: r.needs || '', notes: res.notes || [], format: res.format || '',
-            ...(res.entryId && {entryId: res.entryId})
+            ...(res.entryId && {entryId: res.entryId}),
+            ...((res.collection || r.collection) && {collection: res.collection || r.collection}),
+            ...(r.postType && {postType: r.postType})
         };
     });
     const tally = {};

package/server/services/wpImport/plan.js

@@ -16,7 +16,10 @@
  * (/blog/<slug>), as Blog posts or - without the Blog - as pages there.
  * WooCommerce products go to the Shop (<shop>/<slug>) when one is switched on
  * (see ./woo.js); WooCommerce's own cart, checkout, account and shop pages are
- * then not imported - their old addresses lead to the Shop's.
+ * then not imported - their old addresses lead to the Shop's. A theme's or
+ * plugin's own post types (./custom.js) become a collection with a list page
+ * at their old address (default), pages, or nothing; WordPress's plumbing is
+ * listed with the reason it is not imported (summary.customTypes / internalTypes).
  *
  * @module services/wpImport/plan
  */
@@ -24,14 +27,10 @@ import {detectBuilder, findShortcodes} from './convert.js';
 import {hostOf} from './wxr.js';
 import {FETCH_PORTS, portOf} from './fetch.js';
 import {readWooProducts, shopProductInput, wooPageRole} from './woo.js';
+import {customFields, customOldPath, customTypesOf, mediaContext, rewriteSlugOf, typeLabel} from './custom.js';
 
 /** Addresses under the Shop's that are its own pages, never a product's. */
 const SHOP_RESERVED = ['cart', 'checkout', 'basket', 'account', 'order'];
-/** WooCommerce content types that are records, not content - never imported, and said so. */
-const WOO_RECORDS = {
-    shop_order: 'orders', shop_order_placehold: 'orders', shop_order_refund: 'refunds', shop_coupon: 'coupons',
-    shop_subscription: 'subscriptions', shop_webhook: 'webhooks', wc_user_membership: 'memberships'
-};
 
 export const MEDIA_EXTENSIONS = new Set(['jpg', 'jpeg', 'png', 'gif', 'webp', 'avif', 'bmp', 'ico', 'tif', 'tiff',
     'pdf', 'txt', 'csv', 'doc', 'docx', 'xls', 'xlsx', 'mp4', 'webm', 'ogv', 'mp3', 'ogg', 'wav']);
@@ -184,6 +183,8 @@ export function isoDate(gmt, local) {
  * @param {Set<string>} site.menuSlugs
  * @param {{available: boolean, basePath: string, posts: Map<string,{slug, hash}>, postSlugs: Set<string>, categories: Map<string,string>}} site.blog
  * @param {{available: boolean, reason?: string, basePath: string, currency: string, decimals: number, products: Map<string,{slug, hash}>, productSlugs: Set<string>}} [site.shop]
+ * @param {Set<string>} [site.collections]   - every collection's slug
+ * @param {Map<string,Map<string,string>>} [site.customEntries] - collection slug -> entry id -> fingerprint (collections an import made)
  * @param {boolean} site.redirectsAvailable  - SEO is running (its redirects take the old addresses)
  * @param {Set<string>} site.redirectFroms   - addresses that already redirect
  * @param {object} [mapping] - what earlier runs of this import made ({items: {key: {...}}})
@@ -196,6 +197,8 @@ export function isoDate(gmt, local) {
  * @param {boolean} [options.drafts=true] - import drafts, pending and private items (as drafts)
  * @param {boolean} [options.products=true] - WooCommerce products to the Shop (when one is on)
  * @param {number} [options.now] - the time sales are judged at (tests)
+ * @param {Object<string,'collection'|'pages'|'skip'>} [options.types] - per custom post type (default collection)
+ * @param {Object<string,false>} [options.listPages] - a custom type's list page left out
  * @param {Object<string,'skip'|'overwrite'|'import'>} [options.choices] - per item key
  * @param {Set<string>|null} [options.zipPaths] - uploads-relative paths in the uploaded zip
  * @returns {object}
@@ -204,8 +207,11 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
     const opt = {
         posts: site.blog?.available ? 'blog' : 'pages',
         media: 'download', comments: true, menus: true, redirects: true, drafts: true, products: true, choices: {}, zipPaths: null,
+        types: {}, listPages: {},
         ...options
     };
+    opt.types ||= {};
+    opt.listPages ||= {};
     if (opt.posts === 'blog' && !site.blog?.available) opt.posts = 'pages';
     const choices = opt.choices || {};
     const mapped = mapping.items || {};
@@ -360,16 +366,84 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
         else live({...row, action: 'create', target: shopAt(`/${free}`), slug: free, reason: said.trim()});
     }
 
-    // Everything else WordPress exports, counted so nothing vanishes silently.
-    const others = {};
+    // ---- Custom post types: a theme's or plugin's own content ----
+    // Everything else WordPress exports is either content (offered: a collection, pages, or left out)
+    // or plumbing (listed once with the reason, never offered) - so nothing vanishes silently.
+    const {content: customContent, internal: internalTypes} = customTypesOf(wxr);
     const records = {};
-    for (const it of wxr.items) {
-        if (['page', 'post', 'attachment', 'nav_menu_item', 'product', 'product_variation'].includes(it.type)) continue;
-        if (WOO_RECORDS[it.type]) { records[WOO_RECORDS[it.type]] = (records[WOO_RECORDS[it.type]] || 0) + 1; continue; }
-        others[it.type] = (others[it.type] || 0) + 1;
-    }
-    for (const [type, n] of Object.entries(others)) {
-        notes.push(`${n} "${type}" item${n === 1 ? '' : 's'} (a theme or plugin's own content type) ${n === 1 ? 'is' : 'are'} not imported.`);
+    for (const t of internalTypes) if (t.record) records[t.record] = (records[t.record] || 0) + t.count;
+    const mediaInfo = mediaContext(wxr);
+    const takenCollections = new Set(site.collections || []);
+    const customTypes = [];
+    for (const {type, items: typeItems} of customContent) {
+        const as = ['collection', 'pages', 'skip'].includes(opt.types[type]) ? opt.types[type] : 'collection';
+        const label = typeLabel(type);
+        const rewrite = rewriteSlugOf(typeItems, wxr.site, base);
+        // The type's address here: its old one when the links show it, else its name (said so in the preview).
+        // Never the home page: a type named only "_" or "-" has nothing to make an address of.
+        const prefix = cleanPath(rewrite || type) === '/' ? `/items-${customContent.findIndex(t => t.type === type) + 1}` : cleanPath(rewrite || type);
+        const fields = customFields(typeItems, mediaInfo);
+        const info = {
+            type, label, count: typeItems.length, as, rewrite, prefix,
+            samples: typeItems.filter(i => i.title && !['trash', 'auto-draft', 'inherit'].includes(i.status)).slice(0, 3).map(i => String(i.title).slice(0, 80)),
+            fields: fields.map(f => ({name: f.name, label: f.label, type: f.type, from: f.from.kind})),
+            taxonomies: fields.filter(f => f.from.kind === 'tax').map(f => f.from.key),
+            listPage: as === 'collection' && opt.listPages[type] !== false,
+            listAt: '', listAction: '', collection: null
+        };
+        if (as === 'collection') {
+            const ckey = `collection:${type}`;
+            const was = mapped[ckey];
+            const wanted = `wp-${slugify(type) || prefix.slice(1)}`.slice(0, 60);
+            const crow = {key: ckey, kind: 'collection', wpId: 0, title: label, postType: type, count: typeItems.length, fields: fields.length};
+            let gone = false;
+            if (choices[ckey] === 'skip') { push({...crow, action: 'skip', target: was?.slug || wanted, reason: 'You chose to skip it.'}); gone = true; }
+            else if (was?.slug && takenCollections.has(was.slug)) {
+                push({...crow, action: 'update', target: was.slug, slug: was.slug, reason: 'Made by an earlier import - used again; it only gains fields, never loses them.'});
+            } else if (was?.slug && choices[ckey] !== 'import') {
+                push({...crow, action: 'skip', target: was.slug, reason: 'Deleted on this site since it was imported - choose "Import again" to bring it back.'});
+                gone = true;
+            } else {
+                const slug = freePath(was?.slug || wanted, takenCollections);
+                const action = slug === (was?.slug || wanted) ? 'create' : 'rename';
+                push({...crow, action, target: slug, slug, wanted,
+                    reason: was?.slug ? 'Imported again after being deleted here.' : action === 'rename' ? `This site has a collection called ${wanted} - this one is ${slug}.` : ''});
+            }
+            const crowNow = items[items.length - 1];
+            if (!gone) takenCollections.add(crowNow.slug);
+            info.collection = {slug: crowNow.target, action: crowNow.action};
+            let listAt = '';
+            if (info.listPage && !gone) {
+                const lrow = planDocument({it: {id: 0, title: label, link: '', status: 'publish', content: '', meta: {}, terms: [], password: ''},
+                    key: `typepage:${type}`, kind: 'page', wanted: prefix, oldPath: null, statusMap: PAGE_STATUS});
+                lrow.listFor = type;
+                lrow.wpId = 0;
+                // Its heading: the old address spelled out ("events" -> "Events") - WordPress names types in the singular.
+                lrow.pageTitle = rewrite ? typeLabel(rewrite.split('/').pop()) : label;
+                lrow.title = `${lrow.pageTitle} - list page`;
+                lrow.oldPath = rewrite ? `${base}${prefix}` : null;
+                lrow.oldUrl = '';
+                if (lrow.action === 'create' && !lrow.reason) lrow.reason = `Lists what is published in the collection ${crowNow.target}.`;
+                if (lrow.action !== 'skip') listAt = lrow.target;
+                info.listAction = lrow.action;
+            }
+            info.listAt = listAt;
+            for (const it of typeItems) planCustomEntry(it, type, gone ? '' : crowNow.target, listAt);
+        } else if (as === 'pages') {
+            for (const it of typeItems) {
+                const s = slugify(it.slug) || slugify(it.title) || `${slugify(type) || 'item'}-${it.id}`;
+                const row = planDocument({it, key: `custom:${it.id}`, kind: 'custom', wanted: `${prefix === '/' ? '' : prefix}/${s}`, oldPath: customOldPath(it, wxr.site, base), statusMap: PAGE_STATUS});
+                row.as = 'pages';
+                row.postType = type;
+            }
+        } else {
+            for (const it of typeItems) push({...docRow(it, `custom:${it.id}`, 'custom', customOldPath(it, wxr.site, base)), as: 'skip', postType: type, action: 'skip', reason: `${label} are not being imported.`});
+        }
+        const rows = items.filter(r => r.kind === 'custom' && r.postType === type);
+        info.importing = rows.filter(r => r.action !== 'skip').length;
+        info.drafts = rows.filter(r => r.action !== 'skip' && r.status === 'draft').length;
+        info.kept = rows.filter(r => r.action === 'keep').length;
+        customTypes.push(info);
     }
     // What the Products section of the preview says (and the report keeps).
     const productNotes = [];
@@ -439,8 +513,21 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
     const query = {p: {}, page_id: {}, attachment_id: {}};
     const live = (r) => r.target && r.action !== 'skip';
     for (const r of items) {
+        // An entry in a collection has no address of its own: its old one leads to the type's list page.
+        if (r.kind === 'custom' && r.as === 'collection' && r.action !== 'skip') {
+            if (r.listAt) query.p[r.wpId] = r.listAt;
+            if (r.oldPath) redirects.push({from: r.oldPath, to: r.listAt, key: r.key});
+            continue;
+        }
         if (!live(r)) continue;
-        if (r.kind === 'page' || r.kind === 'post') {
+        if (r.listFor) {
+            if (r.oldPath && r.oldPath !== r.target) redirects.push({from: r.oldPath, to: r.target, key: `${r.key}/archive`});
+            continue;
+        }
+        if (r.kind === 'custom') {
+            query.p[r.wpId] = r.target;
+            if (r.oldPath && r.oldPath !== r.target) redirects.push({from: r.oldPath, to: r.target, key: r.key});
+        } else if (r.kind === 'page' || r.kind === 'post') {
             query[r.kind === 'page' ? 'page_id' : 'p'][r.wpId] = r.target;
             if (r.kind === 'page') query.p[r.wpId] = r.target;
             if (r.oldPath && r.oldPath !== r.target) redirects.push({from: r.oldPath, to: r.target, key: r.key});
@@ -520,6 +607,7 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
         let action = 'create';
         let reason = '';
         if (!opt.redirects) { action = 'skip'; reason = 'Redirects are not being added.'; }
+        else if (!to) { action = 'skip'; reason = 'Its type has no list page to lead to - switch the list page on to give these old addresses a home.'; }
         else if (!site.redirectsAvailable) { action = 'skip'; reason = 'SEO is switched off on this site, so redirects cannot be added.'; }
         else if (from === normalisePath(to)) { action = 'skip'; reason = 'Same address.'; }
         else if (from === '/' || from === '/*') { action = 'skip'; reason = 'That would redirect the home page.'; }
@@ -541,6 +629,8 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
         redirects: redirectPlan.filter(r => r.action !== 'skip').length,
         shortcodes: shortcodeCount,
         builders: items.filter(r => r.builder).length,
+        customTypes,
+        internalTypes,
         products: {
             total: wooProducts.length,
             types: productTypes,
@@ -609,6 +699,30 @@ export function planImport(wxr, site, mapping = {}, options = {}) {
         if (clash) return push({...row, action: 'rename', target, wanted, reason: `${wanted} is taken on this site - imported as ${target}.`});
         return push({...row, action: 'create', target});
     }
+    function planCustomEntry(it, type, collection, listAt) {
+        const key = `custom:${it.id}`;
+        const row = {...docRow(it, key, 'custom', customOldPath(it, wxr.site, base)), as: 'collection', postType: type, collection, listAt,
+            status: it.password ? 'draft' : (PAGE_STATUS[it.status] || 'draft')};
+        const was = mapped[key];
+        const why = excluded(it);
+        if (!collection) return push({...row, action: 'skip', reason: 'Its collection is not being made.'});
+        if (choices[key] === 'skip') return push({...row, action: 'skip', reason: 'You chose to skip it.'});
+        if (why) return push({...row, action: 'skip', reason: why});
+        // Entries an earlier run made are only looked for in a collection still here: one being made
+        // again (deleted, then "Import again") gets them all back as new.
+        if (was?.entryId && was.collection === collection && site.customEntries?.has(collection)) {
+            const nowHash = site.customEntries?.get(collection)?.get(was.entryId);
+            if (nowHash === undefined) {
+                if (choices[key] !== 'import') return push({...row, action: 'skip', reason: 'Deleted from the collection since it was imported - choose "Import again" to bring it back.'});
+                return push({...row, action: 'create', reason: 'Imported again after being deleted here.'});
+            }
+            const edited = nowHash !== was.entryHash;
+            if (edited && choices[key] !== 'overwrite') return push({...row, action: 'keep', entryId: was.entryId, reason: 'Edited in the collection since it was imported - left as it is.'});
+            return push({...row, action: 'update', entryId: was.entryId, reason: edited ? 'Edited here since - you chose to overwrite it.' : ''});
+        }
+        if (it.password) row.reason = 'It was password-protected in WordPress - imported as a draft.';
+        return push({...row, action: 'create'});
+    }
     function planBlogPost({it, key, slug, oldPath}) {
         const row = docRow(it, key, 'post', oldPath);
         row.status = it.password ? 'draft' : (POST_STATUS[it.status] || 'draft');
@@ -682,7 +796,9 @@ export function menuItems(wxr, menuSlug, addressFor, linkFor, categoryAddress =
                 if (!text) text = term.name;
             }
         } else if (m._menu_item_type === 'post_type_archive') {
-            url = addressFor('archive');
+            // A custom type's archive leads to its list page; the posts' archive to the Blog.
+            const obj = String(m._menu_item_object || '');
+            url = addressFor(obj && obj !== 'post' ? `archive:${obj}` : 'archive');
         } else {
             const raw = String(m._menu_item_url || '').trim();
             url = linkFor(raw) || (/^(https?:|mailto:|tel:|\/|#)/i.test(raw) ? raw : null);