@lana-commerce/core 11.0.0

package/cjs/modules/recentlyVisitedProducts.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRecentlyVisitedProducts = void 0;
+const tslib_1 = require("tslib");
+const effector_1 = require("effector");
+const request_js_1 = require("../request.js");
+const compact_js_1 = require("../compact.js");
+function createRecentlyVisitedProducts(config) {
+    const init = () => {
+        try {
+            return JSON.parse(localStorage.getItem(config.key) || "[]");
+        }
+        catch (_a) {
+            return [];
+        }
+    };
+    const recentlyVisitedProducts = (0, effector_1.createStore)([]);
+    const recentlyVisitedProductIDs = (0, effector_1.createStore)(init());
+    recentlyVisitedProductIDs.updates.watch((v) => {
+        try {
+            localStorage.setItem(config.key, JSON.stringify(v));
+        }
+        catch (_a) { }
+    });
+    const fetchProductsFx = (0, effector_1.createEffect)((pl) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const existingIDs = new Set(pl.currentProducts.map((p) => p.id));
+        const missingIDs = pl.ids.filter((id) => !existingIDs.has(id));
+        let newProducts = [];
+        if (missingIDs.length > 0) {
+            const resp = yield (0, request_js_1.request)(config.graphql.getProductsQuery)({
+                shopID: config.shopID,
+                ids: missingIDs,
+            }, config.opts);
+            newProducts = resp.kind === "data" ? resp.data : [];
+        }
+        return Object.assign(Object.assign({}, pl), { newProducts });
+    }));
+    const addRecentlyVisitedProduct = (0, effector_1.createEvent)();
+    recentlyVisitedProductIDs.on(addRecentlyVisitedProduct, (ids, id) => {
+        const a = ids.filter((v) => v !== id);
+        a.splice(0, 0, id);
+        if (a.length > 10) {
+            a.length = 10;
+        }
+        return a;
+    });
+    recentlyVisitedProducts.on(fetchProductsFx.doneData, (_, result) => {
+        const allProducts = new Map();
+        for (const p of [...result.currentProducts, ...result.newProducts]) {
+            allProducts.set(p.id, p);
+        }
+        return (0, compact_js_1.compact)(result.ids.map((id) => allProducts.get(id)));
+    });
+    const fetchNow = (0, effector_1.createEvent)();
+    (0, effector_1.forward)({
+        from: (0, effector_1.sample)((0, effector_1.combine)({ currentProducts: recentlyVisitedProducts, ids: recentlyVisitedProductIDs }), fetchNow),
+        to: fetchProductsFx,
+    });
+    (0, effector_1.forward)({
+        from: (0, effector_1.sample)(recentlyVisitedProducts, recentlyVisitedProductIDs, (currentProducts, ids) => ({
+            currentProducts,
+            ids,
+        })),
+        to: fetchProductsFx,
+    });
+    fetchNow();
+    return {
+        addRecentlyVisitedProduct,
+        recentlyVisitedProducts,
+    };
+}
+exports.createRecentlyVisitedProducts = createRecentlyVisitedProducts;

