@shadowmkj/plugin-ecommerce 3.85.1

package/dist/ui/VariantOptionsSelector/index.css

@@ -0,0 +1,37 @@
+@layer payload-default {
+  .variantOptionsSelector {
+    margin-top: calc(var(--spacing-field) * 2);
+    margin-bottom: calc(var(--spacing-field) * 2);
+  }
+
+  .variantOptionsSelectorHeading {
+    font-size: calc(var(--base) * 1);
+    font-weight: 500;
+    color: var(--color-text);
+    margin-bottom: calc(var(--base) * 0.5);
+  }
+
+  .variantOptionsSelectorItem {
+    display: flex;
+    flex-direction: column;
+    gap: 0;
+  }
+
+  .variantOptionsSelectorList {
+    display: flex;
+    flex-direction: column;
+    gap: calc(var(--base) * 0.75);
+  }
+
+  .variantOptionsSelectorError {
+    position: relative;
+  }
+
+  .variantOptionsSelectorErrorWrapper {
+    &.showError {
+      border-radius: 2px;
+      outline: 1px solid var(--theme-error-400);
+      outline-offset: 2px;
+    }
+  }
+}

package/dist/ui/VariantOptionsSelector/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ui/VariantOptionsSelector/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAKrD,OAAO,aAAa,CAAA;AAGpB,KAAK,KAAK,GAAG,EAAE,GAAG,sBAAsB,CAAA;AAExC,eAAO,MAAM,sBAAsB,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CA8ElD,CAAA"}

package/dist/ui/VariantOptionsSelector/index.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { FieldLabel } from '@payloadcms/ui';
+import { ErrorBox } from './ErrorBox.js';
+import './index.css';
+import { OptionsSelect } from './OptionsSelect.js';
+export const VariantOptionsSelector = async (props)=>{
+    const { clientField, data, field, path, req, user } = props;
+    const { label } = clientField;
+    // Get collection slugs from field custom prop, with defaults for backwards compatibility
+    const productsSlug = field.custom?.productsSlug || 'products';
+    const variantTypesSlug = field.custom?.variantTypesSlug || 'variantTypes';
+    const product = await req.payload.findByID({
+        id: data.product,
+        collection: productsSlug,
+        depth: 0,
+        draft: true,
+        select: {
+            variants: true,
+            variantTypes: true
+        },
+        user
+    });
+    // @ts-expect-error - TODO: Fix types
+    const existingVariantOptions = product.variants?.docs?.map((variant)=>variant.options) ?? [];
+    const variantTypeIDs = product.variantTypes;
+    const variantTypes = [];
+    // Need to get the variant types separately so that the options are populated
+    // @ts-expect-error - TODO: Fix types
+    if (variantTypeIDs?.length && variantTypeIDs.length > 0) {
+        // @ts-expect-error - TODO: Fix types
+        for (const variantTypeID of variantTypeIDs){
+            const variantType = await req.payload.findByID({
+                id: variantTypeID,
+                collection: variantTypesSlug,
+                depth: 1,
+                joins: {
+                    options: {
+                        sort: 'value'
+                    }
+                }
+            });
+            if (variantType) {
+                variantTypes.push(variantType);
+            }
+        }
+    }
+    return /*#__PURE__*/ _jsxs("div", {
+        className: "variantOptionsSelector",
+        children: [
+            /*#__PURE__*/ _jsx("div", {
+                className: "variantOptionsSelectorHeading",
+                children: /*#__PURE__*/ _jsx(FieldLabel, {
+                    as: "span",
+                    label: label
+                })
+            }),
+            /*#__PURE__*/ _jsx(ErrorBox, {
+                existingOptions: existingVariantOptions,
+                path: path,
+                children: /*#__PURE__*/ _jsx("div", {
+                    className: "variantOptionsSelectorList",
+                    children: variantTypes.map((type)=>{
+                        // @ts-expect-error - TODO: Fix types
+                        const options = type.options.docs.map((option)=>({
+                                label: option.label,
+                                value: option.id
+                            }));
+                        return /*#__PURE__*/ _jsx(OptionsSelect, {
+                            field: clientField,
+                            label: type.label || type.name,
+                            options: options,
+                            path: path
+                        }, type.name);
+                    })
+                })
+            })
+        ]
+    });
+};
+
+//# sourceMappingURL=index.js.map

