@salla.sa/twilight-components 2.14.589 → 2.14.591

package/dist/types/components/salla-products-list/salla-products-list.d.ts

@@ -35,6 +35,8 @@ export declare class SallaProductsList {
     limit: number;
     /**
      * Sorting the list of products
+     * On the main filterable search page, the initial order follows search relevance
+     * unless the shopper supplies `sort` or `by` in the URL. Later updates still apply.
      */
     sortBy?: string | 'ourSuggest' | 'bestSell' | 'topRated' | 'priceFromTopToLow' | 'priceFromLowToTop';
     /**
@@ -244,6 +246,8 @@ export declare class SallaProductsList {
      * Clear the current selection.
      */
     clearSelection(): Promise<void>;
+    private isSearchPageList;
+    private syncSearchSortControl;
     componentWillLoad(): any;
     componentDidLoad(): Promise<void>;
     private canRender;

package/dist/types/components.d.ts

@@ -2581,7 +2581,7 @@ export namespace Components {
          */
         "setFilters": (filters: any) => Promise<void>;
         /**
-          * Sorting the list of products
+          * Sorting the list of products On the main filterable search page, the initial order follows search relevance unless the shopper supplies `sort` or `by` in the URL. Later updates still apply.
          */
         "sortBy"?: | string
     | 'ourSuggest'
@@ -7912,7 +7912,7 @@ declare namespace LocalJSX {
          */
         "selectable"?: boolean;
         /**
-          * Sorting the list of products
+          * Sorting the list of products On the main filterable search page, the initial order follows search relevance unless the shopper supplies `sort` or `by` in the URL. Later updates still apply.
          */
         "sortBy"?: | string
     | 'ourSuggest'

package/dist/types/shared/cart-free-gifts.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Shared free-gift lookup for the cart.
+ *
+ * The gift feature is twilight-only: no theme passes `added-by-offer` /
+ * `free-gift-quantity` attributes. `salla-conditional-offer` resolves the gift LINES it
+ * lists (read-only, as information) and the cart line count from here, never from theme
+ * attributes.
+ *
+ * Data source: `salla.api.cart.details()` — it hits the `api.cart.show`
+ * route, which IS in `CartPresenter::$routesWithItems`, so the response
+ * carries `data.cart.items[]` with the per-item keys `added_by_offer`
+ * (bool), `offer_id` (int|null) and `free_gift_quantity` (int) set by
+ * `CartItemTransformer.php`. Those three names are a pinned
+ * contract — do not rename them here or on the components that consume them.
+ *
+ * We deliberately never read these fields off a `cart::updated` payload:
+ * that event fires from `latest()` too, and `api.cart.latest` is NOT in
+ * `$routesWithItems`, so a `cart::updated` payload legitimately carries no
+ * `items` at all. Callers must fetch on mount and call
+ * `refreshCartFreeGifts()` on the event — this module never derives from
+ * event payloads.
+ *
+ * The banner asks for the gift lines and the cart line count on the same tick (initial
+ * mount, and again on every `cart::updated`). Concurrent callers share a
+ * single in-flight promise, mirroring `_pendingOffersRequest` in
+ * `twilight/packages/twilight/src/api/cart.js:831-846`.
+ */
+/**
+ * A gift cart LINE, with the few display fields `salla-conditional-offer` needs to
+ * render its free-gifts card: a thumbnail, the
+ * product name, the price it would have cost, and the cart-item id it is keyed by.
+ *
+ * `originalPrice` is the price the shopper is NOT paying. Cart items report the price
+ * under several near-synonymous keys (`original_price`, `product_price`, `price`) whose
+ * shapes differ — `Money` objects serialize as `{amount, currency}`, plain columns as
+ * numbers — so it is coerced here rather than at each call site, and is `null` when
+ * nothing usable was sent (render nothing, never "0").
+ */
+export interface CartFreeGiftItem {
+    /** Cart-item id (already a route key / string). */
+    id: string;
+    offerId: number | null;
+    /** Free units granted by the offer, i.e. what the gifts card shows as "free". */
+    quantity: number;
+    /**
+     * The two halves of a MERGED line, kept separate and unfused.
+     *
+     * `AddToCart.php:543-544` grants a gift by incrementing an EXISTING line when the
+     * shopper already owns that product, so one line can be quantity 3 of which
+     * `free_gift_quantity` is 1 and the other 2 were PAID for. `quantity` (the free half)
+     * is what the gifts card shows; `lineQuantity` is the whole line.
+     */
+    freeQuantity: number;
+    lineQuantity: number;
+    name: string;
+    imageUrl: string;
+    imageAlt: string;
+    url: string;
+    originalPrice: number | null;
+}
+/**
+ * The SDK's own name for "this visitor has no cart at all".
+ *
+ * `salla.api.cart.details()` resolves its id through
+ * `getCurrentCartId(false, …, allowCreate = false)`, which returns `null` for a guest with
+ * no stored cart id rather than creating one server-side; `details()` then throws this
+ * (twilight/src/api/cart.js:192-199). It is a STATEMENT ABOUT THE CART, not a failure to
+ * reach the server — no cart means no items — so it is the one rejection that resolves to
+ * a hard 0 instead of "unknown".
+ *
+ * Matched on `name`, never on message text: the wording is not a contract, the name is.
+ */
+export declare const CART_NOT_CREATED = "CartNotCreated";
+export declare function isCartNotCreated(error: any): boolean;
+/**
+ * Every free-gift LINE currently in the cart, in cart order.
+ *
+ * Shares the cache, the in-flight promise and the generation guard with
+ * `getCartItemCount()` — the banner asking for both still issues exactly ONE
+ * `details()` request per cart mutation.
+ */
+export declare function getCartFreeGiftItems(): Promise<CartFreeGiftItem[]>;
+/**
+ * Whether the cached cart picture came from a response that was actually reached and
+ * parsed, rather than from the fallback a rejected lookup publishes.
+ *
+ * For the ONE consumer that has to tell "the cart is empty" apart from "the lookup could
+ * not say, and guessed empty": `salla-conditional-offer` stops before it even asks for the
+ * offer when the count is `0`, which is unrecoverable if that `0` was a guess. Everything
+ * else should just read the values — they are already the best available answer.
+ *
+ * Synchronous and side-effect free: it reports on what is cached NOW, so a caller that
+ * wants a fresh answer must still await one of the lookups above.
+ */
+export declare function hasAuthoritativeCartData(): boolean;
+/**
+ * How many LINES the cart holds — `null` while that is genuinely UNKNOWN (nothing has
+ * loaded yet, or the lookup failed), never `0` for either.
+ *
+ * The distinction is the whole point: `salla-conditional-offer` hides its banner on an
+ * empty cart, and a `0` that really meant "still loading" would make the banner flicker
+ * or disappear on a populated one. Shares the cache, the in-flight promise and the
+ * generation guard with `getCartFreeGiftItems()`, so asking for the count costs no
+ * request of its own.
+ */
+export declare function getCartItemCount(): Promise<number | null>;
+/**
+ * Invalidates the cache and re-fetches — call this from a `cart::updated`
+ * handler, ignoring the event payload entirely.
+ *
+ * Bumps `generation` first so that any request already in flight (started
+ * before this invalidation) can no longer publish into `cache` when it
+ * settles — mirrors `salla.event.on('cart::updated', () => { Salla.api.cart._pendingOffersRequest = null; })`
+ * in `twilight/packages/twilight/src/api/cart.js:81`, which abandons its
+ * own in-flight promise on cart update for the same reason.
+ *
+ * Then chains a fresh fetch BEHIND whatever was already in flight (rather
+ * than firing a second request in parallel): once that prior request
+ * settles — its result now guaranteed to be discarded by the generation
+ * check above — `fetchAndCache()` starts a request under the new
+ * generation, which is free to publish.
+ *
+ * `pendingRefresh` de-dupes concurrent callers of THIS function the same
+ * way `pendingRequest` de-dupes concurrent fetches: N components all
+ * invalidating within the same synchronous `cart::updated` dispatch share
+ * one refresh chain and therefore, ultimately, one fresh HTTP request.
+ *
+ * That sharing window is deliberately NARROW — it closes the instant the
+ * fresh request goes out, NOT when it comes back. Holding it open for the
+ * whole round trip silently coalesced two DIFFERENT cart mutations into one
+ * refresh: the second `cart::updated` got handed the first one's promise, so
+ * it never bumped `generation` and never issued a request, and the response
+ * that eventually published had been asked for BEFORE the second mutation
+ * happened. The cart then sat on pre-mutation gift data — a merged line
+ * showing yesterday's paid quantity beside yesterday's corrected total —
+ * until some later mutation happened to come along. A shopper clicking "+"
+ * twice inside one round trip is all it took.
+ */
+export declare function refreshCartFreeGifts(): Promise<void>;
+/** @internal exported for tests only — resets module-level state between specs. */
+export declare function __resetCartFreeGiftsForTests(): void;

package/dist/types/shared/offer-stages.d.ts

@@ -0,0 +1,288 @@
+/**
+ * Multi-stage promotion progress.
+ *
+ * Pure, component-agnostic helpers for turning a shopper's current cart value
+ * plus a list of stage thresholds into "which stage is Locked / Current /
+ * Completed, and how full is each segment".
+ *
+ * Deliberately NOT shared with `salla-tiered-offer`'s `TierUtils`:
+ *  - `TierUtils.findCurrentTierIndex` is 1-based with `0` overloaded to mean
+ *    "no tier reached", which cannot express "stage 0 is reached".
+ *  - It takes `TieredOfferTier[]`, a shape a conditional-offer `Discount` does
+ *    not share a single field with.
+ *  - It assumes its caller already sorted; the conditional-offer payload is
+ *    emitted UNSORTED by the backend.
+ *
+ * So this module takes plain numbers, is 0-based, uses an explicit
+ * `NO_STAGE_REACHED` sentinel, and sorts defensively on every call.
+ *
+ * ONE deliberate exception to "pure": `getCurrencyDecimals()` reads the store's money
+ * precision off `salla.config` so that `getRemainingToStage()` can round AT THE SOURCE
+ * and every consumer — including the `products_count` path that never touches
+ * `salla.money()` — benefits without each of them remembering to. It is fully guarded and
+ * falls back to `DEFAULT_CURRENCY_DECIMALS`, so a missing SDK degrades rather than throws;
+ * callers that want it hermetic can pass the measure and stub `salla.config`.
+ *
+ * ---------------------------------------------------------------------------
+ * WHO DECIDES A TIER IS UNLOCKED
+ * ---------------------------------------------------------------------------
+ * The ENGINE does, and it now says so: every `details.discounts[]` entry carries
+ * `is_applied`. Threshold arithmetic here is a PROJECTION ("how far to go"), never a
+ * CLAIM about what the engine granted, because the engine's formula
+ *
+ *     ($subtotal - $alreadyAppliedDiscount) - $excludedItemsAmount >= min_spend
+ *
+ * uses two terms that are not in the payload at all. On beta a gift tier at `min_spend`
+ * 300 with `current_value` 300 rendered as unlocked while the engine had refused it (the
+ * gift's own price is in that tier's excluded set), so no arithmetic over shipped keys
+ * could ever have agreed with it.
+ *
+ * BUT `is_applied` IS NOT "THE SHOPPER IS PAST THIS TIER". It answers a narrower
+ * question, and reading it as the broader one is what produced the second beta report.
+ * `CartOfferDiscount::apply()` walks the tiers, keeps the LAST one whose conditions pass
+ * and calls `discountItem()` ONCE after the loop, so a cart offer grants EXACTLY ONE
+ * reward — the best qualifying tier. Every earlier tier is therefore `is_applied: false`
+ * even for a shopper who sailed past it: its reward is SUPERSEDED, not out of reach. A
+ * cart at `current_value` 510 came back as `false / false / true` and the badge row read
+ * LOCKED / LOCKED / CHECKED, which is unreadable as a progress stepper.
+ *
+ * So there are TWO questions and this module answers both, separately:
+ *  - "which tier gave the reward" — the single winner, `appliedIndex`.
+ *  - "is the shopper past this tier"  — cumulative, `met`, which is what the ✓, the
+ *    strikethrough, the lock and the "N of M" count render from.
+ *
+ * The passed tiers carry a ✓ AND a strikethrough while the tier ahead carries a lock.
+ * Struck-through means superseded, so a ✓ means THRESHOLD PASSED, not REWARD GRANTED.
+ *
+ * Hence the split, and it is load-bearing:
+ *  - `met` / `metCount` / `nextUnmetIndex` / `allMet` are the ENGINE-DERIVED verdict.
+ *    Render from these.
+ *  - `appliedIndex` names the one tier that actually paid out. Diagnostics only so far.
+ *  - `lastReachedIndex` / `currentIndex` / `isComplete` / `fills` / `overallPercentage`
+ *    are pure threshold projections. Use them for distance and bar geometry only.
+ *
+ * `is_applied` is TRI-STATE, because twilight and the Store package deploy independently:
+ * absent means "this backend does not report it yet" and falls back to the arithmetic,
+ * while `false` is a real verdict and outranks the arithmetic. See `readAppliedFlag`.
+ *
+ * `salla-tiered-offer` keeps its own copy of the defensive ascending sort and the
+ * completed/total ratio; that duplication is deliberate and not migrated here.
+ */
+/** Explicit sentinel: no stage has been reached yet (or there is no next stage). */
+export declare const NO_STAGE_REACHED = -1;
+export declare enum OfferStageState {
+    LOCKED = "locked",
+    CURRENT = "current",
+    COMPLETED = "completed"
+}
+/** The backend sends `end_value` as a string under `s-source: mobile`, so every numeric field is coerced. */
+export type NumericLike = number | string | null | undefined;
+/**
+ * The engine's verdict for one tier, as a TRI-STATE.
+ *
+ *  - `true`      the engine granted this tier.
+ *  - `false`     the engine did NOT grant it. A REAL answer — never overridden by arithmetic.
+ *  - `undefined` the backend said nothing (older Store/SpecialOffer-Module deploy). Only
+ *                this case falls back to `current_value >= min_spend`.
+ *
+ * Distinguishing the middle case from the last one IS the fix, so anything that is not an
+ * unambiguous yes/no is read as `undefined` — a half-understood value must degrade to the
+ * old behaviour, not invent a verdict.
+ */
+export type AppliedFlag = boolean | undefined;
+export interface OfferStageProgress {
+    /** Defensively ascending-sorted, numeric-coerced copy of the thresholds. */
+    thresholds: number[];
+    /**
+     * THE STEPPER, index-aligned with `thresholds`: has the shopper got past this tier?
+     *
+     * Everything shopper-visible — badge, tooltip row, ✓/lock, strikethrough, "N of M" —
+     * renders from HERE, never from `lastReachedIndex` and never from `applied` directly.
+     *
+     * MONOTONIC BY CONSTRUCTION: `true`s form a prefix, so a lock can never sit below a ✓.
+     * That is the fix. Derived as `index <= appliedIndex` once the engine has granted
+     * anything, all-`false` when the engine granted nothing, and `value >= threshold` only
+     * when this backend reports no verdict at all. See `computeOfferStageProgress`.
+     */
+    met: boolean[];
+    /** The raw tri-state flags, index-aligned with `thresholds`. `undefined` = the backend sent none. */
+    applied: AppliedFlag[];
+    /**
+     * 0-based index of the tier that actually PAID OUT — the highest `is_applied: true` —
+     * or `NO_STAGE_REACHED` when the engine granted nothing or reported nothing.
+     *
+     * A cart offer grants one reward, so this is the winner. `met` is the prefix it closes;
+     * do not render a ✓ from this field alone.
+     */
+    appliedIndex: number;
+    /** True when at least one tier carried a real `is_applied`, i.e. this backend reports the verdict. */
+    hasEngineVerdict: boolean;
+    /** How many tiers are met. `appliedIndex + 1` under a verdict — see `met`. */
+    metCount: number;
+    /** 0-based index of the FIRST tier that is not met, or `NO_STAGE_REACHED` when all are. */
+    nextUnmetIndex: number;
+    /**
+     * True when every tier is met. The congratulations gate — `isComplete` is not.
+     *
+     * Under a verdict this means the LAST tier is the winner, which is exactly when the
+     * shopper has the offer's best reward in the cart and "you have unlocked this offer" is
+     * true. It stays false whenever the engine granted nothing, however affordable the
+     * thresholds look.
+     */
+    allMet: boolean;
+    /**
+     * 0-based index of the highest stage whose THRESHOLD is reached, or `NO_STAGE_REACHED`.
+     * A projection, not a verdict: it drives the bar, not the ✓. See `met`.
+     */
+    lastReachedIndex: number;
+    /**
+     * 0-based index of the first stage whose THRESHOLD is unreached, or `NO_STAGE_REACHED`.
+     * A projection, not a verdict — for the next TARGET use `nextUnmetIndex`.
+     */
+    currentIndex: number;
+    /** True when the final THRESHOLD has been reached. A projection, not a verdict — see `allMet`. */
+    isComplete: boolean;
+    /** `currentValue`, clamped to `[0, finalThreshold]` so a stale/overshooting server value can never render out of range. */
+    value: number;
+    /**
+     * The cart's progress AS EACH TIER COUNTS IT, index-aligned with `thresholds` and clamped
+     * like `value`.
+     *
+     * The engine measures every tier by that tier's own rule — it leaves a tier's gift
+     * product out of the count toward that tier — so the progress toward tier 2 can be lower
+     * than the offer-level figure, and "how far to tier 2" is only right against tier 2's
+     * own number. An entry is the tier's `current_value` when the backend sent a readable
+     * one and `value` otherwise, so on a backend that sends none every entry IS `value`.
+     */
+    values: number[];
+    /** Baseline the first segment fills from (`details.start_value`). */
+    startValue: number;
+    /** 0..100 fill of the segment leading INTO each stage, index-aligned with `thresholds`. */
+    fills: number[];
+    /** 0..100 overall completion across all stages. Exactly 100 when `isComplete`. */
+    overallPercentage: number;
+}
+/**
+ * Read one tier's `is_applied` as a tri-state.
+ *
+ * `true`/`false` booleans are what `CartOffersTransformer` casts and emits. The numeric
+ * and string spellings are accepted too because the `s-source: mobile` pipeline already
+ * stringifies numeric fields in this very payload (`end_value`), and reading a `0` there
+ * as "absent" would silently restore the bug this exists to fix.
+ *
+ * EVERYTHING ELSE — key missing, `undefined`, `null`, `''`, an object — is ABSENT, not
+ * `false`: a value we cannot interpret is not the engine saying no, and must degrade to
+ * the arithmetic fallback rather than lock a tier the shopper has genuinely earned.
+ */
+export declare function readAppliedFlag(value: unknown): AppliedFlag;
+/**
+ * Whether a THRESHOLD is usable.
+ *
+ * Thresholds get the opposite policy to values: an unparseable threshold is DROPPED,
+ * never coerced to 0, because a 0 threshold is satisfied by an empty cart and would
+ * render as an already-COMPLETED stage — reintroducing exactly the synthetic-zeroth-
+ * checkpoint bug this component was rewritten to remove.
+ *
+ * Callers that keep their own parallel array of stage objects MUST filter it with this
+ * predicate so their index alignment with `progress.thresholds` survives the drop.
+ */
+export declare function isUsableThreshold(value: NumericLike): boolean;
+/**
+ * Stable ascending sort of arbitrary items by a numeric threshold accessor.
+ *
+ * Ties are broken by `getIdentity` when supplied and readable on BOTH sides — the tier
+ * `id` (0 = base tier, 1..N = configured options in the order the engine walks them), so
+ * two tiers sharing a `min_spend` order by what they ARE rather than by where they
+ * happened to land in an unsorted payload. Without it (or when either id is unreadable)
+ * ties keep their original relative order, which is the previous behaviour exactly.
+ */
+export declare function sortByThreshold<T>(items: T[], getThreshold: (item: T) => NumericLike, getIdentity?: (item: T) => NumericLike): T[];
+/**
+ * Derive the full stage picture from the server's `current_value`.
+ *
+ * @param currentValue the server-computed cart value — never recomputed client-side.
+ * @param rawThresholds each stage's `min_spend`, in any order.
+ * @param rawStartValue the baseline the first segment fills from (`details.start_value`).
+ * @param rawApplied each stage's `is_applied`, POSITIONALLY ALIGNED WITH `rawThresholds`
+ *        before any sorting or dropping happens here. Omit it and every tier reads as
+ *        absent, i.e. the threshold behaviour, unchanged.
+ * @param rawTierValues each stage's OWN `current_value`, aligned the same way. A tier
+ *        without a readable one is measured by `currentValue`, so omitting it — an older
+ *        backend — changes nothing. See `OfferStageProgress.values`.
+ */
+export declare function computeOfferStageProgress(currentValue: NumericLike, rawThresholds: NumericLike[], rawStartValue?: NumericLike, rawApplied?: unknown[], rawTierValues?: NumericLike[]): OfferStageProgress;
+/**
+ * Locked / Current / Completed for one 0-based stage index — from `met`, so a tier the
+ * engine withheld outright reads LOCKED even with its threshold met, and every tier the
+ * shopper has passed on the way to a granted one reads COMPLETED.
+ *
+ * - Completed: `met[index]` — index at or below the winner.
+ * - Current:   exactly `nextUnmetIndex`, the first tier ABOVE the winner.
+ * - Locked:    every other unmet stage, and any out-of-range index.
+ */
+export declare function getStageState(index: number, progress: OfferStageProgress): OfferStageState;
+/**
+ * How the offer MEASURES its thresholds, which is also what its remainder rounds to.
+ *
+ * Mirrors `OfferType` in `salla-conditional-offer/interfaces.ts` without importing it —
+ * this module stays free of the component's payload types (see the header) — so a caller
+ * maps `details.based_on` onto it at the call site.
+ */
+export declare enum OfferStageMeasure {
+    /** `order_amount` — a money value, rounded to the store's currency precision. */
+    CURRENCY = "currency",
+    /** `products_count` — whole products, so the remainder is a whole number. */
+    COUNT = "count"
+}
+/**
+ * The precision to fall back to when the store publishes none.
+ *
+ * 2 is the platform default (SAR/USD/AED); a store on a 3-decimal currency (KWD, BHD)
+ * that reports its precision gets 3, and only a store that reports NOTHING readable
+ * lands here.
+ */
+export declare const DEFAULT_CURRENCY_DECIMALS = 2;
+/**
+ * The store's money precision — THE ONE IMPURITY IN THIS MODULE (see the header note).
+ *
+ * Asked in the order the platform answers it:
+ *  1. `salla.config.currency()` — the ACTIVE currency's own precision, which is the only
+ *     source that can differ per currency (a store displaying KWD wants 3 while its SAR
+ *     prices want 2).
+ *  2. `salla.config.get('store.currency.decimals')` — the store-level key
+ *     `salla-bought-together.tsx:142` already rounds its basket total by.
+ *  3. `DEFAULT_CURRENCY_DECIMALS`.
+ *
+ * Every step is guarded: this runs inside `render()`, where an SDK that is not on the
+ * page yet (or a `config` that throws) must degrade to the default, never take the banner
+ * down.
+ */
+export declare function getCurrencyDecimals(): number;
+/**
+ * How much more of the cart value is needed to reach the given stage, rounded UP at the
+ * display precision. Never negative.
+ *
+ * `threshold - value` is raw IEEE-754 subtraction over two server-sent floats, so
+ * `300 - 289.599993` is `10.400007000000012`. Nothing downstream cleans that up:
+ * `salla.money()` only swaps digits and appends a symbol (`base/src/helpers/numbers.ts:74-84`).
+ * Rounding here, at the source, covers every consumer, including the `products_count`
+ * path that never reaches `salla.money`.
+ *
+ * Rounding goes UP, never to the nearest unit: the displayed amount must be enough to
+ * unlock the tier. Rounding 10.400007 to 10.40 asks for an amount that leaves the cart
+ * at 299.999993, still below the threshold. Float noise is guarded (see `CEIL_TOLERANCE`)
+ * so an exact 10.40 stays 10.40.
+ *
+ * A count remainder is a WHOLE number, because `salla.lang.choice('blocks.header.products_count', 10.4)`
+ * matches no plural interval and a shopper cannot add 0.4 of a product.
+ *
+ * Only the derived remainder is rounded. `progress.values` and `progress.thresholds` are
+ * server facts and stay as sent: rounding them would move the unlocked/locked boundary,
+ * which is the engine's call.
+ *
+ * A positive remainder never becomes 0: `getGuidanceMessage` drops its line on
+ * `remaining <= 0`, so a genuinely unmet tier must still ask for at least one unit of the
+ * precision (0.01 for a 2-decimal currency, 1 for a count). Exact zero, a met tier,
+ * still returns 0.
+ */
+export declare function getRemainingToStage(index: number, progress: OfferStageProgress, measure?: OfferStageMeasure): number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salla.sa/twilight-components",
-  "version": "2.14.589",
+  "version": "2.14.591",
   "license": "GPL-3.0",
   "author": "Salla Team <support@salla.dev> (https://salla.dev)",
   "bugs": {
@@ -82,9 +82,9 @@
   },
   "dependencies": {
     "@googlemaps/markerclusterer": "2.6.2",
-    "@salla.sa/applepay": "2.14.589",
-    "@salla.sa/twilight": "2.14.589",
-    "@salla.sa/twilight-tailwind-theme": "2.14.589",
+    "@salla.sa/applepay": "2.14.591",
+    "@salla.sa/twilight": "2.14.591",
+    "@salla.sa/twilight-tailwind-theme": "2.14.591",
     "@salla.sa/ui-address-autocomplete-widget": "1.2.1",
     "@salla.sa/ui-google-map-render": "1.2.1",
     "@types/node": "^20.4.8",
@@ -105,5 +105,5 @@
     "vanilla-lazyload": "^17.8.5",
     "vanilla-picker": "^2.12.2"
   },
-  "gitHead": "5487ccd24f7ecfc3936e269f429477aba5365834"
+  "gitHead": "be20f9d830b0e7869d43be890e1579b34d346467"
 }

package/dist/cjs/salla-tooltip.cjs.entry.js

@@ -1,42 +0,0 @@
-/*!
- * Crafted with ❤ by Salla
- */
-'use strict';
-
-var index = require('./index-CfGnMoB7.js');
-
-const sallaTooltipCss = "/*!twlt*/.s-tooltip-container{position:relative;display:inline-block}.s-tooltip-item{position:absolute;transform:translateX(-63%) translateY(-50%);background-color:var(--color-primary);color:var(--color-primary-reverse);bottom:100%;left:50%;text-align:center;border-radius:5px;z-index:1;white-space:nowrap;transition:opacity 0.3s;pointer-events:none;margin:0 0 16px 8px;padding:12px;max-width:150px;width:190px;white-space:normal;opacity:1}.s-tooltip-item::after{content:\"\";position:absolute;bottom:-10px;left:50%;margin-left:-5px;border-width:5px;border-style:solid;border-color:var(--color-primary) transparent transparent transparent}.s-tooltip-item:dir(ltr){transform:translateX(-72%)}.s-tooltip-item--dark{background-color:#555555;color:white;padding:5px 15px;border-radius:8px;font-size:12px;font-weight:normal;max-width:330px;width:max-content}.s-tooltip-item--dark::after{border-color:#555555 transparent transparent transparent}.block{display:block}.shadow{--tw-shadow:0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1);--tw-shadow-colored:0 1px 3px 0 var(--tw-shadow-color), 0 1px 2px -1px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000), var(--tw-ring-shadow, 0 0 #0000), var(--tw-shadow)}";
-
-const SallaTooltip = class {
-    constructor(hostRef) {
-        index.registerInstance(this, hostRef);
-        /**
-         * The theme of the tooltip (default, dark)
-         */
-        this.theme = 'default';
-        this.show = false;
-        this.targetElement = null;
-    }
-    handleMouseOver(event) {
-        if (this.targetElement && this.targetElement.contains(event.target)) {
-            this.show = true;
-        }
-    }
-    handleMouseOut(event) {
-        if (this.targetElement && this.targetElement.contains(event.target)) {
-            this.show = false;
-        }
-    }
-    componentDidLoad() {
-        // Find the target element based on the targetSelector prop
-        this.targetElement = document.getElementById(this.targetId);
-    }
-    render() {
-        const validTheme = ['default', 'dark'].includes(this.theme) ? this.theme : 'default';
-        return (index.h("div", { key: '4027073cb58fa70679f54f6009ed1ca95fd3f3d0', class: "s-tooltip-container" }, index.h("div", { key: 'ea50ad74b456fa3c89cfef2b69b2c9d5630d63bd', class: `s-tooltip-item s-tooltip-item--${validTheme}`, style: { display: this.show ? 'block' : 'none' } }, this.text ? index.h("span", null, this.text) : index.h("slot", null))));
-    }
-    get el() { return index.getElement(this); }
-};
-SallaTooltip.style = sallaTooltipCss;
-
-exports.salla_tooltip = SallaTooltip;

package/dist/esm/salla-tooltip.entry.js

@@ -1,40 +0,0 @@
-/*!
- * Crafted with ❤ by Salla
- */
-import { r as registerInstance, h, a as getElement } from './index-BnDYuqv2.js';
-
-const sallaTooltipCss = "/*!twlt*/.s-tooltip-container{position:relative;display:inline-block}.s-tooltip-item{position:absolute;transform:translateX(-63%) translateY(-50%);background-color:var(--color-primary);color:var(--color-primary-reverse);bottom:100%;left:50%;text-align:center;border-radius:5px;z-index:1;white-space:nowrap;transition:opacity 0.3s;pointer-events:none;margin:0 0 16px 8px;padding:12px;max-width:150px;width:190px;white-space:normal;opacity:1}.s-tooltip-item::after{content:\"\";position:absolute;bottom:-10px;left:50%;margin-left:-5px;border-width:5px;border-style:solid;border-color:var(--color-primary) transparent transparent transparent}.s-tooltip-item:dir(ltr){transform:translateX(-72%)}.s-tooltip-item--dark{background-color:#555555;color:white;padding:5px 15px;border-radius:8px;font-size:12px;font-weight:normal;max-width:330px;width:max-content}.s-tooltip-item--dark::after{border-color:#555555 transparent transparent transparent}.block{display:block}.shadow{--tw-shadow:0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1);--tw-shadow-colored:0 1px 3px 0 var(--tw-shadow-color), 0 1px 2px -1px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000), var(--tw-ring-shadow, 0 0 #0000), var(--tw-shadow)}";
-
-const SallaTooltip = class {
-    constructor(hostRef) {
-        registerInstance(this, hostRef);
-        /**
-         * The theme of the tooltip (default, dark)
-         */
-        this.theme = 'default';
-        this.show = false;
-        this.targetElement = null;
-    }
-    handleMouseOver(event) {
-        if (this.targetElement && this.targetElement.contains(event.target)) {
-            this.show = true;
-        }
-    }
-    handleMouseOut(event) {
-        if (this.targetElement && this.targetElement.contains(event.target)) {
-            this.show = false;
-        }
-    }
-    componentDidLoad() {
-        // Find the target element based on the targetSelector prop
-        this.targetElement = document.getElementById(this.targetId);
-    }
-    render() {
-        const validTheme = ['default', 'dark'].includes(this.theme) ? this.theme : 'default';
-        return (h("div", { key: '4027073cb58fa70679f54f6009ed1ca95fd3f3d0', class: "s-tooltip-container" }, h("div", { key: 'ea50ad74b456fa3c89cfef2b69b2c9d5630d63bd', class: `s-tooltip-item s-tooltip-item--${validTheme}`, style: { display: this.show ? 'block' : 'none' } }, this.text ? h("span", null, this.text) : h("slot", null))));
-    }
-    get el() { return getElement(this); }
-};
-SallaTooltip.style = sallaTooltipCss;
-
-export { SallaTooltip as salla_tooltip };

package/dist/twilight/p-483551e7.entry.js

@@ -1,4 +0,0 @@
-/*!
- * Crafted with ❤ by Salla
- */
-import{r as t,h as o,a as r}from"./p-BnDYuqv2.js";const a=class{constructor(o){t(this,o),this.theme="default",this.show=!1,this.targetElement=null}handleMouseOver(t){this.targetElement&&this.targetElement.contains(t.target)&&(this.show=!0)}handleMouseOut(t){this.targetElement&&this.targetElement.contains(t.target)&&(this.show=!1)}componentDidLoad(){this.targetElement=document.getElementById(this.targetId)}render(){const t=["default","dark"].includes(this.theme)?this.theme:"default";return o("div",{key:"4027073cb58fa70679f54f6009ed1ca95fd3f3d0",class:"s-tooltip-container"},o("div",{key:"ea50ad74b456fa3c89cfef2b69b2c9d5630d63bd",class:`s-tooltip-item s-tooltip-item--${t}`,style:{display:this.show?"block":"none"}},this.text?o("span",null,this.text):o("slot",null)))}get el(){return r(this)}};a.style='/*!twlt*/.s-tooltip-container{position:relative;display:inline-block}.s-tooltip-item{position:absolute;transform:translateX(-63%) translateY(-50%);background-color:var(--color-primary);color:var(--color-primary-reverse);bottom:100%;left:50%;text-align:center;border-radius:5px;z-index:1;white-space:nowrap;transition:opacity 0.3s;pointer-events:none;margin:0 0 16px 8px;padding:12px;max-width:150px;width:190px;white-space:normal;opacity:1}.s-tooltip-item::after{content:"";position:absolute;bottom:-10px;left:50%;margin-left:-5px;border-width:5px;border-style:solid;border-color:var(--color-primary) transparent transparent transparent}.s-tooltip-item:dir(ltr){transform:translateX(-72%)}.s-tooltip-item--dark{background-color:#555555;color:white;padding:5px 15px;border-radius:8px;font-size:12px;font-weight:normal;max-width:330px;width:max-content}.s-tooltip-item--dark::after{border-color:#555555 transparent transparent transparent}.block{display:block}.shadow{--tw-shadow:0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1);--tw-shadow-colored:0 1px 3px 0 var(--tw-shadow-color), 0 1px 2px -1px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000), var(--tw-ring-shadow, 0 0 #0000), var(--tw-shadow)}';export{a as salla_tooltip}