package/cjs/modules/search.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSearch = void 0;
+const tslib_1 = require("tslib");
+const effector_1 = require("effector");
+const request_js_1 = require("../request.js");
+const combineEvery_js_1 = require("../effector/combineEvery.js");
+const compact_js_1 = require("../compact.js");
+const persist_js_1 = require("./persist.js");
+const requestResponse_js_1 = require("../effector/requestResponse.js");
+function createSearch(config) {
+    const configWithJWTAndLocale = (0, effector_1.combine)(config.jwt, config.locale, (authToken, locale) => (Object.assign(Object.assign({}, config), { opts: Object.assign(Object.assign({}, config.opts), { authToken,
+            locale }) })));
+    const clear = (0, effector_1.createEvent)();
+    const unexpectedError = (0, effector_1.createEvent)();
+    const setQuery = (0, effector_1.createEvent)();
+    const submit = (0, effector_1.createEvent)();
+    const setAllState = (0, effector_1.createEvent)();
+    const query = (0, effector_1.restore)(setQuery, "")
+        .reset(clear)
+        .on(setAllState, (_, v) => v.query);
+    const result = (0, effector_1.createStore)({ kind: "not_submitted" })
+        .reset(clear)
+        .on(setAllState, (_, v) => v.result);
+    const resultQuery = (0, effector_1.createStore)("")
+        .reset(clear)
+        .on(setAllState, (_, v) => v.resultQuery);
+    const resultSubmitted = result.map((v) => (v.kind !== "not_submitted" ? true : false));
+    if (config.persist) {
+        const VERSION = 1;
+        const { load, save, onChange, maxAgeMs } = config.persist;
+        const realMaxAgeMs = Math.max(maxAgeMs !== null && maxAgeMs !== void 0 ? maxAgeMs : 0, 0) || 1800000;
+        const allState = (0, effector_1.combine)({
+            query,
+            result,
+            resultQuery,
+        });
+        {
+            const allState = (0, persist_js_1.deserialize)(load(), VERSION, realMaxAgeMs);
+            if (allState) {
+                setAllState(allState);
+            }
+        }
+        allState.updates.watch((data) => {
+            save((0, persist_js_1.serialize)(data, VERSION));
+        });
+        onChange((data) => {
+            const allState = (0, persist_js_1.deserialize)(data, VERSION, realMaxAgeMs);
+            if (allState) {
+                setAllState(allState);
+            }
+        });
+    }
+    const searchFx = (0, effector_1.createEffect)((p) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, request_js_1.request)(p.config.graphql.searchProductsQuery)({ shopID: p.config.shopID, query: p.query }, p.config.opts);
+    }));
+    const searchFxIdle = searchFx.pending.map((pending) => !pending);
+    const searchResult = (0, requestResponse_js_1.requestResponseSplit)(searchFx.doneData);
+    // success
+    resultQuery.on(searchFx.done.filterMap((v) => (v.result.kind === "data" ? v.params.query : undefined)), (_, v) => v);
+    (0, effector_1.forward)({
+        from: searchResult.data.map((v) => ({ kind: "result", result: (0, compact_js_1.compact)(v.items) })),
+        to: result,
+    });
+    // failure
+    (0, effector_1.forward)({
+        from: searchResult.error.map(() => ({ kind: "error" })),
+        to: result,
+    });
+    (0, effector_1.forward)({
+        from: searchResult.error,
+        to: unexpectedError,
+    });
+    // submit -> (if not pending) -> searchFx
+    (0, effector_1.guard)({
+        source: (0, effector_1.sample)((0, effector_1.combine)(configWithJWTAndLocale, query), submit, ([config, query]) => ({
+            config,
+            query,
+        })),
+        filter: searchFxIdle,
+        target: searchFx,
+    });
+    // on locale change, let's re-submit the query, but only if there was some result
+    (0, effector_1.guard)({
+        source: (0, effector_1.sample)((0, effector_1.combine)(configWithJWTAndLocale, resultQuery), config.locale, ([config, query]) => ({
+            config,
+            query,
+        })),
+        filter: (0, combineEvery_js_1.combineEvery)(searchFxIdle, resultSubmitted),
+        target: searchFx,
+    });
+    return {
+        clear,
+        unexpectedError,
+        setQuery,
+        query,
+        submit,
+        result,
+        pending: searchFx.pending,
+    };
+}
+exports.createSearch = createSearch;

package/cjs/multiResponseToResponse.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multiResponseToResponse = void 0;
+const request_js_1 = require("./request.js");
+function multiResponseToResponse(resp, f, ignoreErrors) {
+    if (resp.kind === "system_error") {
+        return resp;
+    }
+    if (resp.errors && !ignoreErrors) {
+        return { kind: "custom_error", text: (0, request_js_1.prettyPrintGraphErrors)(resp.errors) };
+    }
+    if (!resp.data) {
+        return { kind: "system_error", type: "unrecognized_data_body", details: resp.details };
+    }
+    const data = f(resp.data);
+    return data
+        ? { kind: "data", data: data }
+        : resp.errors
+            ? { kind: "custom_error", text: (0, request_js_1.prettyPrintGraphErrors)(resp.errors) }
+            : { kind: "system_error", type: "unrecognized_data_body", details: resp.details };
+}
+exports.multiResponseToResponse = multiResponseToResponse;

