@lana-commerce/core 11.0.0

package/cjs/configLoader.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = exports.booleanVar = exports.stringVar = exports.anyVar = void 0;
+function anyVar(mandatory) {
+    const v = { kind: "any", __type: undefined, mandatory };
+    return mandatory ? { kind: "mandatory", mandatory: v } : v;
+}
+exports.anyVar = anyVar;
+// prettier-ignore
+function stringVar(envVars, defaultValue, mandatory) {
+    const v = { kind: "string", envVars, defaultValue, mandatory };
+    return defaultValue !== undefined ? { kind: "default", default: v } : mandatory ? { kind: "mandatory", mandatory: v } : v;
+}
+exports.stringVar = stringVar;
+// prettier-ignore
+function booleanVar(envVars, defaultValue, mandatory) {
+    const v = { kind: "boolean", envVars, defaultValue, mandatory };
+    return defaultValue !== undefined ? { kind: "default", default: v } : mandatory ? { kind: "mandatory", mandatory: v } : v;
+}
+exports.booleanVar = booleanVar;
+function varToBaseBar(v) {
+    if (v.kind === "default") {
+        return v.default;
+    }
+    else if (v.kind === "mandatory") {
+        return v.mandatory;
+    }
+    else {
+        return v;
+    }
+}
+function envVarOrUndefined(v) {
+    var _a;
+    if (v.kind === "string" || v.kind === "boolean") {
+        for (const envKey of v.envVars) {
+            const envVal = (_a = process.env[envKey]) === null || _a === void 0 ? void 0 : _a.trim();
+            if (envVal) {
+                if (v.kind === "string") {
+                    return envVal;
+                }
+                else {
+                    return true;
+                }
+            }
+        }
+    }
+}
+function defaultOrUndefined(v) {
+    return v.kind === "string" || v.kind === "boolean" ? v.defaultValue : undefined;
+}
+function loadConfig(confDef, input) {
+    const out = {};
+    for (const key in confDef) {
+        const fdef = varToBaseBar(confDef[key]);
+        let val = input[key];
+        if (val === undefined) {
+            val = envVarOrUndefined(fdef);
+        }
+        if (val === undefined) {
+            val = defaultOrUndefined(fdef);
+        }
+        if (val === undefined && fdef.mandatory) {
+            throw new Error(`"${key}" config field is mandatory`);
+        }
+        out[key] = val;
+    }
+    return out;
+}
+exports.loadConfig = loadConfig;

package/cjs/controlledQueue.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControlledQueue = void 0;
+const tslib_1 = require("tslib");
+class ControlledQueue {
+    constructor() {
+        this.queue = [];
+    }
+    discardQueue() {
+        while (this.queue.length > 0) {
+            const item = this.queue[0];
+            this.queue.splice(0, 1);
+            item.resolve({ kind: "discarded" });
+        }
+    }
+    queueLoop() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let discard = false;
+            const controller = {
+                discard: () => {
+                    discard = true;
+                },
+            };
+            while (this.queue.length > 0) {
+                const item = this.queue[0];
+                this.queue.splice(0, 1);
+                const result = yield item.pfn(controller);
+                item.resolve({ kind: "resolved", value: result });
+                if (discard) {
+                    discard = false;
+                    this.discardQueue();
+                }
+            }
+            this.queueLoopPromise = undefined;
+        });
+    }
+    exec(pfn) {
+        return new Promise((resolve) => {
+            this.queue.push({ pfn, resolve });
+            if (!this.queueLoopPromise) {
+                this.queueLoopPromise = Promise.resolve().then(() => this.queueLoop());
+            }
+        });
+    }
+}
+exports.ControlledQueue = ControlledQueue;

