@merchi/sdk 1.40.2

package/dist/pricing/visibility.js

@@ -0,0 +1,227 @@
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+function collectSelectedOptionIds(selections) {
+    var e_1, _a;
+    var ids = [];
+    var addFrom = function (fieldValues) {
+        var e_2, _a;
+        try {
+            for (var _b = __values(Object.keys(fieldValues)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var key = _c.value;
+                var sel = fieldValues[Number(key)];
+                if (sel && sel.selectedOptionIds)
+                    ids.push.apply(ids, __spreadArray([], __read(sel.selectedOptionIds), false));
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    addFrom(selections.fieldValues || {});
+    try {
+        for (var _b = __values(selections.groups || []), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var group = _c.value;
+            addFrom(group.fieldValues || {});
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return ids;
+}
+// Shared machinery for both field- and option-level conditional visibility.
+// Mirrors the server's `check_selected_by_fullfilled` recursion: a `selectedBy`
+// list is fulfilled when any of its trigger option ids is currently selected
+// AND that selecting option is itself fulfilled (its own `selectedBy` and its
+// owning field's `selectedBy`), with a `checked` accumulator to break cycles.
+function buildResolver(rules, selections) {
+    var e_3, _a, e_4, _b;
+    var allFields = __spreadArray(__spreadArray([], __read(rules.fields), false), __read(rules.groupFields), false);
+    var optionsById = new Map();
+    var fieldByOptionId = new Map();
+    try {
+        for (var allFields_1 = __values(allFields), allFields_1_1 = allFields_1.next(); !allFields_1_1.done; allFields_1_1 = allFields_1.next()) {
+            var f = allFields_1_1.value;
+            try {
+                for (var _c = (e_4 = void 0, __values(f.options)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var o = _d.value;
+                    optionsById.set(o.id, o);
+                    fieldByOptionId.set(o.id, f);
+                    if (o.originalId != null) {
+                        optionsById.set(o.originalId, o);
+                        fieldByOptionId.set(o.originalId, f);
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (allFields_1_1 && !allFields_1_1.done && (_a = allFields_1.return)) _a.call(allFields_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    var selectedOptionIds = collectSelectedOptionIds(selections);
+    var sameOption = function (a, b) {
+        var oa = optionsById.get(a);
+        return oa != null && oa === optionsById.get(b);
+    };
+    var isFulfilled = function (selectedBy, checked) {
+        var e_5, _a, e_6, _b;
+        if (!selectedBy || selectedBy.length === 0)
+            return true;
+        try {
+            for (var selectedBy_1 = __values(selectedBy), selectedBy_1_1 = selectedBy_1.next(); !selectedBy_1_1.done; selectedBy_1_1 = selectedBy_1.next()) {
+                var triggerId = selectedBy_1_1.value;
+                try {
+                    for (var selectedOptionIds_1 = (e_6 = void 0, __values(selectedOptionIds)), selectedOptionIds_1_1 = selectedOptionIds_1.next(); !selectedOptionIds_1_1.done; selectedOptionIds_1_1 = selectedOptionIds_1.next()) {
+                        var selId = selectedOptionIds_1_1.value;
+                        if (!sameOption(triggerId, selId))
+                            continue;
+                        if (checked.includes(selId))
+                            return true;
+                        // sameOption only returns true for ids present in optionsById, and
+                        // fieldByOptionId is populated in the same loop, so both lookups are
+                        // guaranteed non-null here (mirrors server dereferencing directly).
+                        var opt = optionsById.get(selId);
+                        var field = fieldByOptionId.get(selId);
+                        var nextChecked = __spreadArray(__spreadArray([], __read(checked), false), [selId], false);
+                        if (isFulfilled(opt.selectedBy, nextChecked) &&
+                            isFulfilled(field.selectedBy, nextChecked)) {
+                            return true;
+                        }
+                    }
+                }
+                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                finally {
+                    try {
+                        if (selectedOptionIds_1_1 && !selectedOptionIds_1_1.done && (_b = selectedOptionIds_1.return)) _b.call(selectedOptionIds_1);
+                    }
+                    finally { if (e_6) throw e_6.error; }
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (selectedBy_1_1 && !selectedBy_1_1.done && (_a = selectedBy_1.return)) _a.call(selectedBy_1);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        return false;
+    };
+    // Group variation fields only materialise as variations when the job
+    // actually has groups (the server builds them inside each `variations_group`
+    // via `VariationsGroups.mapper_variations`; with no groups there are no group
+    // variations at all). Independent fields are always in play. This mirrors the
+    // server, where a non-group job exposes no group fields.
+    var hasGroups = Boolean(selections.groups && selections.groups.length > 0);
+    var fieldsToConsider = hasGroups ? allFields : rules.fields;
+    return { allFields: allFields, fieldsToConsider: fieldsToConsider, isFulfilled: isFulfilled };
+}
+export function resolveVisibleFields(rules, selections) {
+    var e_7, _a;
+    var _b = buildResolver(rules, selections), fieldsToConsider = _b.fieldsToConsider, isFulfilled = _b.isFulfilled;
+    var visible = new Set();
+    try {
+        for (var fieldsToConsider_1 = __values(fieldsToConsider), fieldsToConsider_1_1 = fieldsToConsider_1.next(); !fieldsToConsider_1_1.done; fieldsToConsider_1_1 = fieldsToConsider_1.next()) {
+            var f = fieldsToConsider_1_1.value;
+            if (isFulfilled(f.selectedBy, []))
+                visible.add(f.id);
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (fieldsToConsider_1_1 && !fieldsToConsider_1_1.done && (_a = fieldsToConsider_1.return)) _a.call(fieldsToConsider_1);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    return visible;
+}
+// Returns the set of option ids whose own `selectedBy` is fulfilled — i.e. the
+// options that should be visible/selectable given the current selections.
+// Mirrors the server's per-option `isVisible = check_selected_by_fullfilled(
+// option.selected_by)`. Options with no `selectedBy` are always visible.
+export function resolveVisibleOptionIds(rules, selections) {
+    var e_8, _a, e_9, _b;
+    var _c = buildResolver(rules, selections), fieldsToConsider = _c.fieldsToConsider, isFulfilled = _c.isFulfilled;
+    var visible = new Set();
+    try {
+        for (var fieldsToConsider_2 = __values(fieldsToConsider), fieldsToConsider_2_1 = fieldsToConsider_2.next(); !fieldsToConsider_2_1.done; fieldsToConsider_2_1 = fieldsToConsider_2.next()) {
+            var f = fieldsToConsider_2_1.value;
+            try {
+                for (var _d = (e_9 = void 0, __values(f.options)), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    var o = _e.value;
+                    if (isFulfilled(o.selectedBy, []))
+                        visible.add(o.id);
+                }
+            }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            finally {
+                try {
+                    if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
+                }
+                finally { if (e_9) throw e_9.error; }
+            }
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (fieldsToConsider_2_1 && !fieldsToConsider_2_1.done && (_a = fieldsToConsider_2.return)) _a.call(fieldsToConsider_2);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    return visible;
+}

package/dist/pricing/visibility.test.js

@@ -0,0 +1,210 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { resolveVisibleFields, resolveVisibleOptionIds } from './visibility.js';
+function field(id, selectedBy, options) {
+    if (options === void 0) { options = []; }
+    return {
+        id: id,
+        originalId: id, position: 0, fieldType: 2, independent: true,
+        isSelectable: true,
+        selectedBy: selectedBy,
+        variationCost: 0, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        options: options.map(function (oid) { return ({
+            id: oid, originalId: oid, position: 0, default: false,
+            variationCost: 0, variationUnitCost: 0,
+            variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+            selectedBy: [],
+        }); }),
+    };
+}
+var rules = {
+    currency: 'AUD', taxPercent: 0,
+    product: { unitPrice: 0, minimumPrice: null, discountGroup: null },
+    fields: [
+        field(1, [], [101, 102]),
+        field(2, [101], [201]),
+        field(3, [201], [301]), // chained: visible if option 201 selected
+    ],
+    groupFields: [],
+    hasGroups: false,
+};
+test('field with no selectedBy is always visible', function () {
+    var v = resolveVisibleFields(rules, { fieldValues: {} });
+    expect(v.has(1)).toBe(true);
+    expect(v.has(2)).toBe(false);
+    expect(v.has(3)).toBe(false);
+});
+test('conditional field appears when its trigger option is selected', function () {
+    var v = resolveVisibleFields(rules, {
+        fieldValues: { 1: { selectedOptionIds: [101] } },
+    });
+    expect(v.has(2)).toBe(true);
+    expect(v.has(3)).toBe(false);
+});
+test('chained conditional field requires its parent to be fulfilled', function () {
+    var v = resolveVisibleFields(rules, {
+        fieldValues: { 1: { selectedOptionIds: [101] }, 2: { selectedOptionIds: [201] } },
+    });
+    expect(v.has(3)).toBe(true);
+});
+test('group fields are not visible when the job has no groups', function () {
+    var groupRules = __assign(__assign({}, rules), { fields: [field(1, [], [101])], hasGroups: true, groupFields: [field(20, []), field(21, [])] });
+    // No groups submitted -> the job is a single non-group job, so group fields
+    // never materialise as variations (mirrors the server).
+    var v = resolveVisibleFields(groupRules, { fieldValues: { 1: { selectedOptionIds: [101] } } });
+    expect(v.has(1)).toBe(true);
+    expect(v.has(20)).toBe(false);
+    expect(v.has(21)).toBe(false);
+});
+test('group field selections also drive visibility', function () {
+    var groupRules = __assign(__assign({}, rules), { fields: [], hasGroups: true, groupFields: [field(10, [], [110]), field(11, [110], [111])] });
+    var v = resolveVisibleFields(groupRules, {
+        fieldValues: {},
+        groups: [{ quantity: 5, fieldValues: { 10: { selectedOptionIds: [110] } } }],
+    });
+    expect(v.has(11)).toBe(true);
+});
+test('options/fields with null originalId still resolve by id', function () {
+    var noOrigOption = {
+        id: 401, originalId: null, position: 0, default: false,
+        variationCost: 0, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        selectedBy: [],
+    };
+    var trigger = {
+        id: 40, originalId: null, position: 0, fieldType: 2, independent: true,
+        isSelectable: true, selectedBy: [],
+        variationCost: 0, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        options: [noOrigOption],
+    };
+    var dependent = field(41, [401], []);
+    var noOrigRules = __assign(__assign({}, rules), { fields: [trigger, dependent] });
+    var v = resolveVisibleFields(noOrigRules, {
+        fieldValues: { 40: { selectedOptionIds: [401] } },
+    });
+    expect(v.has(41)).toBe(true);
+});
+test('cyclic selectedBy references terminate via the checked guard', function () {
+    function fieldWithOptSelectedBy(id, selectedBy, opts) {
+        return {
+            id: id,
+            originalId: id, position: 0, fieldType: 2, independent: true,
+            isSelectable: true,
+            selectedBy: selectedBy,
+            variationCost: 0, variationUnitCost: 0,
+            variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+            options: opts.map(function (o) { return ({
+                id: o.id, originalId: o.id, position: 0, default: false,
+                variationCost: 0, variationUnitCost: 0,
+                variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                selectedBy: o.selectedBy,
+            }); }),
+        };
+    }
+    var cyclicRules = __assign(__assign({}, rules), { fields: [
+            fieldWithOptSelectedBy(20, [], [{ id: 120, selectedBy: [121] }]),
+            fieldWithOptSelectedBy(21, [], [{ id: 121, selectedBy: [120] }]),
+            field(22, [120], []),
+        ] });
+    var v = resolveVisibleFields(cyclicRules, {
+        fieldValues: { 20: { selectedOptionIds: [120] }, 21: { selectedOptionIds: [121] } },
+    });
+    expect(v.has(22)).toBe(true);
+});
+test('field selections without selectedOptionIds are ignored', function () {
+    var v = resolveVisibleFields(rules, {
+        fieldValues: { 1: { value: 'text-only' }, 9: undefined },
+    });
+    expect(v.has(1)).toBe(true);
+    expect(v.has(2)).toBe(false);
+});
+test('missing fieldValues falls back to an empty selection map', function () {
+    var v = resolveVisibleFields(rules, { fieldValues: undefined });
+    expect(v.has(1)).toBe(true);
+    expect(v.has(2)).toBe(false);
+});
+test('group without fieldValues falls back to an empty selection map', function () {
+    var v = resolveVisibleFields(rules, {
+        fieldValues: {},
+        groups: [{ quantity: 1, fieldValues: undefined }],
+    });
+    expect(v.has(1)).toBe(true);
+    expect(v.has(2)).toBe(false);
+});
+// --- resolveVisibleOptionIds (option-level conditional visibility) ---
+// Mirrors the production case: a Size field with options (24mm=901, 25mm=902)
+// and a Colour field whose Green option (912) is gated by `selectedBy: [902]`.
+function sizeAndColourRules() {
+    var opt = function (id, selectedBy) {
+        if (selectedBy === void 0) { selectedBy = []; }
+        return ({
+            id: id,
+            originalId: id, position: id, default: false,
+            variationCost: 0, variationUnitCost: 0,
+            variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+            selectedBy: selectedBy,
+        });
+    };
+    var f = function (id, options) { return ({
+        id: id,
+        originalId: id, position: 0, fieldType: 2, independent: true,
+        isSelectable: true, selectedBy: [],
+        variationCost: 0, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        options: options,
+    }); };
+    return __assign(__assign({}, rules), { fields: [
+            f(900, [opt(901), opt(902)]),
+            f(910, [opt(911), opt(912, [902]), opt(913)]), // Colour: Red, Green(gated by 25mm), Blue
+        ], groupFields: [] });
+}
+test('option with no selectedBy is always visible', function () {
+    var v = resolveVisibleOptionIds(sizeAndColourRules(), { fieldValues: {} });
+    expect(v.has(901)).toBe(true);
+    expect(v.has(911)).toBe(true);
+    expect(v.has(913)).toBe(true);
+});
+test('gated option is hidden until its trigger option is selected', function () {
+    var r = sizeAndColourRules();
+    var hidden = resolveVisibleOptionIds(r, { fieldValues: { 900: { selectedOptionIds: [901] } } });
+    expect(hidden.has(912)).toBe(false); // 24mm selected -> Green hidden
+    var visible = resolveVisibleOptionIds(r, { fieldValues: { 900: { selectedOptionIds: [902] } } });
+    expect(visible.has(912)).toBe(true); // 25mm selected -> Green visible
+});
+test('group option visibility resolves from group selections', function () {
+    var opt = function (id, selectedBy) {
+        if (selectedBy === void 0) { selectedBy = []; }
+        return ({
+            id: id,
+            originalId: id, position: id, default: false,
+            variationCost: 0, variationUnitCost: 0,
+            variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+            selectedBy: selectedBy,
+        });
+    };
+    var f = function (id, options) { return ({
+        id: id,
+        originalId: id, position: 0, fieldType: 2, independent: true,
+        isSelectable: true, selectedBy: [],
+        variationCost: 0, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        options: options,
+    }); };
+    var groupRules = __assign(__assign({}, rules), { fields: [], hasGroups: true, groupFields: [f(800, [opt(801), opt(802)]), f(810, [opt(811, [802])])] });
+    var v = resolveVisibleOptionIds(groupRules, {
+        fieldValues: {},
+        groups: [{ quantity: 5, fieldValues: { 800: { selectedOptionIds: [802] } } }],
+    });
+    expect(v.has(811)).toBe(true);
+});

package/dist/request.js

@@ -0,0 +1,169 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+// eslint-disable-next-line no-unused-vars
+import { getErrorFromCode } from './constants/errors.js';
+var ApiError = /** @class */ (function (_super) {
+    __extends(ApiError, _super);
+    function ApiError(err) {
+        var _this = this;
+        var message = JSON.stringify(err);
+        /* istanbul ignore next */
+        _this = _super.call(this, message) || this;
+        _this.statusCode = err.statusCode;
+        _this.errorCode = getErrorFromCode(err.errorCode);
+        _this.errorMessage = err.message ?
+            err.message : 'No error message';
+        _this.details = err.details;
+        _this.name = 'ApiError';
+        _this.original = err;
+        return _this;
+    }
+    return ApiError;
+}(Error));
+export { ApiError };
+export var version = 'v6';
+function ensureVersionInUri(baseUrl) {
+    // Ensure baseUrl ends with a slash
+    var uri = baseUrl;
+    if (!uri.endsWith('/')) {
+        uri += '/';
+    }
+    // Check if the URI already includes a version
+    var versionPattern = new RegExp('/v\\d+/?$');
+    var match = uri.match(versionPattern);
+    if (match) {
+        // Extract the version and remove it from the URI
+        var foundVersion = match[0].replace(/\//g, '');
+        var strippedUri = uri.replace(versionPattern, '/');
+        return {
+            baseUrl: strippedUri,
+            version: foundVersion
+        };
+    }
+    return {
+        baseUrl: uri,
+        version: version
+    };
+}
+export function backendFetch(baseUrl, resource, options) {
+    var e_1, _a;
+    var _b = ensureVersionInUri(baseUrl), cleanBaseUrl = _b.baseUrl, apiVersion = _b.version;
+    // Remove leading slash from resource if it exists to prevent double slashes
+    var cleanResource = resource.startsWith('/') ? resource.slice(1) : resource;
+    var url = new URL(cleanBaseUrl + apiVersion + '/' + cleanResource);
+    if (options && options.query) {
+        try {
+            for (var _c = __values(options.query), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var entry = _d.value;
+                url.searchParams.append(entry[0], entry[1]);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    return fetch(url.toString(), options);
+}
+export function apiFetch(baseUrl, resource, options, expectEmptyResponse) {
+    return backendFetch(baseUrl, resource, options).then(function (response) {
+        if (response.status < 200 || response.status > 299) {
+            return response.json().then(function (json) {
+                var err = new ApiError(json);
+                return Promise.reject(err);
+            });
+        }
+        else {
+            return expectEmptyResponse ? '' : response.json();
+        }
+    });
+}
+/* istanbul ignore next */
+export function apiFetchWithProgress(baseUrl, resource, options, progressCallback) {
+    return backendFetch(baseUrl, resource, options).then(function (response) {
+        if (!response.body) {
+            var err = new ApiError('empty response');
+            return Promise.reject(err);
+        }
+        var reader = response.body.getReader();
+        var bodyText = '';
+        var errorText = '';
+        var haveError = false;
+        var expected = '{"loadingBar": "' + '.'.repeat(100) + '"}';
+        function readChunk() {
+            return reader.read().then(function (_a) {
+                var done = _a.done, value = _a.value;
+                if (done) {
+                    if (response.status < 200 || response.status > 299) {
+                        var err = new ApiError('Unknown error');
+                        return Promise.reject(err);
+                    }
+                    else if (haveError) {
+                        try {
+                            var jsonText = JSON.parse(errorText);
+                            return Promise.reject(new ApiError(jsonText));
+                        }
+                        catch (e) {
+                            return Promise.reject(new ApiError(errorText));
+                        }
+                    }
+                    else {
+                        return bodyText;
+                    }
+                }
+                else {
+                    var chunk = new TextDecoder().decode(value);
+                    if (haveError) {
+                        errorText += chunk;
+                    }
+                    else {
+                        for (var i = 0; i < chunk.length; ++i) {
+                            var char = chunk[i];
+                            var expectedChar = expected[bodyText.length];
+                            if (expectedChar == char && !haveError) {
+                                bodyText += char;
+                            }
+                            else {
+                                haveError = true;
+                                errorText += char;
+                            }
+                        }
+                    }
+                    if (!haveError && progressCallback) {
+                        var progress = Math.min(Math.max(0, bodyText.length - 16), 100);
+                        progressCallback(progress);
+                    }
+                    return readChunk();
+                }
+            });
+        }
+        return readChunk();
+    });
+}

package/dist/request.test.js

@@ -0,0 +1,70 @@
+import { apiFetch } from './request.js';
+import { ErrorType } from './constants/errors.js';
+import { setup, mockFetch } from './test_util.js';
+setup();
+test('can pass through data from server', function () {
+    mockFetch(true, { 'animal': 'turtle' }, 200);
+    return apiFetch('https://api.merchi.co/', '/test').then(function (data) {
+        expect(data.animal).toBe('turtle');
+    });
+});
+test('can pass through data from server with override url', function () {
+    window.merchiBackendUri = 'http://override.example.com/';
+    mockFetch(true, { 'animal': 'turtle' }, 200);
+    return apiFetch('https://api.merchi.co/', '/test').then(function (data) {
+        expect(data.animal).toBe('turtle');
+    });
+});
+test('404 creates ApiError', function () {
+    mockFetch(false, { 'statusCode': 404, 'errorCode': ErrorType.RESOURCE_NOT_FOUND }, 404);
+    apiFetch('https://api.merchi.co/', '/test').catch(function (e) {
+        expect(e.statusCode).toBe(404);
+        expect(e.name).toBe('ApiError');
+        expect(e.errorCode).toBe(ErrorType.RESOURCE_NOT_FOUND);
+        expect(e.errorMessage).toBe('No error message');
+    });
+});
+test('will get default errorCode', function () {
+    mockFetch(false, { 'statusCode': 404,
+        'errorCode': -1,
+        'message': 'just a test' }, 404);
+    apiFetch('https://api.merchi.co/', '/test').catch(function (e) {
+        expect(e.statusCode).toBe(404);
+        expect(e.name).toBe('ApiError');
+        expect(e.errorCode).toBe(ErrorType.UNKNOWN_ERROR);
+        expect(e.errorMessage).toBe('just a test');
+    });
+});
+test('ApiError exposes details when the server supplies them', function () {
+    var details = {
+        relation: 'file',
+        parentType: 'variation',
+        id: 'abc123',
+        index: 0,
+        provided: {
+            id: 'abc123',
+            uploadId: 'upload-xyz',
+            creationDate: '1776978388',
+        },
+    };
+    mockFetch(false, {
+        'statusCode': 404,
+        'errorCode': ErrorType.RESOURCE_NOT_FOUND,
+        'message': 'no such file #abc123 on variation',
+        'details': details,
+    }, 404);
+    return apiFetch('https://api.merchi.co/', '/test').catch(function (e) {
+        expect(e.name).toBe('ApiError');
+        expect(e.details).toEqual(details);
+        expect(e.details.provided.uploadId).toBe('upload-xyz');
+    });
+});
+test('ApiError leaves details undefined when the server omits them', function () {
+    mockFetch(false, { 'statusCode': 400,
+        'errorCode': ErrorType.RESOURCE_NOT_FOUND,
+        'message': 'plain error' }, 400);
+    return apiFetch('https://api.merchi.co/', '/test').catch(function (e) {
+        expect(e.name).toBe('ApiError');
+        expect(e.details).toBeUndefined();
+    });
+});