package/cjs/nonNull.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nonNull = void 0;
+function nonNull(v, msg) {
+    if (v !== null && v !== undefined) {
+        return v;
+    }
+    throw new Error("assertion failed, value is null or undefined" + (msg ? `: ${msg}` : ""));
+}
+exports.nonNull = nonNull;

package/cjs/oauthState.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeOauthState = exports.encodeOauthState = void 0;
+function ensureNoColon(v) {
+    if (v.indexOf(":") !== -1) {
+        throw new Error(`invalid state key/value (${v}), must not contain a colon (":")`);
+    }
+}
+function encodeOauthState(kvs) {
+    const keys = Object.keys(kvs).sort();
+    keys.forEach(ensureNoColon);
+    let out = "";
+    for (const k of keys) {
+        const v = kvs[k];
+        if (v === undefined)
+            continue;
+        ensureNoColon(v);
+        if (out)
+            out += ":";
+        out += `${k}:${v}`;
+    }
+    return out;
+}
+exports.encodeOauthState = encodeOauthState;
+function decodeOauthState(state) {
+    const out = {};
+    if (state === "")
+        return out;
+    const components = state.split(":");
+    if (components.length % 2 !== 0) {
+        throw new Error("even number of components expected");
+    }
+    for (let i = 0; i < components.length; i += 2) {
+        const k = components[i + 0];
+        const v = components[i + 1];
+        out[k] = v;
+    }
+    return out;
+}
+exports.decodeOauthState = decodeOauthState;

package/cjs/orderShippingAddress.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orderShippingAddress = void 0;
+function orderShippingAddress(o) {
+    return o.shipping_address_override || o.shipping_address;
+}
+exports.orderShippingAddress = orderShippingAddress;

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/pender.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pender = void 0;
+const tslib_1 = require("tslib");
+function pender(pender, f) {
+    return ((...args) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        pender.pending = true;
+        try {
+            return yield f(...args);
+        }
+        finally {
+            pender.pending = false;
+        }
+    }));
+}
+exports.pender = pender;

package/cjs/percentageOff.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.percentageOff = void 0;
+function percentageOff(from, to) {
+    return Math.round((1.0 - to / from) * 100);
+}
+exports.percentageOff = percentageOff;