package/cjs/convertImageURL.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertImageURL = void 0;
+const compact_js_1 = require("./compact.js");
+function convertImageURL(cdnBaseURL, url, p) {
+    if (!url) {
+        url = `${cdnBaseURL}/placeholder.svg`;
+    }
+    const extMatch = url.match(/\.[^/.]+$/);
+    if (!extMatch) {
+        // no extension, bail out, shouldn't really happen
+        return "";
+    }
+    const ext = extMatch[0];
+    const noext = url.replace(/\.[^/.]+$/, ""); // strip away extension
+    const params = (0, compact_js_1.compact)([p.size, p.crop, p.low ? "low" : undefined]);
+    return params.length === 0 ? url : noext + "_" + params.join("_") + (p.scale ? `@${p.scale}x` : "") + ext;
+}
+exports.convertImageURL = convertImageURL;

package/cjs/dataLoader.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadData = void 0;
+const tslib_1 = require("tslib");
+const request_js_1 = require("./request.js");
+const script_js_1 = require("./script.js");
+const arrayToDict_js_1 = require("./arrayToDict.js");
+const compact_js_1 = require("./compact.js");
+const fetchAllItems_js_1 = require("./fetchAllItems.js");
+const nonNull_js_1 = require("./nonNull.js");
+const promiseAll_js_1 = require("./promiseAll.js");
+const timeIt_js_1 = require("./timeIt.js");
+function throwOnFailure(resp) {
+    if (resp.kind !== "data") {
+        throw new Error((0, request_js_1.prettyPrintRequestResponseError)(resp, true));
+    }
+    return resp.data;
+}
+function fetchCategoriesTreeRecursive(shopID, query, opts, category) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const apiCategories = throwOnFailure(yield (0, request_js_1.request)(query)({ shopID, childrenOf: category ? category.id : undefined }, opts));
+        const categories = apiCategories.map((c) => (Object.assign(Object.assign({}, c), { children: [] })));
+        for (const category of categories) {
+            if (!category.has_children)
+                continue;
+            category.children = yield fetchCategoriesTreeRecursive(shopID, query, opts, category);
+        }
+        return categories;
+    });
+}
+function categoriesForEach(categories, cb, parentID = "") {
+    for (const c of categories) {
+        cb(c, parentID);
+        categoriesForEach(c.children, cb, c.id);
+    }
+}
+function flattenCategories(categories) {
+    const out = [];
+    categoriesForEach(categories, (c) => {
+        const cc = Object.assign(Object.assign({}, c), { children: [] });
+        out.push(cc);
+    });
+    return out;
+}
+function createCategoriesMap(categories) {
+    const out = {};
+    categoriesForEach(categories, (c) => {
+        out[c.id] = c;
+    });
+    return out;
+}
+function createCategoryParentMap(categories) {
+    const out = {};
+    categoriesForEach(categories, (c, parentID) => {
+        out[c.id] = parentID;
+    });
+    return out;
+}
+function categoryRelativeURL(c, cmap, cpmap) {
+    const parentCategory = cmap[cpmap[c.id] || ""];
+    const parentURL = parentCategory ? categoryRelativeURL(parentCategory, cmap, cpmap) : "";
+    return `${parentURL}/${c.handle}`;
+}
+//--------------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------------
+function createCategoryBriefs(categories, products) {
+    const cmap = createCategoriesMap(categories);
+    const cpmap = createCategoryParentMap(categories);
+    const out = {};
+    categoriesForEach(categories, (c, parentID) => {
+        var _a, _b;
+        out[c.id] = {
+            id: c.id,
+            parentID: parentID,
+            title: c.title,
+            relativeUrl: categoryRelativeURL(c, cmap, cpmap),
+            featured: c.featured,
+            quantity: products.reduce((count, p) => { var _a; return count + (((_a = p.categories) === null || _a === void 0 ? void 0 : _a.some((pc) => (pc === null || pc === void 0 ? void 0 : pc.id) === c.id)) ? 1 : 0); }, 0),
+            imageUrl: ((_b = (_a = c.image_files) === null || _a === void 0 ? void 0 : _a.find(() => true)) === null || _b === void 0 ? void 0 : _b.public_url) || undefined,
+        };
+    });
+    return out;
+}
+function createProductBriefs(products) {
+    var _a;
+    const out = {};
+    for (const p of products) {
+        out[p.id] = {
+            id: p.id,
+            handle: p.handle,
+            title: p.title,
+            average_score: p.average_score,
+            review_count: p.review_count,
+            variants: (0, compact_js_1.compact)((_a = p.variants) === null || _a === void 0 ? void 0 : _a.map((v) => v
+                ? {
+                    currency_prices: v.currency_prices,
+                    customer_group_price: v.customer_group_price,
+                    id: v.id,
+                    inventory: v.inventory,
+                    inventory_policy: v.inventory_policy,
+                    is_default: v.is_default,
+                    map_price: v.map_price,
+                    media_files: v.media_files,
+                    options: v.options.map((opt) => ({
+                        option_id: opt.option_id,
+                        option_value_id: opt.option_value_id,
+                    })),
+                    price: v.price,
+                    retail_price: v.retail_price,
+                    sale_price: v.sale_price,
+                    sale_price_eligible: v.sale_price_eligible,
+                    sku: v.sku,
+                    tiered_pricing: v.tiered_pricing,
+                }
+                : undefined)),
+        };
+    }
+    return out;
+}
+function loadDataForLanguage(config, locale, isDefault) {
+    var _a;
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const opts = locale ? Object.assign(Object.assign({}, config.opts), { locale }) : config.opts;
+        const ltimeIt = (name, cb) => {
+            const prefix = locale ? `[${locale}] ` : "";
+            const log = (seconds) => {
+                console.log(`${prefix}fetched ${name}: ${seconds.toFixed(3)}s elapsed`);
+            };
+            return (0, timeIt_js_1.timeIt)(log, cb);
+        };
+        const { shop, currencies, products, menus, contentBlocks, categoriesTree, branding, gateways, reviewDimensions, reviewSettings, options, inventoryLocations, } = yield (0, promiseAll_js_1.promiseAll)({
+            shop: ltimeIt("shop", () => tslib_1.__awaiter(this, void 0, void 0, function* () { return throwOnFailure(yield (0, request_js_1.request)(config.graphql.getShopQuery)({ shopID: config.shopID }, opts))[0]; })),
+            currencies: ltimeIt("currencies", () => tslib_1.__awaiter(this, void 0, void 0, function* () { return throwOnFailure(yield (0, request_js_1.request)(config.graphql.getShopCurrenciesQuery)({ shopID: config.shopID }, opts)); })),
+            products: ltimeIt("products", () => tslib_1.__awaiter(this, void 0, void 0, function* () { return throwOnFailure(yield (0, fetchAllItems_js_1.fetchAllItems)(config.graphql.getProductsPageQuery, { shopID: config.shopID }, opts)); })),
+            menus: ltimeIt("menus", () => tslib_1.__awaiter(this, void 0, void 0, function* () { return throwOnFailure(yield (0, fetchAllItems_js_1.fetchAllItems)(config.graphql.getMenusPageQuery, { shopID: config.shopID }, opts)); })),
+            contentBlocks: ltimeIt("content blocks", () => tslib_1.__awaiter(this, void 0, void 0, function* () { return throwOnFailure(yield (0, fetchAllItems_js_1.fetchAllItems)(config.graphql.getContentBlocksPageQuery, { shopID: config.shopID }, opts)); })),
+            categoriesTree: ltimeIt("categories", () => tslib_1.__awaiter(this, void 0, void 0, function* () { return fetchCategoriesTreeRecursive(config.shopID, config.graphql.getCategoriesQuery, opts); })),
+            branding: ltimeIt("branding", () => tslib_1.__awaiter(this, void 0, void 0, function* () { return throwOnFailure(yield (0, request_js_1.request)(config.graphql.getBrandingQuery)({ shopID: config.shopID }, opts)); })),
+            gateways: ltimeIt("gateways", () => tslib_1.__awaiter(this, void 0, void 0, function* () { return throwOnFailure(yield (0, request_js_1.request)(config.graphql.getGatewaysQuery)({ shopID: config.shopID }, opts)); })),
+            reviewDimensions: ltimeIt("review dimensions", () => tslib_1.__awaiter(this, void 0, void 0, function* () { return throwOnFailure(yield (0, request_js_1.request)(config.graphql.getReviewDimensionsQuery)({ shopID: config.shopID }, opts)); })),
+            reviewSettings: ltimeIt("review settings", () => tslib_1.__awaiter(this, void 0, void 0, function* () { return throwOnFailure(yield (0, request_js_1.request)(config.graphql.getReviewSettingsQuery)({ shopID: config.shopID }, opts)); })),
+            options: ltimeIt("options", () => tslib_1.__awaiter(this, void 0, void 0, function* () { return throwOnFailure(yield (0, request_js_1.request)(config.graphql.getOptionsQuery)({ shopID: config.shopID }, opts)); })),
+            inventoryLocations: ltimeIt("inventoryLocations", () => tslib_1.__awaiter(this, void 0, void 0, function* () { return throwOnFailure(yield (0, request_js_1.request)(config.graphql.getInventoryLocationsQuery)({ shopID: config.shopID }, opts)); })),
+        });
+        const analytics = yield (0, script_js_1.embedAnalytics)({
+            shop,
+            branding,
+            cdn: config.cdn,
+            beacon: config.beacon,
+        });
+        const categoriesBrief = createCategoryBriefs(categoriesTree, products);
+        const categories = flattenCategories(categoriesTree);
+        const productsBrief = createProductBriefs(products);
+        const shopLocale = locale || ((_a = shop.language) === null || _a === void 0 ? void 0 : _a.code) || "en";
+        const additionalDataContext = { menus, contentBlocks };
+        const additionalShopData = config.resolveAdditionalShopData(additionalDataContext);
+        const additionalLocaleData = config.resolveAdditionalLocaleData(additionalDataContext);
+        return Object.assign({ isDefault: isDefault !== null && isDefault !== void 0 ? isDefault : true, locale: shopLocale, shopData: Object.assign({ singleLocale: locale === undefined, locale: shopLocale, shop, currencies: (0, arrayToDict_js_1.arrayToDict)(currencies, (c) => c.currency.code), options: (0, arrayToDict_js_1.arrayToDict)(options, (opt) => opt.id), inventoryLocations: (0, arrayToDict_js_1.arrayToDict)(inventoryLocations, (il) => il.id), gateways,
+                reviewSettings, reviewDimensions: (0, arrayToDict_js_1.arrayToDict)(reviewDimensions, (rd) => rd.id), categories: categoriesBrief, siteUrl: config.siteUrl, cdn: config.cdn, opts, staticData: config.staticData }, additionalShopData), products,
+            productsBrief,
+            contentBlocks,
+            categories,
+            branding,
+            gateways,
+            analytics }, additionalLocaleData);
+    });
+}
+function loadData(config) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const shop = throwOnFailure(yield (0, request_js_1.request)(config.graphql.getShopQuery)({ shopID: config.shopID }, config.opts))[0];
+        const shopExtraLanguages = (0, compact_js_1.compact)(shop.languages);
+        const shopLanguage = (0, nonNull_js_1.nonNull)(shop.language, "shop language");
+        if (!shop.languages || shop.languages.length === 0) {
+            return { perLocale: [yield loadDataForLanguage(config)] };
+        }
+        else {
+            const allLanguages = [shopLanguage, ...shopExtraLanguages];
+            return {
+                perLocale: yield Promise.all(allLanguages.map((l, idx) => tslib_1.__awaiter(this, void 0, void 0, function* () { return loadDataForLanguage(config, l.code, idx === 0); }))),
+            };
+        }
+    });
+}
+exports.loadData = loadData;

