rerobe-js-orm 4.5.0 → 4.5.1

package/lib/form-states/Product/ProductFormState.d.ts

@@ -3,6 +3,7 @@ import Product from '../../models/Product';
 export default class ProductFormState extends FormState {
     fields: ProductFormFields;
     props: CompleteProduct;
+    private variantAxes?;
     opts: {
         featuredCollectionOpts: {
             label: string;
@@ -59,8 +60,41 @@ export default class ProductFormState extends FormState {
     private discountValueChangeHandler;
     private calculateSalePrice;
     private inventoryLocationsChangeHandler;
-    private generateVariantId;
+    private isSameOptions;
+    private getExistingVariantByOptions;
     private variantInventoryChangeHandler;
+    setVariantAxes(axes?: {
+        [axis: string]: string[];
+    }): void;
+    generateVariantsFromAxes(defaults?: Partial<VariantInventory>): void;
+    addAxis(axis: string): void;
+    removeAxis(axis: string): void;
+    addAxisValue(axis: string, value: string): void;
+    removeAxisValue(axis: string, value: string): void;
+    reorderAxes(order: string[]): void;
+    upsertVariantByOptions(options: {
+        [k: string]: string;
+    }, patch: Partial<VariantInventory>): void;
+    removeVariantByOptions(options: {
+        [k: string]: string;
+    }): void;
+    findVariantByOptions(options: {
+        [k: string]: string;
+    }): VariantInventory | undefined;
+    validateAxes(axes: {
+        [axis: string]: string[];
+    }): {
+        ok: boolean;
+        errors: string[];
+    };
+    diffVariantsFromAxes(nextAxes: {
+        [axis: string]: string[];
+    }): {
+        toAdd: {
+            [k: string]: string;
+        }[];
+        toRemove: string[];
+    };
     private aggregateInventoryLocationsFromVariants;
     private fieldFactory;
 }

package/lib/form-states/Product/ProductFormState.js

@@ -1,4 +1,15 @@
 "use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const FormState_1 = require("../FormState");
 const options_1 = require("./options");
@@ -571,39 +582,55 @@ class ProductFormState extends FormState_1.default {
             this.multiSelectChangeHandler('inventoryLocations', val);
         }
     }
-    generateVariantId(options) {
-        const entries = Object.entries(options || {}).sort(([a], [b]) => (a > b ? 1 : a < b ? -1 : 0));
-        return entries.map(([k, v]) => `${this.utilities.camelCase(k)}=${String(v).trim()}`).join('|');
+    isSameOptions(a = {}, b = {}) {
+        const aKeys = Object.keys(a || {});
+        const bKeys = Object.keys(b || {});
+        if (aKeys.length !== bKeys.length)
+            return false;
+        return aKeys.every((k) => String(a[k]) === String(b[k]));
+    }
+    getExistingVariantByOptions(options = {}) {
+        var _a;
+        return ((_a = this.fields.variantInventory) === null || _a === void 0 ? void 0 : _a.selectedValues).find((v) => this.isSameOptions(v.options, options));
     }
     variantInventoryChangeHandler(val) {
+        var _a;
         const numAxes = (val === null || val === void 0 ? void 0 : val.options) ? Object.keys(val.options).length : 0;
         if (numAxes > 3) {
             return; // silently ignore invalid (>3 axes)
         }
-        const id = (val === null || val === void 0 ? void 0 : val.id) || this.generateVariantId((val === null || val === void 0 ? void 0 : val.options) || {});
+        const id = (val === null || val === void 0 ? void 0 : val.id) ||
+            ((val === null || val === void 0 ? void 0 : val.options) ? (_a = this.getExistingVariantByOptions(val.options)) === null || _a === void 0 ? void 0 : _a.id : undefined) ||
+            this.utilities.makeRandId(28);
+        const existingInd = this.fields.variantInventory.selectedValues.findIndex((i) => i.id === id);
+        const existing = existingInd !== -1 ? this.fields.variantInventory.selectedValues[existingInd] : {};
         const next = {
             id,
-            options: val.options || {},
-            locations: val === null || val === void 0 ? void 0 : val.locations,
+            options: val.options || existing.options || {},
+            locations: (val === null || val === void 0 ? void 0 : val.locations) !== undefined ? val.locations : existing.locations,
+            price: (val === null || val === void 0 ? void 0 : val.price) !== undefined ? val.price : existing.price,
+            compareAtPrice: (val === null || val === void 0 ? void 0 : val.compareAtPrice) !== undefined ? val.compareAtPrice : existing.compareAtPrice,
+            salePrice: (val === null || val === void 0 ? void 0 : val.salePrice) !== undefined ? val.salePrice : existing.salePrice,
+            isOnSale: (val === null || val === void 0 ? void 0 : val.isOnSale) !== undefined ? val.isOnSale : existing.isOnSale,
+            sku: (val === null || val === void 0 ? void 0 : val.sku) !== undefined ? val.sku : existing.sku,
+            taxable: (val === null || val === void 0 ? void 0 : val.taxable) !== undefined ? val.taxable : existing.taxable,
         };
-        const existingIds = this.fields.variantInventory.selectedValues.map((i) => i.id);
-        if (existingIds.includes(id)) {
-            const foundInd = this.fields.variantInventory.selectedValues.findIndex((i) => i.id === id);
+        const foundInd = this.fields.variantInventory.selectedValues.findIndex((i) => i.id === id);
+        if (foundInd !== -1) {
             const foundI = this.fields.variantInventory.selectedValues[foundInd];
-            const sameLocations = (() => {
+            let shouldToggleRemove = false;
+            if ((val === null || val === void 0 ? void 0 : val.locations) !== undefined) {
                 const norm = (arr = []) => [...arr]
                     .filter((l) => l && l.id)
                     .sort((a, b) => (a.id > b.id ? 1 : a.id < b.id ? -1 : 0))
                     .map((l) => `${l.id}:${Number(l.availableAmount) || 0}:${Number(l.incomingAmount) || 0}`)
                     .join('|');
-                return norm(foundI.locations) === norm(next.locations);
-            })();
-            if (sameLocations) {
-                // same locations => toggle remove
+                shouldToggleRemove = norm(foundI.locations) === norm(next.locations);
+            }
+            if (shouldToggleRemove) {
                 this.fields.variantInventory.selectedValues.splice(foundInd, 1);
             }
             else {
-                // update quantity/options
                 this.fields.variantInventory.selectedValues.splice(foundInd, 1, next);
             }
         }
@@ -621,6 +648,195 @@ class ProductFormState extends FormState_1.default {
         // aggregate main inventoryLocations from variant locations (sum by location id)
         this.aggregateInventoryLocationsFromVariants();
     }
+    // Public: define axes (≤3) for generating combinations
+    setVariantAxes(axes = {}) {
+        const axisKeys = Object.keys(axes || {});
+        if (axisKeys.length > 3) {
+            // trim to first 3 axes to enforce limit
+            this.variantAxes = axisKeys.slice(0, 3).reduce((acc, k) => {
+                acc[k] = Array.from(new Set((axes[k] || []).map((v) => String(v).trim()).filter(Boolean)));
+                return acc;
+            }, {});
+        }
+        else {
+            this.variantAxes = axisKeys.reduce((acc, k) => {
+                acc[k] = Array.from(new Set((axes[k] || []).map((v) => String(v).trim()).filter(Boolean)));
+                return acc;
+            }, {});
+        }
+    }
+    // Public: regenerate variants from axes, preserving existing per-variant fields where options match
+    generateVariantsFromAxes(defaults = {}) {
+        const axes = this.variantAxes || {};
+        const axisKeys = Object.keys(axes);
+        if (axisKeys.length === 0) {
+            this.fields.variantInventory.selectedValues = [];
+            this.fields.variantInventory.valid = false;
+            this.aggregateInventoryLocationsFromVariants();
+            this.fields.quantity.inputValue = 0;
+            this.fields.availableForSale.selectedValue = false;
+            return;
+        }
+        const cartesian = (keys, idx, cur, out) => {
+            if (idx >= keys.length) {
+                out.push(Object.assign({}, cur));
+                return;
+            }
+            const key = keys[idx];
+            const values = axes[key] || [];
+            values.forEach((v) => {
+                cartesian(keys, idx + 1, Object.assign(Object.assign({}, cur), { [key]: v }), out);
+            });
+        };
+        const combos = [];
+        cartesian(axisKeys, 0, {}, combos);
+        const regenerated = combos.map((opts) => {
+            var _a, _b, _c, _d, _e, _f;
+            const prev = this.getExistingVariantByOptions(opts);
+            const id = (prev === null || prev === void 0 ? void 0 : prev.id) || this.utilities.makeRandId(28);
+            const merged = {
+                id,
+                options: opts,
+                locations: (prev === null || prev === void 0 ? void 0 : prev.locations) || defaults.locations,
+                price: (_a = prev === null || prev === void 0 ? void 0 : prev.price) !== null && _a !== void 0 ? _a : defaults.price,
+                compareAtPrice: (_b = prev === null || prev === void 0 ? void 0 : prev.compareAtPrice) !== null && _b !== void 0 ? _b : defaults.compareAtPrice,
+                salePrice: (_c = prev === null || prev === void 0 ? void 0 : prev.salePrice) !== null && _c !== void 0 ? _c : defaults.salePrice,
+                isOnSale: (_d = prev === null || prev === void 0 ? void 0 : prev.isOnSale) !== null && _d !== void 0 ? _d : defaults.isOnSale,
+                sku: (_e = prev === null || prev === void 0 ? void 0 : prev.sku) !== null && _e !== void 0 ? _e : defaults.sku,
+                taxable: (_f = prev === null || prev === void 0 ? void 0 : prev.taxable) !== null && _f !== void 0 ? _f : defaults.taxable,
+            };
+            return merged;
+        });
+        this.fields.variantInventory.selectedValues = regenerated;
+        this.fields.variantInventory.valid = regenerated.length > 0;
+        // Aggregate quantity and master locations
+        const totalQty = regenerated.reduce((acc, cur) => {
+            const locs = cur.locations;
+            const sum = Array.isArray(locs) ? locs.reduce((a, l) => a + (Number(l === null || l === void 0 ? void 0 : l.availableAmount) || 0), 0) : 0;
+            return acc + sum;
+        }, 0);
+        this.fields.quantity.inputValue = totalQty;
+        this.fields.availableForSale.selectedValue = totalQty > 0;
+        this.aggregateInventoryLocationsFromVariants();
+    }
+    // Convenience helpers for UI
+    addAxis(axis) {
+        const k = String(axis).trim();
+        if (!k)
+            return;
+        const current = this.variantAxes || {};
+        if (Object.keys(current).includes(k))
+            return;
+        const nextKeys = Object.keys(current).concat(k).slice(0, 3);
+        const next = {};
+        nextKeys.forEach((key) => (next[key] = current[key] || []));
+        if (!next[k])
+            next[k] = [];
+        this.variantAxes = next;
+    }
+    removeAxis(axis) {
+        const current = this.variantAxes || {};
+        if (!current[axis])
+            return;
+        const _a = current, _b = axis, _ = _a[_b], rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+        this.variantAxes = rest;
+        // remove affected variants by regenerating from remaining axes
+        this.generateVariantsFromAxes();
+    }
+    addAxisValue(axis, value) {
+        const current = this.variantAxes || {};
+        if (!current[axis])
+            current[axis] = [];
+        const val = String(value).trim();
+        if (!val)
+            return;
+        if (!current[axis].includes(val))
+            current[axis].push(val);
+        this.variantAxes = current;
+        this.generateVariantsFromAxes();
+    }
+    removeAxisValue(axis, value) {
+        const current = this.variantAxes || {};
+        if (!current[axis])
+            return;
+        const val = String(value).trim();
+        current[axis] = current[axis].filter((v) => v !== val);
+        this.variantAxes = current;
+        this.generateVariantsFromAxes();
+    }
+    reorderAxes(order) {
+        const current = this.variantAxes || {};
+        const keys = order.filter((k) => current[k]).slice(0, 3);
+        const rest = Object.keys(current)
+            .filter((k) => !keys.includes(k))
+            .slice(0, Math.max(0, 3 - keys.length));
+        const nextOrder = keys.concat(rest);
+        const next = {};
+        nextOrder.forEach((k) => (next[k] = current[k]));
+        this.variantAxes = next;
+        // No regen required; only presentation order
+    }
+    upsertVariantByOptions(options, patch) {
+        const prev = this.getExistingVariantByOptions(options);
+        const id = (prev === null || prev === void 0 ? void 0 : prev.id) || this.utilities.makeRandId(28);
+        this.variantInventoryChangeHandler(Object.assign({ id,
+            options }, patch));
+    }
+    removeVariantByOptions(options) {
+        const prev = this.getExistingVariantByOptions(options);
+        if (!prev)
+            return;
+        const ind = this.fields.variantInventory.selectedValues.findIndex((v) => v.id === prev.id);
+        if (ind !== -1) {
+            this.fields.variantInventory.selectedValues.splice(ind, 1);
+            // re-aggregate
+            const totalQty = this.fields.variantInventory.selectedValues.reduce((acc, cur) => {
+                const locs = cur.locations;
+                const sum = Array.isArray(locs) ? locs.reduce((a, l) => a + (Number(l === null || l === void 0 ? void 0 : l.availableAmount) || 0), 0) : 0;
+                return acc + sum;
+            }, 0);
+            this.fields.quantity.inputValue = totalQty;
+            this.fields.availableForSale.selectedValue = totalQty > 0;
+            this.aggregateInventoryLocationsFromVariants();
+        }
+    }
+    findVariantByOptions(options) {
+        return this.getExistingVariantByOptions(options);
+    }
+    validateAxes(axes) {
+        const errors = [];
+        const keys = Object.keys(axes || {});
+        if (keys.length > 3)
+            errors.push('Too many axes (max 3).');
+        keys.forEach((k) => {
+            const vals = axes[k] || [];
+            const clean = vals.map((v) => String(v).trim()).filter(Boolean);
+            if (clean.length !== vals.length)
+                errors.push(`Axis "${k}" has empty/invalid values.`);
+        });
+        return { ok: errors.length === 0, errors };
+    }
+    diffVariantsFromAxes(nextAxes) {
+        const curRows = this.fields.variantInventory.selectedValues || [];
+        const curKeySet = new Set(curRows.map((r) => JSON.stringify(r.options || {})));
+        // build combos for nextAxes
+        const keys = Object.keys(nextAxes || {});
+        const out = [];
+        const cart = (i, acc) => {
+            if (i >= keys.length) {
+                out.push(Object.assign({}, acc));
+                return;
+            }
+            const k = keys[i];
+            const vals = nextAxes[k] || [];
+            vals.forEach((v) => cart(i + 1, Object.assign(Object.assign({}, acc), { [k]: v })));
+        };
+        cart(0, {});
+        const nextKeySet = new Set(out.map((o) => JSON.stringify(o)));
+        const toAdd = out.filter((o) => !curKeySet.has(JSON.stringify(o)));
+        const toRemove = curRows.filter((r) => !nextKeySet.has(JSON.stringify(r.options || {}))).map((r) => r.id);
+        return { toAdd, toRemove };
+    }
     aggregateInventoryLocationsFromVariants() {
         var _a;
         const variants = ((_a = this.fields.variantInventory) === null || _a === void 0 ? void 0 : _a.selectedValues) || [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rerobe-js-orm",
-  "version": "4.5.0",
+  "version": "4.5.1",
   "description": "ReRobe's Javascript ORM Framework",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",