package/cjs/popupConnectQueue.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enqueueItem = exports.removeQueueChangeListener = exports.addQueueChangeListener = exports.POPUP_CONNECT_QUEUE_KEY = exports.QueueItemArrayType = exports.QueueItemType = void 0;
+const tslib_1 = require("tslib");
+const ss = tslib_1.__importStar(require("superstruct"));
+const buildconfig_js_1 = require("./buildconfig.js");
+const typedLocalStorage_js_1 = require("./typedLocalStorage.js");
+exports.QueueItemType = ss.union([
+    ss.object({
+        kind: ss.literal("success"),
+        code: ss.string(),
+        state: ss.string(),
+    }),
+    ss.object({
+        kind: ss.literal("success_oauth1"),
+        oauth_token: ss.string(),
+        oauth_verifier: ss.string(),
+    }),
+    ss.object({
+        kind: ss.literal("failure"),
+        state: ss.string(),
+    }),
+]);
+exports.QueueItemArrayType = ss.array(exports.QueueItemType);
+exports.POPUP_CONNECT_QUEUE_KEY = buildconfig_js_1.BUILD_CONFIG.POPUP_CONNECT_QUEUE_KEY;
+function addQueueChangeListener(callback) {
+    if (listeners.find((v) => v === callback))
+        return;
+    listeners.push(callback);
+    if (listeners.length === 1) {
+        window.addEventListener("storage", onStorageEvent);
+    }
+}
+exports.addQueueChangeListener = addQueueChangeListener;
+function removeQueueChangeListener(callback) {
+    const i = listeners.findIndex((v) => v === callback);
+    if (i !== -1) {
+        listeners.splice(i, 1);
+    }
+    if (listeners.length === 0) {
+        window.removeEventListener("storage", onStorageEvent);
+    }
+}
+exports.removeQueueChangeListener = removeQueueChangeListener;
+function enqueueItem(item) {
+    const queue = (0, typedLocalStorage_js_1.loadFromLocalStorageTyped)(exports.POPUP_CONNECT_QUEUE_KEY, exports.QueueItemArrayType) || [];
+    queue.push(item);
+    (0, typedLocalStorage_js_1.saveToLocalStorageTyped)(exports.POPUP_CONNECT_QUEUE_KEY, queue);
+}
+exports.enqueueItem = enqueueItem;
+const listeners = [];
+function onStorageEvent(storageEvent) {
+    if (storageEvent.key !== exports.POPUP_CONNECT_QUEUE_KEY)
+        return;
+    const queue = (0, typedLocalStorage_js_1.loadFromLocalStorageTyped)(exports.POPUP_CONNECT_QUEUE_KEY, exports.QueueItemArrayType) || [];
+    for (const item of queue) {
+        for (const cb of listeners) {
+            cb(item);
+        }
+    }
+    (0, typedLocalStorage_js_1.saveToLocalStorageTyped)(exports.POPUP_CONNECT_QUEUE_KEY, []);
+}

package/cjs/preact/components/SixDigitInput.js

