domma-cms 1.8.1 → 1.8.3

package/server/services/wpImport/woo.js

@@ -0,0 +1,554 @@
+/**
+ * WooCommerce products in a WordPress export, and what each becomes in the
+ * Shop. PURE: no I/O - the runner supplies the converted description, the
+ * media addresses and the Shop's currency.
+ *
+ * What WooCommerce keeps where (all in the WXR):
+ *   product            an item; its type is a `product_type` term (simple,
+ *                      variable, grouped, external), its categories and tags
+ *                      `product_cat` / `product_tag` terms, attribute values
+ *                      `pa_*` terms, "featured" a `product_visibility` term
+ *   product_variation  an item whose parent is the product; `attribute_<key>`
+ *                      meta names its value for each variation attribute
+ *   postmeta           _regular_price, _sale_price (+ _sale_price_dates_from/to),
+ *                      _price, _sku, _manage_stock, _stock, _stock_status,
+ *                      _weight, _virtual, _downloadable, _tax_status,
+ *                      _tax_class, _thumbnail_id, _product_image_gallery,
+ *                      _product_url (external), _children (grouped, serialised)
+ *                      and _product_attributes (PHP-serialised)
+ *
+ * PHP-serialised values are read by `unserializePhp` - arrays, strings,
+ * numbers, booleans and null only. Objects (O:, C:), references and enums are
+ * refused, as is anything too long or too deep: an export is untrusted input.
+ *
+ * @module services/wpImport/woo
+ */
+
+export const PRODUCT_TYPES = ['simple', 'variable', 'grouped', 'external'];
+
+/** Limits for one serialised value. */
+export const SERIAL_LIMITS = Object.freeze({maxLength: 65536, maxDepth: 6, maxItems: 2000});
+
+export class SerialError extends Error {}
+
+/**
+ * Read a PHP-serialised value - safely.
+ *
+ * Arrays whose keys are 0..n-1 in order become JS arrays; any other array
+ * becomes a prototype-less object (so a "__proto__" key is just a key).
+ *
+ * @param {string} text
+ * @param {Partial<typeof SERIAL_LIMITS>} [limits]
+ * @returns {*}
+ * @throws {SerialError} on anything but arrays, strings, ints, floats, bools and null
+ */
+export function unserializePhp(text, limits = {}) {
+    const lim = {...SERIAL_LIMITS, ...limits};
+    const src = String(text ?? '');
+    if (src.length > lim.maxLength) throw new SerialError('The value is too long.');
+    const buf = Buffer.from(src, 'utf8');
+    if (buf.length > lim.maxLength * 4) throw new SerialError('The value is too long.');
+    let at = 0;
+    let items = 0;
+
+    const fail = (why) => { throw new SerialError(`${why} at character ${at}`); };
+    const expect = (ch) => { if (buf[at] !== ch.charCodeAt(0)) fail(`Expected "${ch}"`); at++; };
+    const until = (ch) => {
+        const end = buf.indexOf(ch.charCodeAt(0), at);
+        if (end === -1 || end - at > 24) fail(`Expected "${ch}"`);
+        const s = buf.toString('latin1', at, end);
+        at = end + 1;
+        return s;
+    };
+    const intText = (s) => {
+        if (!/^[+-]?\d{1,18}$/.test(s)) fail('Not a whole number');
+        const n = Number(s);
+        if (!Number.isSafeInteger(n)) fail('A number too large');
+        return n;
+    };
+
+    function value(depth) {
+        if (depth > lim.maxDepth) fail('Nested too deep');
+        if (++items > lim.maxItems) fail('Too many values');
+        const type = String.fromCharCode(buf[at] ?? 0);
+        at++;
+        switch (type) {
+            case 'N': expect(';'); return null;
+            case 'b': {
+                expect(':');
+                const s = until(';');
+                if (s !== '0' && s !== '1') fail('Not a boolean');
+                return s === '1';
+            }
+            case 'i': expect(':'); return intText(until(';'));
+            case 'd': {
+                expect(':');
+                const s = until(';');
+                if (!/^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/.test(s)) fail('Not a number');
+                return Number(s);
+            }
+            case 's': {
+                expect(':');
+                const len = intText(until(':'));
+                if (len < 0 || at + 1 + len + 2 > buf.length) fail('A string runs past the end');
+                expect('"');
+                const s = buf.toString('utf8', at, at + len);
+                at += len;
+                expect('"');
+                expect(';');
+                return s;
+            }
+            case 'a': {
+                expect(':');
+                const n = intText(until(':'));
+                if (n < 0 || n > lim.maxItems) fail('Too many values');
+                expect('{');
+                const keys = [];
+                const vals = [];
+                for (let i = 0; i < n; i++) {
+                    const kt = String.fromCharCode(buf[at] ?? 0);
+                    if (kt !== 'i' && kt !== 's') fail('An array key must be a number or a string');
+                    const k = value(depth + 1);
+                    keys.push(k);
+                    vals.push(value(depth + 1));
+                }
+                expect('}');
+                if (keys.every((k, i) => k === i)) return vals;
+                const out = Object.create(null);
+                keys.forEach((k, i) => { out[String(k)] = vals[i]; });
+                return out;
+            }
+            case 'O': case 'C': fail('Objects are refused'); break;
+            case 'r': case 'R': fail('References are refused'); break;
+            case 'E': fail('Enums are refused'); break;
+            default: fail('Not a serialised value');
+        }
+        return undefined;
+    }
+
+    const out = value(0);
+    if (at !== buf.length) fail('Something follows the value');
+    return out;
+}
+
+/** unserializePhp that answers {value, error} instead of throwing. */
+export function readSerialised(text, limits) {
+    const s = String(text ?? '').trim();
+    if (!s) return {value: null, error: ''};
+    try { return {value: unserializePhp(s, limits), error: ''}; } catch (err) { return {value: null, error: err.message}; }
+}
+
+const int = (v) => {
+    const n = Number.parseInt(String(v ?? '').trim(), 10);
+    return Number.isFinite(n) ? n : null;
+};
+
+/** "pa_colour-name" -> "Colour name". */
+export function attributeLabel(key) {
+    const s = String(key || '').replace(/^pa_/, '').replace(/[-_]+/g, ' ').trim();
+    return s ? s[0].toUpperCase() + s.slice(1) : 'Option';
+}
+
+/** WooCommerce's sanitize_title for an attribute name (the key its variations use). */
+const attrKey = (name) => String(name || '').toLowerCase().normalize('NFKD').replace(/[̀-ͯ]/g, '')
+    .replace(/[^a-z0-9_ -]/g, '').trim().replace(/\s+/g, '-');
+
+/** An attribute key as compared: WordPress percent-encodes non-Latin ones ("%d1%80…"), in either case. */
+const keyText = (k) => {
+    const s = String(k || '');
+    try { return decodeURIComponent(s).toLowerCase(); } catch { return s.toLowerCase(); }
+};
+
+/**
+ * Every WooCommerce product in an export, as plain data.
+ *
+ * @param {object} wxr - from readWxr()
+ * @returns {object[]}
+ */
+export function readWooProducts(wxr) {
+    const termName = new Map();
+    for (const t of wxr.terms || []) termName.set(`${t.taxonomy}\0${t.slug}`, t.name || t.slug);
+    const variationsOf = new Map();
+    for (const it of wxr.items) {
+        if (it.type !== 'product_variation') continue;
+        if (!variationsOf.has(it.parent)) variationsOf.set(it.parent, []);
+        variationsOf.get(it.parent).push(it);
+    }
+    return wxr.items.filter(i => i.type === 'product').map((it) => {
+        const m = it.meta || {};
+        const problems = [];
+        const terms = (domain) => it.terms.filter(t => t.domain === domain);
+        for (const t of it.terms) if (t.slug && !termName.has(`${t.domain}\0${t.slug}`)) termName.set(`${t.domain}\0${t.slug}`, t.name || t.slug);
+
+        const attrsRaw = readSerialised(m._product_attributes);
+        if (attrsRaw.error) problems.push(`its attributes could not be read: ${attrsRaw.error}`);
+        const attributes = [];
+        const list = Array.isArray(attrsRaw.value) ? attrsRaw.value : (attrsRaw.value && typeof attrsRaw.value === 'object' ? Object.entries(attrsRaw.value).map(([k, v]) => ({...(v && typeof v === 'object' ? v : {}), __key: k})) : []);
+        for (const a of list.slice(0, 40)) {
+            if (!a || typeof a !== 'object') continue;
+            const taxonomy = Number(a.is_taxonomy) === 1 || a.is_taxonomy === true;
+            // A custom attribute's array key is WooCommerce's own sanitize_title of its name - the key its
+            // variations use - so it is kept as it is (only lower-cased): a non-Latin name's is percent-encoded.
+            const own = String(a.__key || '').trim();
+            const key = taxonomy ? String(a.name || a.__key || '') : ((/^[a-z0-9_%-]+$/i.test(own) ? own.toLowerCase() : attrKey(own || a.name)) || keyText(own || a.name).trim());
+            if (!key) continue;
+            const values = taxonomy
+                ? terms(key).map(t => t.name || t.slug)
+                : String(a.value ?? '').split('|').map(s => s.trim()).filter(Boolean);
+            attributes.push({
+                key,
+                label: taxonomy ? attributeLabel(key) : (String(a.name || a.__key || '').trim().slice(0, 40) || attributeLabel(key)),
+                taxonomy,
+                values,
+                variation: Number(a.is_variation) === 1 || a.is_variation === true,
+                visible: !(Number(a.is_visible) === 0 || a.is_visible === false),
+                position: Number(a.position) || 0
+            });
+        }
+        attributes.sort((a, b) => a.position - b.position);
+
+        const typeTerm = terms('product_type')[0]?.slug || '';
+        const kids = variationsOf.get(it.id) || [];
+        const type = PRODUCT_TYPES.includes(typeTerm) ? typeTerm : (kids.length ? 'variable' : (m._product_url ? 'external' : 'simple'));
+
+        const variations = kids.map(v => {
+            const vm = v.meta || {};
+            const attrs = Object.create(null);
+            for (const [k, val] of Object.entries(vm)) {
+                if (!k.startsWith('attribute_')) continue;
+                const key = k.slice(10);
+                const a = attributes.find(x => x.key === key || attrKey(x.key) === key || keyText(x.key) === keyText(key));
+                const raw = String(val ?? '').trim();
+                attrs[a?.key || key] = raw === '' ? '' : (a?.taxonomy || key.startsWith('pa_') ? (termName.get(`${a?.key || key}\0${raw}`) || raw) : raw);
+            }
+            return {
+                id: v.id, status: v.status, order: v.order, title: v.title, attrs,
+                regular: vm._regular_price ?? '', sale: vm._sale_price ?? '', price: vm._price ?? '',
+                saleFrom: vm._sale_price_dates_from ?? '', saleTo: vm._sale_price_dates_to ?? '',
+                sku: vm._sku ?? '', manageStock: vm._manage_stock === 'yes', stock: int(vm._stock), stockStatus: vm._stock_status || '',
+                thumbId: int(vm._thumbnail_id) || 0, weight: vm._weight ?? '', virtual: vm._virtual === 'yes', downloadable: vm._downloadable === 'yes'
+            };
+        }).sort((a, b) => a.order - b.order || a.id - b.id);
+
+        const children = readSerialised(m._children);
+        if (children.error) problems.push(`its grouped products could not be read: ${children.error}`);
+        const visibility = new Set(terms('product_visibility').map(t => t.slug));
+
+        return {
+            id: it.id, item: it, type, problems,
+            regular: m._regular_price ?? '', sale: m._sale_price ?? '', price: m._price ?? '',
+            saleFrom: m._sale_price_dates_from ?? '', saleTo: m._sale_price_dates_to ?? '',
+            sku: m._sku ?? '', manageStock: m._manage_stock === 'yes', stock: int(m._stock), stockStatus: m._stock_status || '',
+            weight: m._weight ?? '', virtual: m._virtual === 'yes', downloadable: m._downloadable === 'yes',
+            taxStatus: m._tax_status || '', taxClass: m._tax_class || '',
+            thumbId: int(m._thumbnail_id) || 0,
+            galleryIds: String(m._product_image_gallery || '').split(',').map(int).filter(n => n > 0).slice(0, 40),
+            categories: terms('product_cat').map(t => ({slug: t.slug, name: t.name || t.slug})),
+            tags: terms('product_tag').map(t => t.name || t.slug),
+            featured: visibility.has('featured') || m._featured === 'yes',
+            hidden: visibility.has('exclude-from-catalog') && visibility.has('exclude-from-search'),
+            attributes,
+            variations,
+            children: (Array.isArray(children.value) ? children.value : Object.values(children.value || {})).map(int).filter(n => n > 0).slice(0, 200),
+            url: String(m._product_url || '').trim(),
+            buttonText: String(m._button_text || '').trim()
+        };
+    });
+}
+
+/**
+ * A decimal price as WooCommerce stores it ("12.5") in minor units, or null.
+ *
+ * @param {string} value
+ * @param {number} [decimals=2]
+ */
+export function toMinorUnits(value, decimals = 2) {
+    const s = String(value ?? '').trim();
+    // "12", "12.5", "12." and ".5" (wc_format_decimal can leave either end bare).
+    if (!/^(\d{1,12}(\.\d{0,8})?|\.\d{1,8})$/.test(s)) return null;
+    const [whole = '', frac = ''] = s.split('.');
+    const d = Math.max(0, Math.min(4, decimals | 0));
+    const digits = (frac + '0'.repeat(d + 1)).slice(0, d + 1);
+    let n = Number(whole) * 10 ** d + Number(digits.slice(0, d) || 0);
+    if (Number(digits[d]) >= 5) n += 1;
+    return Number.isSafeInteger(n) && n <= 1e11 ? n : null;
+}
+
+/** The decimals a currency is written with (GBP 2, JPY 0). */
+export function currencyDecimals(currency) {
+    try { return new Intl.NumberFormat('en', {style: 'currency', currency}).resolvedOptions().maximumFractionDigits; } catch { return 2; }
+}
+
+/** Is a sale on now? (WooCommerce's dates are Unix seconds, or a date string in older exports.) */
+function saleState(from, to, now) {
+    const at = (v) => {
+        const s = String(v ?? '').trim();
+        if (!s) return null;
+        if (/^\d{9,11}$/.test(s)) return Number(s) * 1000;
+        const t = Date.parse(s);
+        return Number.isFinite(t) ? t : null;
+    };
+    const f = at(from);
+    const t = at(to);
+    if (t !== null && t < now) return {state: 'ended'};
+    if (f !== null && f > now) return {state: 'later'};
+    return {state: 'on', ends: t};
+}
+
+/** The price, and the "was" price when there is a sale on: {price, compareAt, regular, note}. */
+function pricesOf(p, decimals, now) {
+    const regular = toMinorUnits(p.regular, decimals) ?? toMinorUnits(p.price, decimals);
+    const sale = toMinorUnits(p.sale, decimals);
+    let note = '';
+    if (sale !== null && regular !== null && sale < regular) {
+        const {state, ends} = saleState(p.saleFrom, p.saleTo, now);
+        // The Shop has no sale dates: a sale with an end would otherwise run on for ever, unsaid.
+        if (state === 'on' && ends !== null) note = `its sale ends ${new Date(ends).toISOString().slice(0, 10)} - the Shop has no sale dates, so put the price back to the full price then`;
+        if (state === 'on') return {price: sale, compareAt: regular, regular, note};
+        if (state === 'later') note = 'its sale price was scheduled for later - imported at the full price';
+    }
+    return {price: regular, compareAt: null, regular, note};
+}
+
+/** Control characters out, cut to n, trimmed AFTER the cut (as the Shop's own cleaning reads it). */
+const clip = (s, n) => String(s ?? '').replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, '').trim().slice(0, n).trim();
+const STOCK_MAX = 1e9;
+const WEIGHT_MAX = 1e7;
+
+/** WooCommerce's tax class -> the Shop's. */
+function taxClassOf(p) {
+    if (p.taxStatus === 'none') return {taxClass: 'zero', note: ''};
+    if (!p.taxClass || p.taxClass === 'standard') return {taxClass: 'standard', note: ''};
+    if (/reduced/i.test(p.taxClass)) return {taxClass: 'reduced', note: ''};
+    if (/zero/i.test(p.taxClass)) return {taxClass: 'zero', note: ''};
+    return {taxClass: 'standard', note: `its tax class "${clip(p.taxClass, 40)}" is not one the Shop has - it is standard rate here`};
+}
+
+/**
+ * What a product becomes in the Shop: the input the Shop's own save cleans
+ * (amounts in minor units), plus what the preview and the report say about it.
+ *
+ * @param {object} p - from readWooProducts()
+ * @param {object} [ctx]
+ * @param {string} [ctx.slug]
+ * @param {string} [ctx.description] - the product's text, converted (Markdown)
+ * @param {(attachmentId: number) => string|null} [ctx.mediaUrl]
+ * @param {number} [ctx.decimals=2] - the Shop's currency's
+ * @param {number} [ctx.now=Date.now()]
+ * @param {boolean} [ctx.published] - publish (on sale) when WooCommerce had it published
+ * @returns {{input: object, notes: string[], needs: string, onSale: boolean}}
+ */
+export function shopProductInput(p, ctx = {}) {
+    const {slug = '', description = '', mediaUrl = () => null, decimals = 2, now = Date.now(), published = true} = ctx;
+    const notes = [...p.problems];
+    let needs = '';
+    let sellable = true;
+
+    // ---- Price, options, stock ----
+    let price = null;
+    let compareAt = null;
+    let optionName = '';
+    const variants = [];
+    let trackStock = false;
+    let stock = null;
+
+    if (p.type === 'variable') {
+        const vAttrs = p.attributes.filter(a => a.variation);
+        const keys = vAttrs.length ? vAttrs.map(a => a.key) : [...new Set(p.variations.flatMap(v => Object.keys(v.attrs)))];
+        const label = (k) => vAttrs.find(a => a.key === k)?.label || attributeLabel(k);
+        optionName = clip(keys.map(label).join(' / '), 40) || 'Option';
+        const live = p.variations.filter(v => v.status !== 'private' && v.status !== 'trash');
+        if (live.length < p.variations.length) notes.push(`${p.variations.length - live.length} switched-off option${p.variations.length - live.length === 1 ? ' was' : 's were'} left out`);
+        const seen = new Set();
+        const regulars = [];
+        let allOnSale = true;
+        let allManaged = true;
+        const outOfStock = [];
+        for (const v of live) {
+            const pr = pricesOf(v, decimals, now);
+            let name = clip(keys.map(k => v.attrs[k] || `Any ${label(k).toLowerCase()}`).join(' / '), 80) || clip(v.title, 80) || `Option ${variants.length + 1}`;
+            if (pr.price === null) { notes.push(`the option "${name}" had no price - left out`); continue; }
+            if (pr.note) notes.push(`${name}: ${pr.note}`);
+            // The number goes on after the cut, so a long name still becomes a new one.
+            const stem = name;
+            for (let n = 2; seen.has(name.toLowerCase()) && n < 1000; n++) name = `${clip(stem, 80 - ` (${n})`.length)} (${n})`;
+            if (seen.has(name.toLowerCase())) { notes.push('an option with the same name as another was left out'); continue; }
+            seen.add(name.toLowerCase());
+            if (pr.compareAt === null) allOnSale = false;
+            regulars.push(pr.regular);
+            if (!v.manageStock) allManaged = false;
+            if (!v.manageStock && v.stockStatus === 'outofstock') outOfStock.push(name);
+            variants.push({name, price: pr.price, sku: clip(v.sku, 60), stock: v.manageStock ? Math.min(STOCK_MAX, Math.max(0, v.stock ?? 0)) : null, imageId: v.thumbId});
+        }
+        if (variants.length > 60) {
+            notes.push(`it had ${variants.length} options - the Shop takes 60, so the rest were left out`);
+            variants.length = 60;
+        }
+        if (!variants.length) {
+            notes.push('none of its options could be sold here - imported as a draft');
+            sellable = false;
+            price = 0;
+        } else {
+            price = Math.min(...variants.map(v => v.price));
+            if (allOnSale && regulars.length && regulars.every(r => r === regulars[0])) compareAt = regulars[0];
+            if (allManaged) trackStock = true;
+            else {
+                for (const v of variants) v.stock = null;
+                if (p.manageStock) notes.push(`its stock (${Math.max(0, p.stock ?? 0)}) was counted for the product as a whole - the Shop counts each option, so stock is not counted until you set it per option`);
+                if (outOfStock.length) notes.push(`out of stock in WooCommerce: ${outOfStock.slice(0, 5).join(', ')}${outOfStock.length > 5 ? '…' : ''} - set their stock in the Shop`);
+            }
+        }
+    } else {
+        const pr = pricesOf(p, decimals, now);
+        if (pr.note) notes.push(pr.note);
+        price = pr.price;
+        compareAt = pr.compareAt;
+        if (price === null) {
+            price = 0;
+            sellable = false;
+            notes.push(p.type === 'grouped' ? 'a grouped product has no price of its own' : 'it had no price - imported as a draft');
+        }
+        if (p.manageStock) { trackStock = true; stock = Math.min(STOCK_MAX, Math.max(0, p.stock ?? 0)); }
+        else if (p.stockStatus === 'outofstock') { trackStock = true; stock = 0; }
+    }
+    if (p.manageStock && (p.stock ?? 0) < 0) notes.push('it was on backorder - its stock is 0 here (the Shop takes no backorders)');
+
+    // ---- Words ----
+    let text = String(description || '');
+    const details = p.attributes.filter(a => !a.variation && a.visible && a.values.length)
+        .map(a => `- **${a.label.replace(/[*_[\]]/g, '')}:** ${a.values.join(', ').replace(/[*_[\]]/g, '')}`);
+    if (details.length) text = `${text.trim()}\n\n${details.join('\n')}`.trim();
+    if (p.type === 'external') {
+        needs = 'External product';
+        sellable = false;
+        notes.push('an external (affiliate) product - the Shop sells only its own, so it is a draft with a link to where it was sold');
+        // Only a plain address goes into the Markdown link - no brackets or parentheses that could end it early.
+        if (/^https?:\/\/[^\s<>"'()[\]\\`]+$/i.test(p.url)) text = `${text.trim()}\n\n[${clip(p.buttonText, 60).replace(/[[\]]/g, '') || 'Buy it here'}](${p.url})`.trim();
+    }
+    if (p.type === 'grouped') {
+        needs = 'Grouped product';
+        sellable = false;
+    }
+    if (p.downloadable) {
+        needs = needs || 'Downloadable files';
+        notes.push('its download files are not imported - add them in the Shop (Shopping Cart Pro sells downloads)');
+    }
+    if (p.hidden) {
+        sellable = false;
+        notes.push('it was hidden from the WooCommerce catalogue - imported as a draft');
+    }
+    const tax = taxClassOf(p);
+    if (tax.note) notes.push(tax.note);
+
+    // ---- Pictures ----
+    const images = [];
+    for (const id of [p.thumbId, ...p.galleryIds, ...variants.map(v => v.imageId)]) {
+        const url = id ? mediaUrl(id) : null;
+        if (url && !images.includes(url)) images.push(url);
+    }
+    if (images.length > 12) { images.length = 12; notes.push('it had more than 12 pictures - the Shop takes 12'); }
+
+    // ---- Filing ----
+    const cats = p.categories.filter(c => c.slug !== 'uncategorized');
+    const category = clip(cats[0]?.name, 60);
+    const tags = [...new Set([...p.tags, ...cats.slice(1).map(c => c.name)].map(t => clip(t, 40).toLowerCase()).filter(Boolean))].slice(0, 20);
+    if (cats.length > 1) notes.push(`the Shop files a product under one category - ${cats.slice(1).map(c => c.name).join(', ')} became tags`);
+
+    const kg = Number(String(p.weight ?? '').trim());
+    let weight = Number.isFinite(kg) && kg > 0 ? Math.round(kg * 1000) : null;
+    if (weight !== null && weight > WEIGHT_MAX) {
+        weight = null;
+        notes.push(`its weight (${clip(p.weight, 20)}) is more than the Shop takes when read as kilograms - left empty; the old shop may have used grams`);
+    }
+
+    const onSale = Boolean(published && sellable);
+    const it = p.item;
+    return {
+        input: {
+            name: clip(plainTitle(it.title), 140) || `Product ${p.id}`,
+            slug,
+            summary: clip(plainText(it.excerpt).replace(/\s+/g, ' '), 300),
+            description: clip(text, 20000),
+            price,
+            compareAt,
+            sku: clip(p.sku, 60),
+            images,
+            category,
+            tags,
+            status: onSale ? 'active' : 'draft',
+            featured: p.featured,
+            position: Number.isInteger(it.order) && it.order > 0 ? it.order : 0,
+            trackStock,
+            stock: variants.length ? null : stock,
+            optionName: variants.length ? optionName : '',
+            variants: variants.map(({imageId, ...v}) => v),
+            shippable: !(p.virtual || p.downloadable),
+            weight,
+            taxClass: tax.taxClass,
+            unlisted: false,
+            owner: ''
+        },
+        notes: [...new Set(notes)],
+        needs,
+        onSale
+    };
+}
+
+/** HTML (an excerpt) as plain text. */
+function plainText(html) {
+    return String(html || '').replace(/<br\s*\/?>/gi, '\n').replace(/<\/p>\s*<p[^>]*>/gi, '\n\n').replace(/<[^>]*>/g, '')
+        .replace(/&nbsp;/g, ' ').replace(/&#0*39;|&apos;/g, "'").replace(/&quot;/g, '"').replace(/&lt;/g, '<').replace(/&gt;/g, '>')
+        .replace(/&#8217;/g, '’').replace(/&#8216;/g, '‘').replace(/&#8220;/g, '“').replace(/&#8221;/g, '”')
+        .replace(/&#8211;/g, '–').replace(/&#8212;/g, '—').replace(/&#8230;/g, '…').replace(/&amp;/g, '&').trim();
+}
+
+/** A title as text: the few tags WordPress allows in one removed, entities decoded. */
+function plainTitle(s) {
+    return plainText(String(s ?? '').replace(/<\/?(b|i|em|strong|span|br|a|small|sup|sub|code|mark|u|s|del|ins)\b[^>]*>/gi, '').replace(/</g, '&lt;').replace(/>/g, '&gt;'));
+}
+
+/**
+ * The fingerprint parts of a Shop product - what an edit in the Shop changes.
+ * Stock is left out: sales here move it, and a sale is not an edit.
+ */
+export function productFingerprintParts(d = {}) {
+    return JSON.stringify([d.name, d.summary, d.description, d.price, d.compareAt ?? null, d.sku, d.category, d.tags || [], d.images || [],
+        d.optionName || '', (d.variants || []).map(v => [v.name, v.price ?? null, v.sku || '']), d.status, Boolean(d.featured),
+        d.shippable !== false, d.weight ?? null, d.taxClass || 'standard']);
+}
+
+/**
+ * An update of a product made by an earlier run: the new input over what the
+ * Shop has now, keeping its stock (sales here move it) and the ids of options
+ * that are still there (orders refer to them).
+ *
+ * @param {object} now - the product's data in the Shop
+ * @param {object} input - from shopProductInput()
+ */
+export function mergeForUpdate(now = {}, input = {}) {
+    const byName = new Map((now.variants || []).map(v => [String(v.name).toLowerCase(), v]));
+    const variants = (input.variants || []).map(v => {
+        const had = byName.get(String(v.name).toLowerCase());
+        return had ? {...v, id: had.id, stock: now.trackStock ? had.stock : v.stock} : v;
+    });
+    return {
+        ...now,
+        ...input,
+        variants,
+        trackStock: now.trackStock ?? input.trackStock,
+        stock: now.trackStock ? now.stock : input.stock,
+        unlisted: now.unlisted === true,
+        owner: now.owner || ''
+    };
+}
+
+/** WooCommerce's own pages (cart, checkout, my account, the shop page): what each is, or ''. */
+export function wooPageRole(item) {
+    const c = String(item?.content || '');
+    if (/\[woocommerce_cart\b|wp:woocommerce\/cart\b/.test(c)) return 'cart';
+    if (/\[woocommerce_checkout\b|wp:woocommerce\/checkout\b/.test(c)) return 'checkout';
+    if (/\[woocommerce_my_account\b|wp:woocommerce\/customer-account\b|wp:woocommerce\/classic-shortcode\s+\{"shortcode":"my-account"/.test(c)) return 'account';
+    if (/wp:woocommerce\/(product-catalog|all-products|product-collection)\b|wp:woocommerce\/classic-template\s+\{"template":"archive-product"/.test(c)) return 'shop';
+    if (/^shop$/i.test(item?.slug || '') && !c.replace(/<!--[\s\S]*?-->/g, '').trim()) return 'shop';
+    return '';
+}

package/server/services/wpImport/wxr.js

@@ -4,6 +4,8 @@
  *
  *   {site: {title, link, baseSiteUrl, baseBlogUrl, wxrVersion, hosts[]},
  *    authors[], categories[], tags[], menus[],
+ *    terms: [{taxonomy, id, slug, name, parent, description}]   - every other taxonomy's terms
+ *           (WooCommerce's product_cat, product_tag, pa_* attribute values…),
  *    items: [{id, type, title, slug, status, parent, order, date, dateGmt, link, guid,
  *             creator, content, excerpt, password, attachmentUrl, meta{}, terms[], comments[]}]}
  *
@@ -88,6 +90,18 @@ export function wxrFromTree(root) {
         .map(t => ({id: int(textOf(t, 'wp:term_id')), slug: textOf(t, 'wp:term_slug'), name: textOf(t, 'wp:term_name')}))
         .filter(m => m.slug);
 
+    // Every other taxonomy's terms: WooCommerce's product categories, tags and attribute values among them.
+    const terms = children(channel, 'wp:term')
+        .map(t => ({
+            taxonomy: textOf(t, 'wp:term_taxonomy'),
+            id: int(textOf(t, 'wp:term_id')),
+            slug: textOf(t, 'wp:term_slug'),
+            name: textOf(t, 'wp:term_name'),
+            parent: textOf(t, 'wp:term_parent'),
+            description: textOf(t, 'wp:term_description')
+        }))
+        .filter(t => t.taxonomy && t.taxonomy !== 'nav_menu' && t.slug);
+
     const items = children(channel, 'item').map(readItem);
 
     // A menu named only on its items (WXR 1.0 has no wp:term for it).
@@ -99,8 +113,13 @@ export function wxrFromTree(root) {
     // Categories and tags named only on posts (a partial export). Sets: big exports have thousands of each.
     const catSlugs = new Set(categories.map(c => c.slug));
     const tagSlugs = new Set(tags.map(t => t.slug));
+    const termKeys = new Set(terms.map(t => `${t.taxonomy}\0${t.slug}`));
     for (const it of items) {
         for (const t of it.terms) {
+            if (t.domain !== 'category' && t.domain !== 'post_tag' && t.domain !== 'nav_menu' && t.slug && !termKeys.has(`${t.domain}\0${t.slug}`)) {
+                termKeys.add(`${t.domain}\0${t.slug}`);
+                terms.push({taxonomy: t.domain, id: 0, slug: t.slug, name: t.name || t.slug, parent: '', description: ''});
+            }
             if (t.domain === 'category' && !catSlugs.has(t.slug)) { catSlugs.add(t.slug); categories.push({id: 0, slug: t.slug, parent: '', name: t.name || t.slug, description: ''}); }
             if (t.domain === 'post_tag' && !tagSlugs.has(t.slug)) { tagSlugs.add(t.slug); tags.push({id: 0, slug: t.slug, name: t.name || t.slug, description: ''}); }
         }
@@ -112,7 +131,7 @@ export function wxrFromTree(root) {
         if (h) { hostSet.add(h); hostSet.add(bareHost(h)); hostSet.add(`www.${bareHost(h)}`); }
     }
     site.hosts = [...hostSet];
-    return {site, authors, categories, tags, menus, items};
+    return {site, authors, categories, tags, menus, terms, items};
 }
 
 function readItem(node) {

package/server/templates/page.html

@@ -25,7 +25,7 @@
     <link rel="stylesheet" href="/dist/domma/themes/domma-themes.css">
 
     <!-- Site CSS -->
-    <link rel="stylesheet" href="/public/css/site.css?v=20261014-block-card-heights">
+    <link rel="stylesheet" href="/public/css/site.css?v=20261016-mobile-layouts">
     <link rel="stylesheet" href="/public/css/forms.css?v=20260927-submit-btn-css">
     <!-- Menu item hover / current-page effects. Loaded after site.css so a
          menu's own highlight wins over the blanket link styling there. -->