package/cjs/defaultVariant.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultVariant = void 0;
+function defaultVariant(product) {
+    var _a;
+    if (!product)
+        return undefined;
+    let out;
+    if (product.variants) {
+        for (const v of product.variants) {
+            if (!v)
+                continue;
+            if (!out) {
+                // some variant, better than nothing
+                out = v;
+            }
+            if ((((_a = v.media_files) === null || _a === void 0 ? void 0 : _a.length) || 0) > 0) {
+                // prefer some variant with images
+                out = v;
+            }
+            if (v.is_default) {
+                // definitely the one we're looking for
+                out = v;
+                break;
+            }
+        }
+    }
+    return out;
+}
+exports.defaultVariant = defaultVariant;

package/cjs/effector/clearOnChangeAfterDelay.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearOnChangeAfterDelay = void 0;
+const effector_1 = require("effector");
+function clearOnChangeAfterDelay(store, timeout) {
+    const clear = (0, effector_1.createEvent)();
+    store.reset(clear);
+    let lastTimeout = null;
+    store.updates.watch(() => {
+        if (lastTimeout)
+            clearTimeout(lastTimeout);
+        lastTimeout = setTimeout(() => {
+            clear();
+        }, timeout);
+    });
+}
+exports.clearOnChangeAfterDelay = clearOnChangeAfterDelay;