@@ -0,0 +1,167 @@
+"use strict";
+/** @jsx h */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SixDigitInput = void 0;
+const preact_1 = require("preact");
+class SixDigitInput extends preact_1.Component {
+    constructor() {
+        super(...arguments);
+        this.inputRefs = [null, null, null, null, null, null];
+        this.focusedOnce = false;
+        this.cursorKeyDownPos = 0;
+    }
+    focus() {
+        const v = this.inputRefs[0];
+        if (v)
+            v.focus();
+    }
+    onChangeNth(e, idx) {
+        const newValue = e.currentTarget.value;
+        const { value } = this.props;
+        const oldValue = value.length > idx ? value[idx] : "";
+        let nextValue = "";
+        let move = 0;
+        if (oldValue === "") {
+            nextValue = value + newValue;
+            const shouldBeAt = Math.min(5, nextValue.length);
+            move = shouldBeAt - idx;
+        }
+        else if (oldValue !== "") {
+            const ar = value.split("");
+            ar.splice(idx, 1, ...newValue.split(""));
+            nextValue = ar.join("");
+            if (this.cursorKeyDownPos === 1)
+                move = 1;
+        }
+        nextValue = nextValue.substring(0, 6);
+        this.onChange(nextValue, idx, move);
+    }
+    onChange(nextValue, idx, move) {
+        this.props.onChange(nextValue);
+        if (nextValue.length === 6) {
+            const e6 = this.props.onEnteredSixDigits;
+            if (e6) {
+                setTimeout(e6, 0);
+            }
+        }
+        if (move !== 0) {
+            const r = this.inputRefs[idx + move];
+            if (r) {
+                r.focus();
+                if (move > 0) {
+                    r.setSelectionRange(0, 0);
+                }
+                else {
+                    r.setSelectionRange(1, 1);
+                }
+            }
+        }
+    }
+    onKeyDownNth(idx, e) {
+        var _a;
+        const pos = ((_a = this.inputRefs[idx]) === null || _a === void 0 ? void 0 : _a.selectionStart) || 0;
+        const { value } = this.props;
+        const v = value.length > idx ? value[idx] : "";
+        const absPos = idx + pos;
+        const isFirst = pos === 0;
+        const isLast = v.length > 0 ? pos === 1 : true;
+        switch (e.keyCode) {
+            case 8: // backspace
+                e.preventDefault();
+                if (absPos > 0 && absPos <= value.length) {
+                    if (pos === 1)
+                        this.cursorOverride = { idx, pos: 0 };
+                    if (pos === 0)
+                        this.cursorOverride = { idx: idx - 1, pos: 0 };
+                    const ar = value.split("");
+                    ar.splice(absPos - 1, 1);
+                    this.onChange(ar.join(""), idx, pos === 0 ? -1 : 0);
+                }
+                break;
+            case 46: // delete
+                e.preventDefault();
+                if (value.length > absPos) {
+                    if (pos === 0)
+                        this.cursorOverride = { idx, pos: 0 };
+                    const ar = value.split("");
+                    ar.splice(absPos, 1);
+                    this.onChange(ar.join(""), idx, 0);
+                }
+                break;
+            case 37: // arrow left
+                if (isFirst) {
+                    e.preventDefault();
+                    if (idx > 0) {
+                        const r = this.inputRefs[idx - 1];
+                        if (r) {
+                            r.focus();
+                            r.setSelectionRange(1, 1);
+                        }
+                    }
+                }
+                break;
+            case 39: // arrow right
+                if (isLast) {
+                    e.preventDefault();
+                    if (idx < 5) {
+                        const r = this.inputRefs[idx + 1];
+                        if (r) {
+                            r.focus();
+                            r.setSelectionRange(0, 0);
+                        }
+                    }
+                }
+                break;
+            case 36: // home
+                {
+                    const r = this.inputRefs[0];
+                    if (r) {
+                        r.focus();
+                        r.setSelectionRange(0, 0);
+                    }
+                }
+                break;
+            case 35: // end
+                {
+                    const r = this.inputRefs[value.length === 6 ? 5 : value.length];
+                    if (r) {
+                        r.focus();
+                        r.setSelectionRange(1, 1);
+                    }
+                }
+                break;
+            default:
+                if (value.length === 6)
+                    e.preventDefault();
+                this.cursorKeyDownPos = pos;
+                break;
+        }
+    }
+    getValue(idx) {
+        const { value } = this.props;
+        return value.length > idx ? value[idx] : "";
+    }
+    componentDidUpdate() {
+        var _a;
+        const co = this.cursorOverride;
+        if (co) {
+            (_a = this.inputRefs[co.idx]) === null || _a === void 0 ? void 0 : _a.setSelectionRange(co.pos, co.pos);
+            this.cursorOverride = undefined;
+        }
+    }
+    render() {
+        const { autoFocus, className, inputClassName } = this.props;
+        return ((0, preact_1.h)("div", { className: className }, [0, 1, 2, 3, 4, 5].map((i) => ((0, preact_1.h)("input", { key: i, inputMode: "numeric", pattern: "[0-9]*", autoComplete: "off", type: "text", ref: (e) => {
+                this.inputRefs[i] = e;
+                if (i === 0 && autoFocus && !this.focusedOnce && e) {
+                    this.focusedOnce = true;
+                    e.focus();
+                }
+            }, className: inputClassName, value: this.getValue(i), onKeyDown: (e) => {
+                this.onKeyDownNth(i, e);
+            }, onInput: (e) => {
+                this.onChangeNth(e, i);
+            } })))));
+    }
+}
+exports.SixDigitInput = SixDigitInput;