package/dist/ui/VariantOptionsSelector/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/ui/VariantOptionsSelector/index.tsx"],"sourcesContent":["import type { SelectFieldServerProps } from 'payload'\n\nimport { FieldLabel } from '@payloadcms/ui'\n\nimport { ErrorBox } from './ErrorBox.js'\nimport './index.css'\nimport { OptionsSelect } from './OptionsSelect.js'\n\ntype Props = {} & SelectFieldServerProps\n\nexport const VariantOptionsSelector: React.FC<Props> = async (props) => {\n  const { clientField, data, field, path, req, user } = props\n  const { label } = clientField\n\n  // Get collection slugs from field custom prop, with defaults for backwards compatibility\n  const productsSlug = (field.custom?.productsSlug as string) || 'products'\n  const variantTypesSlug = (field.custom?.variantTypesSlug as string) || 'variantTypes'\n\n  const product = await req.payload.findByID({\n    id: data.product,\n    collection: productsSlug,\n    depth: 0,\n    draft: true,\n    select: {\n      variants: true,\n      variantTypes: true,\n    },\n    user,\n  })\n\n  // @ts-expect-error - TODO: Fix types\n  const existingVariantOptions = product.variants?.docs?.map((variant) => variant.options) ?? []\n\n  const variantTypeIDs = product.variantTypes\n\n  const variantTypes = []\n\n  // Need to get the variant types separately so that the options are populated\n  // @ts-expect-error - TODO: Fix types\n  if (variantTypeIDs?.length && variantTypeIDs.length > 0) {\n    // @ts-expect-error - TODO: Fix types\n    for (const variantTypeID of variantTypeIDs) {\n      const variantType = await req.payload.findByID({\n        id: variantTypeID,\n        collection: variantTypesSlug,\n        depth: 1,\n        joins: {\n          options: {\n            sort: 'value',\n          },\n        },\n      })\n\n      if (variantType) {\n        variantTypes.push(variantType)\n      }\n    }\n  }\n\n  return (\n    <div className=\"variantOptionsSelector\">\n      <div className=\"variantOptionsSelectorHeading\">\n        <FieldLabel as=\"span\" label={label} />\n      </div>\n\n      <ErrorBox existingOptions={existingVariantOptions} path={path}>\n        <div className=\"variantOptionsSelectorList\">\n          {variantTypes.map((type) => {\n            // @ts-expect-error - TODO: Fix types\n            const options = type.options.docs.map((option) => ({\n              label: option.label,\n              value: option.id,\n            }))\n\n            return (\n              <OptionsSelect\n                field={clientField}\n                key={type.name}\n                label={type.label || type.name}\n                options={options}\n                path={path}\n              />\n            )\n          })}\n        </div>\n      </ErrorBox>\n    </div>\n  )\n}\n"],"names":["FieldLabel","ErrorBox","OptionsSelect","VariantOptionsSelector","props","clientField","data","field","path","req","user","label","productsSlug","custom","variantTypesSlug","product","payload","findByID","id","collection","depth","draft","select","variants","variantTypes","existingVariantOptions","docs","map","variant","options","variantTypeIDs","length","variantTypeID","variantType","joins","sort","push","div","className","as","existingOptions","type","option","value","name"],"mappings":";AAEA,SAASA,UAAU,QAAQ,iBAAgB;AAE3C,SAASC,QAAQ,QAAQ,gBAAe;AACxC,OAAO,cAAa;AACpB,SAASC,aAAa,QAAQ,qBAAoB;AAIlD,OAAO,MAAMC,yBAA0C,OAAOC;IAC5D,MAAM,EAAEC,WAAW,EAAEC,IAAI,EAAEC,KAAK,EAAEC,IAAI,EAAEC,GAAG,EAAEC,IAAI,EAAE,GAAGN;IACtD,MAAM,EAAEO,KAAK,EAAE,GAAGN;IAElB,yFAAyF;IACzF,MAAMO,eAAe,AAACL,MAAMM,MAAM,EAAED,gBAA2B;IAC/D,MAAME,mBAAmB,AAACP,MAAMM,MAAM,EAAEC,oBAA+B;IAEvE,MAAMC,UAAU,MAAMN,IAAIO,OAAO,CAACC,QAAQ,CAAC;QACzCC,IAAIZ,KAAKS,OAAO;QAChBI,YAAYP;QACZQ,OAAO;QACPC,OAAO;QACPC,QAAQ;YACNC,UAAU;YACVC,cAAc;QAChB;QACAd;IACF;IAEA,qCAAqC;IACrC,MAAMe,yBAAyBV,QAAQQ,QAAQ,EAAEG,MAAMC,IAAI,CAACC,UAAYA,QAAQC,OAAO,KAAK,EAAE;IAE9F,MAAMC,iBAAiBf,QAAQS,YAAY;IAE3C,MAAMA,eAAe,EAAE;IAEvB,6EAA6E;IAC7E,qCAAqC;IACrC,IAAIM,gBAAgBC,UAAUD,eAAeC,MAAM,GAAG,GAAG;QACvD,qCAAqC;QACrC,KAAK,MAAMC,iBAAiBF,eAAgB;YAC1C,MAAMG,cAAc,MAAMxB,IAAIO,OAAO,CAACC,QAAQ,CAAC;gBAC7CC,IAAIc;gBACJb,YAAYL;gBACZM,OAAO;gBACPc,OAAO;oBACLL,SAAS;wBACPM,MAAM;oBACR;gBACF;YACF;YAEA,IAAIF,aAAa;gBACfT,aAAaY,IAAI,CAACH;YACpB;QACF;IACF;IAEA,qBACE,MAACI;QAAIC,WAAU;;0BACb,KAACD;gBAAIC,WAAU;0BACb,cAAA,KAACtC;oBAAWuC,IAAG;oBAAO5B,OAAOA;;;0BAG/B,KAACV;gBAASuC,iBAAiBf;gBAAwBjB,MAAMA;0BACvD,cAAA,KAAC6B;oBAAIC,WAAU;8BACZd,aAAaG,GAAG,CAAC,CAACc;wBACjB,qCAAqC;wBACrC,MAAMZ,UAAUY,KAAKZ,OAAO,CAACH,IAAI,CAACC,GAAG,CAAC,CAACe,SAAY,CAAA;gCACjD/B,OAAO+B,OAAO/B,KAAK;gCACnBgC,OAAOD,OAAOxB,EAAE;4BAClB,CAAA;wBAEA,qBACE,KAAChB;4BACCK,OAAOF;4BAEPM,OAAO8B,KAAK9B,KAAK,IAAI8B,KAAKG,IAAI;4BAC9Bf,SAASA;4BACTrB,MAAMA;2BAHDiC,KAAKG,IAAI;oBAMpB;;;;;AAKV,EAAC"}

package/dist/ui/utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../src/ui/utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAEjD;;GAEG;AACH,eAAO,MAAM,kBAAkB,gCAG5B;IACD,QAAQ,EAAE,QAAQ,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;CACrB,KAAG,MAaH,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,6BAG9B;IACD,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,QAAQ,CAAA;CACnB,KAAG,MAUH,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,WAAW,qCAIrB;IACD,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,QAAQ,CAAA;IAClB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,KAAG,MAQH,CAAA"}

package/dist/ui/utilities.js

@@ -0,0 +1,40 @@
+/**
+ * Convert display value with decimal point to base value (e.g., $25.00 to 2500)
+ */ export const convertToBaseValue = ({ currency, displayValue })=>{
+    if (!currency) {
+        return parseFloat(displayValue);
+    }
+    // Remove currency symbol and any non-numeric characters except decimal
+    const cleanValue = displayValue.replace(currency.symbol, '').replace(/[^0-9.]/g, '');
+    // Parse the clean value to a float
+    const floatValue = parseFloat(cleanValue || '0');
+    // Convert to the base value (e.g., cents for USD)
+    return Math.round(floatValue * Math.pow(10, currency.decimals));
+};
+/**
+ * Convert base value to display value with decimal point (e.g., 2500 to $25.00)
+ */ export const convertFromBaseValue = ({ baseValue, currency })=>{
+    if (!currency) {
+        return baseValue.toString();
+    }
+    // Convert from base value (e.g., cents) to decimal value (e.g., dollars)
+    const decimalValue = baseValue / Math.pow(10, currency.decimals);
+    // Format with the correct number of decimal places
+    return decimalValue.toFixed(currency.decimals);
+};
+/**
+ * Format a base value as a locale-aware currency string using the Intl API.
+ *
+ * @example formatPrice({ baseValue: 2500, currency: USD }) // "$25.00"
+ * @example formatPrice({ baseValue: 2500, currency: EUR, locale: 'de' }) // "25,00 €"
+ */ export const formatPrice = ({ baseValue, currency, locale = 'en' })=>{
+    return new Intl.NumberFormat(locale, {
+        currency: currency.code,
+        currencyDisplay: currency.symbolDisplay ?? 'symbol',
+        maximumFractionDigits: currency.decimals,
+        minimumFractionDigits: currency.decimals,
+        style: 'currency'
+    }).format(baseValue / Math.pow(10, currency.decimals));
+};
+
+//# sourceMappingURL=utilities.js.map

package/dist/ui/utilities.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/ui/utilities.ts"],"sourcesContent":["import type { Currency } from '../types/index.js'\n\n/**\n * Convert display value with decimal point to base value (e.g., $25.00 to 2500)\n */\nexport const convertToBaseValue = ({\n  currency,\n  displayValue,\n}: {\n  currency: Currency\n  displayValue: string\n}): number => {\n  if (!currency) {\n    return parseFloat(displayValue)\n  }\n\n  // Remove currency symbol and any non-numeric characters except decimal\n  const cleanValue = displayValue.replace(currency.symbol, '').replace(/[^0-9.]/g, '')\n\n  // Parse the clean value to a float\n  const floatValue = parseFloat(cleanValue || '0')\n\n  // Convert to the base value (e.g., cents for USD)\n  return Math.round(floatValue * Math.pow(10, currency.decimals))\n}\n\n/**\n * Convert base value to display value with decimal point (e.g., 2500 to $25.00)\n */\nexport const convertFromBaseValue = ({\n  baseValue,\n  currency,\n}: {\n  baseValue: number\n  currency: Currency\n}): string => {\n  if (!currency) {\n    return baseValue.toString()\n  }\n\n  // Convert from base value (e.g., cents) to decimal value (e.g., dollars)\n  const decimalValue = baseValue / Math.pow(10, currency.decimals)\n\n  // Format with the correct number of decimal places\n  return decimalValue.toFixed(currency.decimals)\n}\n\n/**\n * Format a base value as a locale-aware currency string using the Intl API.\n *\n * @example formatPrice({ baseValue: 2500, currency: USD }) // \"$25.00\"\n * @example formatPrice({ baseValue: 2500, currency: EUR, locale: 'de' }) // \"25,00 €\"\n */\nexport const formatPrice = ({\n  baseValue,\n  currency,\n  locale = 'en',\n}: {\n  baseValue: number\n  currency: Currency\n  locale?: string\n}): string => {\n  return new Intl.NumberFormat(locale, {\n    currency: currency.code,\n    currencyDisplay: currency.symbolDisplay ?? 'symbol',\n    maximumFractionDigits: currency.decimals,\n    minimumFractionDigits: currency.decimals,\n    style: 'currency',\n  }).format(baseValue / Math.pow(10, currency.decimals))\n}\n"],"names":["convertToBaseValue","currency","displayValue","parseFloat","cleanValue","replace","symbol","floatValue","Math","round","pow","decimals","convertFromBaseValue","baseValue","toString","decimalValue","toFixed","formatPrice","locale","Intl","NumberFormat","code","currencyDisplay","symbolDisplay","maximumFractionDigits","minimumFractionDigits","style","format"],"mappings":"AAEA;;CAEC,GACD,OAAO,MAAMA,qBAAqB,CAAC,EACjCC,QAAQ,EACRC,YAAY,EAIb;IACC,IAAI,CAACD,UAAU;QACb,OAAOE,WAAWD;IACpB;IAEA,uEAAuE;IACvE,MAAME,aAAaF,aAAaG,OAAO,CAACJ,SAASK,MAAM,EAAE,IAAID,OAAO,CAAC,YAAY;IAEjF,mCAAmC;IACnC,MAAME,aAAaJ,WAAWC,cAAc;IAE5C,kDAAkD;IAClD,OAAOI,KAAKC,KAAK,CAACF,aAAaC,KAAKE,GAAG,CAAC,IAAIT,SAASU,QAAQ;AAC/D,EAAC;AAED;;CAEC,GACD,OAAO,MAAMC,uBAAuB,CAAC,EACnCC,SAAS,EACTZ,QAAQ,EAIT;IACC,IAAI,CAACA,UAAU;QACb,OAAOY,UAAUC,QAAQ;IAC3B;IAEA,yEAAyE;IACzE,MAAMC,eAAeF,YAAYL,KAAKE,GAAG,CAAC,IAAIT,SAASU,QAAQ;IAE/D,mDAAmD;IACnD,OAAOI,aAAaC,OAAO,CAACf,SAASU,QAAQ;AAC/C,EAAC;AAED;;;;;CAKC,GACD,OAAO,MAAMM,cAAc,CAAC,EAC1BJ,SAAS,EACTZ,QAAQ,EACRiB,SAAS,IAAI,EAKd;IACC,OAAO,IAAIC,KAAKC,YAAY,CAACF,QAAQ;QACnCjB,UAAUA,SAASoB,IAAI;QACvBC,iBAAiBrB,SAASsB,aAAa,IAAI;QAC3CC,uBAAuBvB,SAASU,QAAQ;QACxCc,uBAAuBxB,SAASU,QAAQ;QACxCe,OAAO;IACT,GAAGC,MAAM,CAACd,YAAYL,KAAKE,GAAG,CAAC,IAAIT,SAASU,QAAQ;AACtD,EAAC"}

package/dist/utilities/accessComposition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessComposition.d.ts","sourceRoot":"","sources":["../../src/utilities/accessComposition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAS,MAAM,SAAS,CAAA;AAI5C;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,QAAQ,uBAAwB,MAAM,EAAE,KAAG,MA0BvD,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,SAAS,uBAAwB,MAAM,EAAE,KAAG,MA0BxD,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,WAAW,cACX,CAAC,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,OAAO,kBAC7B,MAAM,aACZ,MAAM,KACf,MAQF,CAAA"}

package/dist/utilities/accessComposition.js

@@ -0,0 +1,103 @@
+import { combineWhereConstraints } from 'payload/shared';
+/**
+ * Combines multiple access functions with OR logic.
+ *
+ * Logic:
+ * - If ANY function returns `true` → return `true` (full access, short-circuit)
+ * - If ALL functions return `false` → return `false` (no access)
+ * - If any functions return `Where` queries → combine them with OR logic
+ *
+ * @example
+ * ```ts
+ * const canCreate = or(
+ *   isAdmin,
+ *   isAuthenticated,
+ *   conditional(allowGuestAccess, isGuest)
+ * )
+ * ```
+ */ export const accessOR = (...accessFunctions)=>{
+    return async (args)=>{
+        const whereQueries = [];
+        for (const access of accessFunctions){
+            const result = await access(args);
+            // Short-circuit on true - full access granted
+            if (result === true) {
+                return true;
+            }
+            // Collect Where queries for combination (must be an object, not null/undefined/false)
+            if (result && typeof result === 'object') {
+                whereQueries.push(result);
+            }
+        }
+        // If we have Where queries, combine them with OR
+        if (whereQueries.length > 0) {
+            return combineWhereConstraints(whereQueries, 'or');
+        }
+        // All checkers returned false - no access
+        return false;
+    };
+};
+/**
+ * Combines multiple access functions with AND logic.
+ *
+ * Logic:
+ * - If ANY function returns `false` → return `false` (no access, short-circuit)
+ * - If ALL functions return `true` → return `true` (full access)
+ * - If any functions return `Where` queries → combine them with AND logic
+ *
+ * @example
+ * ```ts
+ * const canUpdate = and(
+ *   isAuthenticated,
+ *   isDocumentOwner
+ * )
+ * ```
+ */ export const accessAND = (...accessFunctions)=>{
+    return async (args)=>{
+        const whereQueries = [];
+        for (const access of accessFunctions){
+            const result = await access(args);
+            // Short-circuit on false - no access
+            if (result === false) {
+                return false;
+            }
+            // Collect Where queries for combination (must be an object, not null/undefined/true)
+            if (result !== true && result && typeof result === 'object') {
+                whereQueries.push(result);
+            }
+        }
+        // If we have Where queries, combine them with AND
+        if (whereQueries.length > 0) {
+            return combineWhereConstraints(whereQueries, 'and');
+        }
+        // All checkers returned true - full access
+        return true;
+    };
+};
+/**
+ * Conditionally applies an access function based on a boolean condition or function.
+ *
+ * Useful for feature flags and plugin configuration.
+ *
+ * @param condition - Boolean or function to determine which function to use
+ * @param checker - Access function to use if condition is true
+ * @param fallback - Access function to use if condition is false (defaults to denying access)
+ *
+ * @example
+ * ```ts
+ * const canCreate = or(
+ *   isAdmin,
+ *   conditional(allowGuestCarts, isGuest)
+ * )
+ * ```
+ */ export const conditional = (condition, accessFunction, fallback = ()=>false)=>{
+    return async (args)=>{
+        const shouldApply = typeof condition === 'function' ? condition(args) : condition;
+        if (shouldApply) {
+            return accessFunction(args);
+        }
+        return fallback(args);
+    };
+};
+
+//# sourceMappingURL=accessComposition.js.map

package/dist/utilities/accessComposition.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/accessComposition.ts"],"sourcesContent":["import type { Access, Where } from 'payload'\n\nimport { combineWhereConstraints } from 'payload/shared'\n\n/**\n * Combines multiple access functions with OR logic.\n *\n * Logic:\n * - If ANY function returns `true` → return `true` (full access, short-circuit)\n * - If ALL functions return `false` → return `false` (no access)\n * - If any functions return `Where` queries → combine them with OR logic\n *\n * @example\n * ```ts\n * const canCreate = or(\n *   isAdmin,\n *   isAuthenticated,\n *   conditional(allowGuestAccess, isGuest)\n * )\n * ```\n */\nexport const accessOR = (...accessFunctions: Access[]): Access => {\n  return async (args) => {\n    const whereQueries: Where[] = []\n\n    for (const access of accessFunctions) {\n      const result = await access(args)\n\n      // Short-circuit on true - full access granted\n      if (result === true) {\n        return true\n      }\n\n      // Collect Where queries for combination (must be an object, not null/undefined/false)\n      if (result && typeof result === 'object') {\n        whereQueries.push(result)\n      }\n    }\n\n    // If we have Where queries, combine them with OR\n    if (whereQueries.length > 0) {\n      return combineWhereConstraints(whereQueries, 'or')\n    }\n\n    // All checkers returned false - no access\n    return false\n  }\n}\n\n/**\n * Combines multiple access functions with AND logic.\n *\n * Logic:\n * - If ANY function returns `false` → return `false` (no access, short-circuit)\n * - If ALL functions return `true` → return `true` (full access)\n * - If any functions return `Where` queries → combine them with AND logic\n *\n * @example\n * ```ts\n * const canUpdate = and(\n *   isAuthenticated,\n *   isDocumentOwner\n * )\n * ```\n */\nexport const accessAND = (...accessFunctions: Access[]): Access => {\n  return async (args) => {\n    const whereQueries: Where[] = []\n\n    for (const access of accessFunctions) {\n      const result = await access(args)\n\n      // Short-circuit on false - no access\n      if (result === false) {\n        return false\n      }\n\n      // Collect Where queries for combination (must be an object, not null/undefined/true)\n      if (result !== true && result && typeof result === 'object') {\n        whereQueries.push(result)\n      }\n    }\n\n    // If we have Where queries, combine them with AND\n    if (whereQueries.length > 0) {\n      return combineWhereConstraints(whereQueries, 'and')\n    }\n\n    // All checkers returned true - full access\n    return true\n  }\n}\n\n/**\n * Conditionally applies an access function based on a boolean condition or function.\n *\n * Useful for feature flags and plugin configuration.\n *\n * @param condition - Boolean or function to determine which function to use\n * @param checker - Access function to use if condition is true\n * @param fallback - Access function to use if condition is false (defaults to denying access)\n *\n * @example\n * ```ts\n * const canCreate = or(\n *   isAdmin,\n *   conditional(allowGuestCarts, isGuest)\n * )\n * ```\n */\nexport const conditional = (\n  condition: ((args: any) => boolean) | boolean,\n  accessFunction: Access,\n  fallback: Access = () => false,\n): Access => {\n  return async (args) => {\n    const shouldApply = typeof condition === 'function' ? condition(args) : condition\n    if (shouldApply) {\n      return accessFunction(args)\n    }\n    return fallback(args)\n  }\n}\n"],"names":["combineWhereConstraints","accessOR","accessFunctions","args","whereQueries","access","result","push","length","accessAND","conditional","condition","accessFunction","fallback","shouldApply"],"mappings":"AAEA,SAASA,uBAAuB,QAAQ,iBAAgB;AAExD;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,MAAMC,WAAW,CAAC,GAAGC;IAC1B,OAAO,OAAOC;QACZ,MAAMC,eAAwB,EAAE;QAEhC,KAAK,MAAMC,UAAUH,gBAAiB;YACpC,MAAMI,SAAS,MAAMD,OAAOF;YAE5B,8CAA8C;YAC9C,IAAIG,WAAW,MAAM;gBACnB,OAAO;YACT;YAEA,sFAAsF;YACtF,IAAIA,UAAU,OAAOA,WAAW,UAAU;gBACxCF,aAAaG,IAAI,CAACD;YACpB;QACF;QAEA,iDAAiD;QACjD,IAAIF,aAAaI,MAAM,GAAG,GAAG;YAC3B,OAAOR,wBAAwBI,cAAc;QAC/C;QAEA,0CAA0C;QAC1C,OAAO;IACT;AACF,EAAC;AAED;;;;;;;;;;;;;;;CAeC,GACD,OAAO,MAAMK,YAAY,CAAC,GAAGP;IAC3B,OAAO,OAAOC;QACZ,MAAMC,eAAwB,EAAE;QAEhC,KAAK,MAAMC,UAAUH,gBAAiB;YACpC,MAAMI,SAAS,MAAMD,OAAOF;YAE5B,qCAAqC;YACrC,IAAIG,WAAW,OAAO;gBACpB,OAAO;YACT;YAEA,qFAAqF;YACrF,IAAIA,WAAW,QAAQA,UAAU,OAAOA,WAAW,UAAU;gBAC3DF,aAAaG,IAAI,CAACD;YACpB;QACF;QAEA,kDAAkD;QAClD,IAAIF,aAAaI,MAAM,GAAG,GAAG;YAC3B,OAAOR,wBAAwBI,cAAc;QAC/C;QAEA,2CAA2C;QAC3C,OAAO;IACT;AACF,EAAC;AAED;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,MAAMM,cAAc,CACzBC,WACAC,gBACAC,WAAmB,IAAM,KAAK;IAE9B,OAAO,OAAOV;QACZ,MAAMW,cAAc,OAAOH,cAAc,aAAaA,UAAUR,QAAQQ;QACxE,IAAIG,aAAa;YACf,OAAOF,eAAeT;QACxB;QACA,OAAOU,SAASV;IAClB;AACF,EAAC"}