package/cjs/effector/combineEvery.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combineEvery = void 0;
+const effector_1 = require("effector");
+function combineEvery(...stores) {
+    return (0, effector_1.combine)(stores, (stores) => stores.every(Boolean));
+}
+exports.combineEvery = combineEvery;

package/cjs/effector/combineSome.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combineSome = void 0;
+const effector_1 = require("effector");
+function combineSome(...stores) {
+    return (0, effector_1.combine)(stores, (stores) => stores.some(Boolean));
+}
+exports.combineSome = combineSome;

package/cjs/effector/debounced.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debounced = void 0;
+const effector_1 = require("effector");
+function debounced(src, dst, delay) {
+    const setDst = (0, effector_1.createEvent)();
+    dst.on(setDst, (_, v) => v);
+    let timeout;
+    src.updates.watch((v) => {
+        if (timeout)
+            clearTimeout(timeout);
+        timeout = setTimeout(() => {
+            setDst(v);
+            timeout = undefined;
+        }, delay);
+    });
+}
+exports.debounced = debounced;

package/cjs/effector/form.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFormWithCustomError = exports.createForm = exports.createEnumField = exports.createStringField = exports.createBooleanField = void 0;
+const effector_1 = require("effector");
+const validator_js_1 = require("./validator.js");
+const restoreNamed_js_1 = require("./restoreNamed.js");
+function commonFields(name) {
+    const setAPIError = (0, effector_1.createEvent)(`${name}.setAPIError`);
+    const apiError = (0, restoreNamed_js_1.restoreNamed)(setAPIError.map((errs) => { var _a; return ((_a = errs[name]) === null || _a === void 0 ? void 0 : _a.problem) || null; }), null, `${name}.apiError`);
+    return {
+        setAPIError,
+        apiError,
+    };
+}
+function createBooleanField(name, initialValueArg) {
+    const { apiError, setAPIError } = commonFields(name);
+    const change = (0, effector_1.createEvent)(`${name}.change`);
+    const changeUntouched = (0, effector_1.createEvent)(`${name}.changeUntouched`);
+    const touch = (0, effector_1.createEvent)(`${name}.touch`); // for compatibility with createFormSubmit
+    const setInitialValue = (0, effector_1.createEvent)(`${name}.setInitialValue`);
+    const initialValue = (0, restoreNamed_js_1.restoreNamed)(setInitialValue, initialValueArg, `${name}.initialValue`);
+    const value = (0, restoreNamed_js_1.restoreNamed)(change, initialValueArg, `${name}.value`).on(changeUntouched, (_, v) => v);
+    const invalid = (0, effector_1.createStore)(null, { name: `${name}.invalid` });
+    const visibleError = apiError;
+    const reset = (0, effector_1.createEvent)(`${name}.reset`);
+    apiError.reset(reset);
+    (0, effector_1.sample)({
+        source: initialValue,
+        clock: reset,
+        target: value,
+    });
+    return {
+        reset,
+        touch,
+        change,
+        changeUntouched,
+        value,
+        invalid,
+        setAPIError,
+        apiError,
+        visibleError,
+        setInitialValue,
+        initialValue,
+    };
+}
+exports.createBooleanField = createBooleanField;
+function createStringField(name, initialValueArg, validators) {
+    return createCommonStringField(name, initialValueArg, validators);
+}
+exports.createStringField = createStringField;
+function createEnumField(name, initialValueArg, validators) {
+    return createCommonStringField(name, initialValueArg, validators);
+}
+exports.createEnumField = createEnumField;
+function createCommonStringField(name, initialValueArg, validators) {
+    const { apiError, setAPIError } = commonFields(name);
+    const change = (0, effector_1.createEvent)(`${name}.change`);
+    const changeUntouched = (0, effector_1.createEvent)(`${name}.changeUntouched`);
+    const touch = (0, effector_1.createEvent)(`${name}.touch`);
+    const touched = (0, restoreNamed_js_1.restoreNamed)(change.map(() => true), false, `${name}.touched`).on(touch, () => true);
+    const setInitialValue = (0, effector_1.createEvent)(`${name}.setInitialValue`);
+    const initialValue = (0, restoreNamed_js_1.restoreNamed)(setInitialValue, initialValueArg, `${name}.initialValue`);
+    const value = (0, restoreNamed_js_1.restoreNamed)(change, initialValueArg, `${name}.value`).on(changeUntouched, (_, v) => v);
+    const invalid = (0, validator_js_1.applyValidators)(value, validators);
+    const visibleError = (0, effector_1.combine)(touched, invalid, apiError, (touched, invalid, apiError) => {
+        if (apiError)
+            return apiError;
+        if (touched && invalid)
+            return invalid;
+        return null;
+    });
+    const reset = (0, effector_1.createEvent)(`${name}.reset`);
+    apiError.reset(reset);
+    touched.reset(reset);
+    (0, effector_1.sample)({
+        source: initialValue,
+        clock: reset,
+        target: value,
+    });
+    return {
+        reset,
+        change,
+        changeUntouched,
+        touch,
+        touched,
+        value,
+        invalid,
+        setAPIError,
+        apiError,
+        visibleError,
+        setInitialValue,
+        initialValue,
+    };
+}
+function fieldValues(obj, keys) {
+    const out = {};
+    for (const key of keys) {
+        out[key] = obj[key].value;
+    }
+    return out;
+}
+function createForm(obj) {
+    const init = (0, effector_1.createEvent)();
+    const propagateInitialValues = (0, effector_1.createEvent)();
+    const reset = (0, effector_1.createEvent)();
+    const submit = (0, effector_1.createEvent)();
+    const keys = Object.keys(obj);
+    (0, effector_1.forward)({
+        from: submit,
+        to: keys.map((f) => obj[f].touch),
+    });
+    (0, effector_1.forward)({
+        from: [reset, init],
+        to: keys.map((f) => obj[f].reset),
+    });
+    for (const key of keys) {
+        const f = obj[key];
+        (0, effector_1.forward)({
+            from: init.map((v) => v[key]),
+            to: f.setInitialValue,
+        });
+        (0, effector_1.forward)({
+            from: propagateInitialValues.map((v) => v[key]),
+            to: f.setInitialValue,
+        });
+    }
+    const valid = (0, validator_js_1.combineValidators)(keys.map((f) => obj[f].invalid));
+    // TODO: I failed figuring out how to do the type here properly. If I apply the actual type from function signature,
+    // "guard()" type inference starts to fail. Could be lib issue. Or just a type inference mess.
+    const submitted = (0, effector_1.createEvent)();
+    (0, effector_1.guard)({
+        source: (0, effector_1.combine)(fieldValues(obj, keys)),
+        clock: submit,
+        filter: valid,
+        target: submitted,
+    });
+    const propagateErrors = (0, effector_1.createEvent)();
+    (0, effector_1.forward)({
+        from: propagateErrors,
+        to: keys.map((f) => obj[f].setAPIError),
+    });
+    const noAPIErrorsSet = (0, effector_1.combine)(keys.map((f) => obj[f].apiError), (errs) => errs.every((e) => !e));
+    const errorPropagationFailed = (0, effector_1.createEvent)();
+    (0, effector_1.guard)({
+        source: propagateErrors,
+        filter: noAPIErrorsSet,
+        target: errorPropagationFailed,
+    });
+    return Object.assign(Object.assign({}, obj), { init,
+        reset,
+        submit,
+        submitted,
+        valid,
+        propagateErrors,
+        propagateInitialValues,
+        errorPropagationFailed });
+}
+exports.createForm = createForm;
+function createFormWithCustomError(obj, err) {
+    const form = createForm(obj);
+    const setError = (0, effector_1.createEvent)("setError");
+    const error = (0, restoreNamed_js_1.restoreNamed)(setError, err, "error");
+    error.reset(form.init);
+    error.reset(form.reset);
+    return Object.assign(Object.assign({}, form), { error,
+        setError });
+}
+exports.createFormWithCustomError = createFormWithCustomError;