package/cjs/preact/effector.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useStoreMap = exports.useStore = void 0;
+const effector_1 = require("effector");
+const hooks_1 = require("preact/hooks");
+const useIsomorphicLayoutEffect = typeof window !== "undefined" ? hooks_1.useLayoutEffect : hooks_1.useEffect;
+const throwError = (message) => {
+    throw Error(message);
+};
+function useStore(store) {
+    if (!effector_1.is.store(store))
+        throwError("expect useStore argument to be a store");
+    const currentValue = store.getState();
+    const inc = (0, hooks_1.useReducer)((n, _action) => n + 1, 0)[1];
+    const currentStore = (0, hooks_1.useRef)({
+        store,
+        value: currentValue,
+        pending: false,
+    });
+    useIsomorphicLayoutEffect(() => {
+        const stop = store.updates.watch((upd) => {
+            const ref = currentStore.current;
+            if (!ref.pending) {
+                ref.value = upd;
+                ref.pending = true;
+                inc();
+                ref.pending = false;
+            }
+        });
+        const newValue = store.getState();
+        const ref = currentStore.current;
+        if (ref.store === store && ref.value !== newValue) {
+            ref.value = newValue;
+            ref.pending = true;
+            inc();
+            ref.pending = false;
+        }
+        ref.store = store;
+        return stop;
+    }, [store]);
+    return currentValue;
+}
+exports.useStore = useStore;
+function useStoreMap(configOrStore, separateFn) {
+    let fn;
+    let updateFilter;
+    let store;
+    let keys;
+    if (separateFn) {
+        fn = separateFn;
+        store = configOrStore;
+        keys = [];
+    }
+    else {
+        fn = configOrStore.fn;
+        store = configOrStore.store;
+        keys = configOrStore.keys;
+        updateFilter = configOrStore.updateFilter;
+    }
+    if (!effector_1.is.store(store))
+        throwError("useStoreMap expects a store");
+    if (!Array.isArray(keys))
+        throwError("useStoreMap expects an array as keys");
+    if (typeof fn !== "function")
+        throwError("useStoreMap expects a function");
+    const result = (0, hooks_1.useMemo)(() => (0, effector_1.createStore)(fn(store.getState(), keys), { updateFilter }).on(store, (_, state) => fn(state, keys)), keys);
+    const state = useStore(result);
+    useIsomorphicLayoutEffect(() => () => {
+        result.off(store);
+        (0, effector_1.clearNode)(result, { deep: true });
+    }, keys);
+    return state;
+}
+exports.useStoreMap = useStoreMap;

package/cjs/preact/transition/CSSTransition.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSSTransition = void 0;
+const tslib_1 = require("tslib");
+/** @jsx h */
+const preact_1 = require("preact");
+const hooks_1 = require("preact/hooks");
+const Transition_js_1 = require("./Transition.js");
+const createClassName = (transition, classNames) => {
+    const { appear, appearActive, appearDone, enter, enterActive, enterDone, exit, exitActive, exitDone } = transition;
+    const classes = typeof classNames === "string"
+        ? {
+            appear: `${classNames}-appear`,
+            appearActive: `${classNames}-appear-active`,
+            appearDone: `${classNames}-appear-done`,
+            enter: `${classNames}-enter`,
+            enterActive: `${classNames}-enter-active`,
+            enterDone: `${classNames}-enter-done`,
+            exit: `${classNames}-exit`,
+            exitActive: `${classNames}-exit-active`,
+            exitDone: `${classNames}-exit-done`,
+        }
+        : classNames;
+    switch (true) {
+        case appear:
+            return classes.appear;
+        case appearActive:
+            return `${classes.appear} ${classes.appearActive}`;
+        case appearDone:
+            return classes.appearDone;
+        case enter:
+            return classes.enter;
+        case enterActive:
+            return `${classes.enter} ${classes.enterActive}`;
+        case enterDone:
+            return classes.enterDone;
+        case exit:
+            return classes.exit;
+        case exitActive:
+            return `${classes.exit} ${classes.exitActive}`;
+        case exitDone:
+            return classes.exitDone;
+        default:
+            return "";
+    }
+};
+const CSSTransition = (_a) => {
+    var { classNames, children } = _a, rest = tslib_1.__rest(_a, ["classNames", "children"]);
+    return ((0, preact_1.h)(Transition_js_1.Transition, Object.assign({}, rest), (transition) => {
+        const { className: childClassName } = children.props;
+        const className = (0, hooks_1.useMemo)(() => `${childClassName ? `${childClassName} ` : ""}${createClassName(transition, classNames)}`, [childClassName, classNames, transition]);
+        return (0, preact_1.cloneElement)(children, { className });
+    }));
+};
+exports.CSSTransition = CSSTransition;