package/cjs/effector/hideOnChangeAfterDelay.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hideOnChangeAfterDelay = void 0;
+const effector_1 = require("effector");
+function hideOnChangeAfterDelay(store, timeout) {
+    const clear = (0, effector_1.createEvent)();
+    store.on(clear, (prev) => (Object.assign(Object.assign({}, prev), { visible: false })));
+    let lastTimeout = null;
+    store.updates.watch(() => {
+        if (lastTimeout)
+            clearTimeout(lastTimeout);
+        lastTimeout = setTimeout(() => {
+            clear();
+        }, timeout);
+    });
+}
+exports.hideOnChangeAfterDelay = hideOnChangeAfterDelay;

package/cjs/effector/requestResponse.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestResponseSplitFirst = exports.requestResponseSplit = exports.requestResponseSplitGeneric = void 0;
+const effector_1 = require("effector");
+function requestResponseSplitGeneric(ev, fn) {
+    const dataSink = (0, effector_1.createEvent)();
+    const errorSink = (0, effector_1.createEvent)();
+    const data = dataSink.filterMap((v) => (v.kind === "data" ? fn(v.data) : undefined));
+    const error = errorSink.filterMap((v) => (v.kind !== "data" ? v : undefined));
+    (0, effector_1.split)({
+        source: ev,
+        match: (ev) => ev.kind,
+        cases: {
+            data: dataSink,
+            error: errorSink,
+            system_error: errorSink,
+            custom_error: errorSink,
+        },
+    });
+    return { data, error };
+}
+exports.requestResponseSplitGeneric = requestResponseSplitGeneric;
+function requestResponseSplit(ev) {
+    return requestResponseSplitGeneric(ev, (v) => v);
+}
+exports.requestResponseSplit = requestResponseSplit;
+function requestResponseSplitFirst(ev) {
+    return requestResponseSplitGeneric(ev, (v) => v[0]);
+}
+exports.requestResponseSplitFirst = requestResponseSplitFirst;

package/cjs/effector/requestResponseMulti.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestResponseSplitMulti = void 0;
+const effector_1 = require("effector");
+const request_js_1 = require("../request.js");
+const split_js_1 = require("./split.js");
+function allFieldsAreNull(v) {
+    for (var key in v) {
+        if (v[key] !== null)
+            return false;
+    }
+    return true;
+}
+function requestResponseSplitMulti(ev) {
+    const data = (0, effector_1.createEvent)();
+    const error = (0, effector_1.createEvent)();
+    (0, split_js_1.splitMap)(ev)
+        .map((v) => {
+        return v.kind !== "data_or_error" ? v : undefined;
+    }, error)
+        .map((v) => {
+        if (v.kind !== "data_or_error")
+            return undefined;
+        if (v.errors && allFieldsAreNull(v.data)) {
+            const err = {
+                kind: "custom_error",
+                text: (0, request_js_1.prettyPrintGraphErrors)(v.errors),
+            };
+            return err;
+        }
+        if (!v.data) {
+            const err = {
+                kind: "custom_error",
+                text: "no data",
+            };
+            return err;
+        }
+        return undefined;
+    }, error)
+        .map((v) => {
+        if (v.kind !== "data_or_error")
+            return undefined;
+        if (v.errors && allFieldsAreNull(v.data))
+            return undefined;
+        if (!v.data)
+            return undefined;
+        return v.data;
+    }, data);
+    return { data, error };
+}
+exports.requestResponseSplitMulti = requestResponseSplitMulti;