@tamagui/toast 1.12.2 → 1.13.0

package/dist/jsx/ToastImperative.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/ToastImperative.tsx"],
-  "sourcesContent": ["import { isWeb } from '@tamagui/core'\nimport { Scope, createContextScope } from '@tamagui/create-context'\nimport React, { useRef } from 'react'\nimport { Platform } from 'react-native'\n\nimport { createNativeToast } from './createNativeToast'\nimport {\n  CreateNativeToastOptions,\n  NativeToastRef,\n  ToastNativePlatform,\n  ToastNativeValue,\n} from './types'\n\ninterface ToastImperativeOptions extends Omit<CreateNativeToastOptions, \"message\"> {\n  /**\n   * Will show a native toast if is true or is set to the current platform. On iOS, it wraps `SPIndicator` and `SPAlert`. On Android, it wraps `ToastAndroid`. On web, it wraps Notification API. Mobile's native features are handled by `burnt`.\n   */\n  native?: ToastNativeValue\n}\ninterface ShowToastOptions extends CreateNativeToastOptions {\n  /**\n   * Used when need custom data\n   */\n  additionalInfo?: Record<string, any>\n  /**\n   * Overrides the native option on `ToastImperativeProvider`\n   */\n  native?: ToastNativeValue\n}\ntype ScopedProps<P> = P & { __scopeToast?: Scope }\n\ntype ToastData = { title: string; id: string } & CreateNativeToastOptions & {\n    isHandledNatively: boolean\n  }\n\ninterface ImperativeToastContextValue {\n  currentToast: ToastData | null\n  nativeToast: NativeToastRef | null\n  showToast: (title: string, options?: ShowToastOptions) => boolean\n  hideToast: () => void\n  options?: ToastImperativeOptions\n}\n\nconst [createImperativeToastContext, createImperativeToastScope] =\n  createContextScope('ImperativeToast')\n\nconst [ToastImperativeProviderProvider, useToastProviderContext] =\n  createImperativeToastContext<ImperativeToastContextValue>('ToastImperativeProvider')\n\nconst useToast = () => {\n  const context = useToastProviderContext('useToast', undefined)\n\n  return {\n    /**\n     * The currently displaying toast\n     */\n    currentToast: context.currentToast,\n    /**\n     * Call it to show a new toast. If you're using native toasts, you can pass native options using \\`burntOptions\\` or \\`notificationOptions\\` depending on the native platform (mobile/web).\n     */\n    show: context.showToast,\n    /**\n     * Call it to hide the currently displayed toast.\n     * \n     * _NOTE_: does not work on Android native toasts\n     * \n     * _NOTE_: hides the last toast on web notification toasts\n     */\n    hide: context.hideToast,\n  }\n}\n\ninterface ToastImperativeProviderProps {\n  children: React.ReactNode\n  /**\n   * Used to provide defaults to imperative API. Options can be overwritten when calling `show()`.\n   */\n  options: ToastImperativeOptions\n}\nconst ToastImperativeProvider = ({\n  children,\n  options,\n  __scopeToast,\n}: ScopedProps<ToastImperativeProviderProps>) => {\n  const counterRef = useRef(0)\n  const [toast, setToast] =\n    React.useState<ImperativeToastContextValue['currentToast']>(null)\n  const [lastNativeToastRef, setLastNativeToastRef] =\n    React.useState<ImperativeToastContextValue['nativeToast']>(null)\n  const showToast = React.useCallback<ImperativeToastContextValue['showToast']>(\n    (title, showToastOptions) => {\n      const native = showToastOptions?.native ?? options.native\n      const isWebNative = Array.isArray(native)\n        ? native.includes('web')\n        : native === 'web'\n      const isMobileNative = Array.isArray(native)\n        ? native.includes('mobile')\n        : native === 'mobile'\n      const isAndroidNative =\n        isMobileNative ||\n        (Array.isArray(native) ? native.includes('android') : native === 'android')\n      const isIosNative =\n        isMobileNative ||\n        (Array.isArray(native) ? native.includes('ios') : native === 'ios')\n\n      const isHandledNatively =\n        native === true ||\n        (isWeb && isWebNative) ||\n        (!isWeb && isMobileNative) ||\n        (Platform.OS === 'android' && isAndroidNative) ||\n        (Platform.OS === 'ios' && isIosNative)\n\n      if (isHandledNatively) {\n        const nativeToastResult = createNativeToast(title, showToastOptions ?? {})\n        if (typeof nativeToastResult === 'object' && nativeToastResult.nativeToastRef) {\n          setLastNativeToastRef(nativeToastResult.nativeToastRef)\n        }\n      }\n      counterRef.current++\n      setToast({\n        title,\n        id: counterRef.current.toString(),\n        ...showToastOptions,\n        isHandledNatively,\n      })\n      return true\n    },\n    [setToast, options.native]\n  )\n  const hideToast = React.useCallback(() => {\n    lastNativeToastRef?.close()\n    setToast(null)\n  }, [setToast, lastNativeToastRef])\n\n  return (\n    <ToastImperativeProviderProvider\n      scope={__scopeToast}\n      showToast={showToast}\n      hideToast={hideToast}\n      currentToast={toast}\n      nativeToast={lastNativeToastRef}\n      options={options}\n    >\n      {children}\n    </ToastImperativeProviderProvider>\n  )\n}\n\nexport { ToastImperativeProvider, useToast }\nexport type { ToastImperativeProviderProps, ToastNativePlatform, ToastNativeValue }\n"],
-  "mappings": "AAAA,SAAS,aAAa;AACtB,SAAgB,0BAA0B;AAC1C,OAAO,SAAS,cAAc;AAC9B,SAAS,gBAAgB;AAEzB,SAAS,yBAAyB;AAsClC,MAAM,CAAC,8BAA8B,0BAA0B,IAC7D,mBAAmB,iBAAiB;AAEtC,MAAM,CAAC,iCAAiC,uBAAuB,IAC7D,6BAA0D,yBAAyB;AAErF,MAAM,WAAW,MAAM;AACrB,QAAM,UAAU,wBAAwB,YAAY,MAAS;AAE7D,SAAO;AAAA;AAAA;AAAA;AAAA,IAIL,cAAc,QAAQ;AAAA;AAAA;AAAA;AAAA,IAItB,MAAM,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQd,MAAM,QAAQ;AAAA,EAChB;AACF;AASA,MAAM,0BAA0B,CAAC;AAAA,EAC/B;AAAA,EACA;AAAA,EACA;AACF,MAAiD;AAC/C,QAAM,aAAa,OAAO,CAAC;AAC3B,QAAM,CAAC,OAAO,QAAQ,IACpB,MAAM,SAAsD,IAAI;AAClE,QAAM,CAAC,oBAAoB,qBAAqB,IAC9C,MAAM,SAAqD,IAAI;AACjE,QAAM,YAAY,MAAM;AAAA,IACtB,CAAC,OAAO,qBAAqB;AAC3B,YAAM,SAAS,kBAAkB,UAAU,QAAQ;AACnD,YAAM,cAAc,MAAM,QAAQ,MAAM,IACpC,OAAO,SAAS,KAAK,IACrB,WAAW;AACf,YAAM,iBAAiB,MAAM,QAAQ,MAAM,IACvC,OAAO,SAAS,QAAQ,IACxB,WAAW;AACf,YAAM,kBACJ,mBACC,MAAM,QAAQ,MAAM,IAAI,OAAO,SAAS,SAAS,IAAI,WAAW;AACnE,YAAM,cACJ,mBACC,MAAM,QAAQ,MAAM,IAAI,OAAO,SAAS,KAAK,IAAI,WAAW;AAE/D,YAAM,oBACJ,WAAW,QACV,SAAS,eACT,CAAC,SAAS,kBACV,SAAS,OAAO,aAAa,mBAC7B,SAAS,OAAO,SAAS;AAE5B,UAAI,mBAAmB;AACrB,cAAM,oBAAoB,kBAAkB,OAAO,oBAAoB,CAAC,CAAC;AACzE,YAAI,OAAO,sBAAsB,YAAY,kBAAkB,gBAAgB;AAC7E,gCAAsB,kBAAkB,cAAc;AAAA,QACxD;AAAA,MACF;AACA,iBAAW;AACX,eAAS;AAAA,QACP;AAAA,QACA,IAAI,WAAW,QAAQ,SAAS;AAAA,QAChC,GAAG;AAAA,QACH;AAAA,MACF,CAAC;AACD,aAAO;AAAA,IACT;AAAA,IACA,CAAC,UAAU,QAAQ,MAAM;AAAA,EAC3B;AACA,QAAM,YAAY,MAAM,YAAY,MAAM;AACxC,wBAAoB,MAAM;AAC1B,aAAS,IAAI;AAAA,EACf,GAAG,CAAC,UAAU,kBAAkB,CAAC;AAEjC,SACE,CAAC;AAAA,IACC,OAAO;AAAA,IACP,WAAW;AAAA,IACX,WAAW;AAAA,IACX,cAAc;AAAA,IACd,aAAa;AAAA,IACb,SAAS;AAAA,IAER,SACH,EATC;AAWL;",
+  "sourcesContent": ["import { isWeb } from '@tamagui/core'\nimport React, { createContext, useContext, useMemo, useRef } from 'react'\nimport { Platform } from 'react-native'\n\nimport { createNativeToast } from './createNativeToast'\nimport {\n  CreateNativeToastOptions,\n  NativeToastRef,\n  ToastNativePlatform,\n  ToastNativeValue,\n} from './types'\n\ninterface ToastImperativeOptions extends Omit<CreateNativeToastOptions, 'message'> {\n  /**\n   * Will show a native toast if is true or is set to the current platform. On iOS, it wraps `SPIndicator` and `SPAlert`. On Android, it wraps `ToastAndroid`. On web, it wraps Notification API. Mobile's native features are handled by `burnt`.\n   */\n  native?: ToastNativeValue\n}\ninterface ShowOptions extends CreateNativeToastOptions {\n  /**\n   * Used when need custom data\n   */\n  additionalInfo?: Record<string, any>\n  /**\n   * Overrides the native option on `ToastImperativeProvider`\n   */\n  native?: ToastNativeValue\n}\n\ntype ToastData = { title: string; id: string } & CreateNativeToastOptions & {\n    isHandledNatively: boolean\n  }\n\ninterface ToastContextI {\n  nativeToast: NativeToastRef | null\n\n  /**\n   * Call it to show a new toast. If you're using native toasts, you can pass native options using \\`burntOptions\\` or \\`notificationOptions\\` depending on the native platform (mobile/web).\n   */\n  show: (title: string, options?: ShowOptions) => boolean\n\n  /**\n   * Call it to hide the currently displayed toast.\n   *\n   * _NOTE_: does not work on Android native toasts\n   *\n   * _NOTE_: hides the last toast on web notification toasts\n   */\n  hide: () => void\n\n  options?: ToastImperativeOptions\n}\n\nconst ToastContext = createContext<ToastContextI>({} as any)\nconst ToastCurrentContext = createContext<ToastData | null>(null)\n\nexport const useToastController = () => {\n  return useContext(ToastContext)\n}\n\nexport const useToastState = () => {\n  return useContext(ToastCurrentContext)\n}\n\n/** @deprecated use `useToastController` and `useToastState` instead to avoid performance pitfalls */\nexport const useToast = () => {\n  return {\n    ...useToastController(),\n    currentToast: useToastState(),\n  }\n}\n\ninterface ToastImperativeProviderProps {\n  children: React.ReactNode\n  /**\n   * Used to provide defaults to imperative API. Options can be overwritten when calling `show()`.\n   */\n  options: ToastImperativeOptions\n}\n\nexport const ToastImperativeProvider = ({\n  children,\n  options,\n}: ToastImperativeProviderProps) => {\n  const counterRef = useRef(0)\n\n  const [toast, setToast] = React.useState<ToastData | null>(null)\n\n  const [lastNativeToastRef, setLastNativeToastRef] =\n    React.useState<ToastContextI['nativeToast']>(null)\n\n  const show = React.useCallback<ToastContextI['show']>(\n    (title, showOptions) => {\n      const native = showOptions?.native ?? options.native\n      const isWebNative = Array.isArray(native)\n        ? native.includes('web')\n        : native === 'web'\n      const isMobileNative = Array.isArray(native)\n        ? native.includes('mobile')\n        : native === 'mobile'\n      const isAndroidNative =\n        isMobileNative ||\n        (Array.isArray(native) ? native.includes('android') : native === 'android')\n      const isIosNative =\n        isMobileNative ||\n        (Array.isArray(native) ? native.includes('ios') : native === 'ios')\n\n      const isHandledNatively =\n        native === true ||\n        (isWeb && isWebNative) ||\n        (!isWeb && isMobileNative) ||\n        (Platform.OS === 'android' && isAndroidNative) ||\n        (Platform.OS === 'ios' && isIosNative)\n\n      if (isHandledNatively) {\n        const nativeToastResult = createNativeToast(title, showOptions ?? {})\n        if (typeof nativeToastResult === 'object' && nativeToastResult.nativeToastRef) {\n          setLastNativeToastRef(nativeToastResult.nativeToastRef)\n        }\n      }\n      counterRef.current++\n      setToast({\n        title,\n        id: counterRef.current.toString(),\n        ...showOptions,\n        isHandledNatively,\n      })\n      return true\n    },\n    [setToast, options.native]\n  )\n  const hide = React.useCallback(() => {\n    lastNativeToastRef?.close()\n    setToast(null)\n  }, [setToast, lastNativeToastRef])\n\n  const contextValue = useMemo(() => {\n    return {\n      show,\n      hide,\n      nativeToast: lastNativeToastRef,\n      options,\n    }\n  }, [show, hide, lastNativeToastRef, JSON.stringify(options || null)])\n\n  const currentContextValue = useMemo(() => {}, [])\n\n  return (\n    <ToastContext.Provider value={contextValue}>\n      <ToastCurrentContext.Provider value={toast}>\n        {children}\n      </ToastCurrentContext.Provider>\n    </ToastContext.Provider>\n  )\n}\n\nexport type { ToastImperativeProviderProps, ToastNativePlatform, ToastNativeValue }\n"],
+  "mappings": "AAAA,SAAS,aAAa;AACtB,OAAO,SAAS,eAAe,YAAY,SAAS,cAAc;AAClE,SAAS,gBAAgB;AAEzB,SAAS,yBAAyB;AAiDlC,MAAM,eAAe,cAA6B,CAAC,CAAQ;AAC3D,MAAM,sBAAsB,cAAgC,IAAI;AAEzD,MAAM,qBAAqB,MAAM;AACtC,SAAO,WAAW,YAAY;AAChC;AAEO,MAAM,gBAAgB,MAAM;AACjC,SAAO,WAAW,mBAAmB;AACvC;AAGO,MAAM,WAAW,MAAM;AAC5B,SAAO;AAAA,IACL,GAAG,mBAAmB;AAAA,IACtB,cAAc,cAAc;AAAA,EAC9B;AACF;AAUO,MAAM,0BAA0B,CAAC;AAAA,EACtC;AAAA,EACA;AACF,MAAoC;AAClC,QAAM,aAAa,OAAO,CAAC;AAE3B,QAAM,CAAC,OAAO,QAAQ,IAAI,MAAM,SAA2B,IAAI;AAE/D,QAAM,CAAC,oBAAoB,qBAAqB,IAC9C,MAAM,SAAuC,IAAI;AAEnD,QAAM,OAAO,MAAM;AAAA,IACjB,CAAC,OAAO,gBAAgB;AACtB,YAAM,SAAS,aAAa,UAAU,QAAQ;AAC9C,YAAM,cAAc,MAAM,QAAQ,MAAM,IACpC,OAAO,SAAS,KAAK,IACrB,WAAW;AACf,YAAM,iBAAiB,MAAM,QAAQ,MAAM,IACvC,OAAO,SAAS,QAAQ,IACxB,WAAW;AACf,YAAM,kBACJ,mBACC,MAAM,QAAQ,MAAM,IAAI,OAAO,SAAS,SAAS,IAAI,WAAW;AACnE,YAAM,cACJ,mBACC,MAAM,QAAQ,MAAM,IAAI,OAAO,SAAS,KAAK,IAAI,WAAW;AAE/D,YAAM,oBACJ,WAAW,QACV,SAAS,eACT,CAAC,SAAS,kBACV,SAAS,OAAO,aAAa,mBAC7B,SAAS,OAAO,SAAS;AAE5B,UAAI,mBAAmB;AACrB,cAAM,oBAAoB,kBAAkB,OAAO,eAAe,CAAC,CAAC;AACpE,YAAI,OAAO,sBAAsB,YAAY,kBAAkB,gBAAgB;AAC7E,gCAAsB,kBAAkB,cAAc;AAAA,QACxD;AAAA,MACF;AACA,iBAAW;AACX,eAAS;AAAA,QACP;AAAA,QACA,IAAI,WAAW,QAAQ,SAAS;AAAA,QAChC,GAAG;AAAA,QACH;AAAA,MACF,CAAC;AACD,aAAO;AAAA,IACT;AAAA,IACA,CAAC,UAAU,QAAQ,MAAM;AAAA,EAC3B;AACA,QAAM,OAAO,MAAM,YAAY,MAAM;AACnC,wBAAoB,MAAM;AAC1B,aAAS,IAAI;AAAA,EACf,GAAG,CAAC,UAAU,kBAAkB,CAAC;AAEjC,QAAM,eAAe,QAAQ,MAAM;AACjC,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,aAAa;AAAA,MACb;AAAA,IACF;AAAA,EACF,GAAG,CAAC,MAAM,MAAM,oBAAoB,KAAK,UAAU,WAAW,IAAI,CAAC,CAAC;AAEpE,QAAM,sBAAsB,QAAQ,MAAM;AAAA,EAAC,GAAG,CAAC,CAAC;AAEhD,SACE,CAAC,aAAa,SAAS,OAAO,cAC5B,CAAC,oBAAoB,SAAS,OAAO,QAClC,SACH,EAFC,oBAAoB,SAGvB,EAJC,aAAa;AAMlB;",
   "names": []
 }

package/dist/jsx/createNativeToast.native.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/createNativeToast.native.tsx"],
-  "sourcesContent": ["import { BurntToastOptions, CreateNativeToastsFn, HideNativeToastsFn } from './types'\n\nexport const createNativeToast: CreateNativeToastsFn = (\n  title,\n  { message, duration, burntOptions }\n) => {\n  // import inline to allow lazy usage of native dependecy:\n  const Burnt: { toast: (options: BurntToastOptions) => any } = require('burnt')\n\n  Burnt.toast({\n    title,\n    message,\n    duration: duration ? duration * 1000 : undefined,\n    ...burntOptions,\n  })\n  return true\n}\n\nexport const hideNativeToast: HideNativeToastsFn = () => {\n  const Burnt: { dismissAllAlerts: () => any } = require('burnt')\n  Burnt.dismissAllAlerts()\n}\n"],
-  "mappings": "AAEO,MAAM,oBAA0C,CACrD,OACA,EAAE,SAAS,UAAU,aAAa,MAC/B;AAEH,QAAM,QAAwD,QAAQ,OAAO;AAE7E,QAAM,MAAM;AAAA,IACV;AAAA,IACA;AAAA,IACA,UAAU,WAAW,WAAW,MAAO;AAAA,IACvC,GAAG;AAAA,EACL,CAAC;AACD,SAAO;AACT;AAEO,MAAM,kBAAsC,MAAM;AACvD,QAAM,QAAyC,QAAQ,OAAO;AAC9D,QAAM,iBAAiB;AACzB;",
+  "sourcesContent": ["import { BurntToastOptions, CreateNativeToastsFn, HideNativeToastsFn } from './types'\n\nexport const createNativeToast: CreateNativeToastsFn = (\n  title,\n  { message, duration, burntOptions }\n) => {\n  // import inline to allow lazy usage of native dependecy:\n  const Burnt = require('burnt') as typeof import('burnt')\n\n  Burnt.toast({\n    title,\n    message,\n    duration: duration ? duration * 1000 : undefined,\n    ...burntOptions,\n  })\n  return true\n}\n\nexport const hideNativeToast: HideNativeToastsFn = () => {\n  const Burnt = require('burnt') as typeof import('burnt')\n  Burnt.dismissAllAlerts()\n}\n"],
+  "mappings": "AAEO,MAAM,oBAA0C,CACrD,OACA,EAAE,SAAS,UAAU,aAAa,MAC/B;AAEH,QAAM,QAAQ,QAAQ,OAAO;AAE7B,QAAM,MAAM;AAAA,IACV;AAAA,IACA;AAAA,IACA,UAAU,WAAW,WAAW,MAAO;AAAA,IACvC,GAAG;AAAA,EACL,CAAC;AACD,SAAO;AACT;AAEO,MAAM,kBAAsC,MAAM;AACvD,QAAM,QAAQ,QAAQ,OAAO;AAC7B,QAAM,iBAAiB;AACzB;",
   "names": []
 }

package/dist/jsx/createNativeToast.native.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/createNativeToast.native.tsx"],
-  "sourcesContent": ["import { BurntToastOptions, CreateNativeToastsFn, HideNativeToastsFn } from './types'\n\nexport const createNativeToast: CreateNativeToastsFn = (\n  title,\n  { message, duration, burntOptions }\n) => {\n  // import inline to allow lazy usage of native dependecy:\n  const Burnt: { toast: (options: BurntToastOptions) => any } = require('burnt')\n\n  Burnt.toast({\n    title,\n    message,\n    duration: duration ? duration * 1000 : undefined,\n    ...burntOptions,\n  })\n  return true\n}\n\nexport const hideNativeToast: HideNativeToastsFn = () => {\n  const Burnt: { dismissAllAlerts: () => any } = require('burnt')\n  Burnt.dismissAllAlerts()\n}\n"],
-  "mappings": "AAEO,MAAM,oBAA0C,CACrD,OACA,EAAE,SAAS,UAAU,aAAa,MAC/B;AAEH,QAAM,QAAwD,QAAQ,OAAO;AAE7E,QAAM,MAAM;AAAA,IACV;AAAA,IACA;AAAA,IACA,UAAU,WAAW,WAAW,MAAO;AAAA,IACvC,GAAG;AAAA,EACL,CAAC;AACD,SAAO;AACT;AAEO,MAAM,kBAAsC,MAAM;AACvD,QAAM,QAAyC,QAAQ,OAAO;AAC9D,QAAM,iBAAiB;AACzB;",
+  "sourcesContent": ["import { BurntToastOptions, CreateNativeToastsFn, HideNativeToastsFn } from './types'\n\nexport const createNativeToast: CreateNativeToastsFn = (\n  title,\n  { message, duration, burntOptions }\n) => {\n  // import inline to allow lazy usage of native dependecy:\n  const Burnt = require('burnt') as typeof import('burnt')\n\n  Burnt.toast({\n    title,\n    message,\n    duration: duration ? duration * 1000 : undefined,\n    ...burntOptions,\n  })\n  return true\n}\n\nexport const hideNativeToast: HideNativeToastsFn = () => {\n  const Burnt = require('burnt') as typeof import('burnt')\n  Burnt.dismissAllAlerts()\n}\n"],
+  "mappings": "AAEO,MAAM,oBAA0C,CACrD,OACA,EAAE,SAAS,UAAU,aAAa,MAC/B;AAEH,QAAM,QAAQ,QAAQ,OAAO;AAE7B,QAAM,MAAM;AAAA,IACV;AAAA,IACA;AAAA,IACA,UAAU,WAAW,WAAW,MAAO;AAAA,IACvC,GAAG;AAAA,EACL,CAAC;AACD,SAAO;AACT;AAEO,MAAM,kBAAsC,MAAM;AACvD,QAAM,QAAQ,QAAQ,OAAO;AAC7B,QAAM,iBAAiB;AACzB;",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamagui/toast",
-  "version": "1.12.2",
+  "version": "1.13.0",
   "source": "src/index.ts",
   "types": "./types/index.d.ts",
   "main": "dist/cjs",
@@ -31,24 +31,26 @@
     }
   },
   "dependencies": {
-    "@tamagui/animate-presence": "1.12.2",
-    "@tamagui/compose-refs": "1.12.2",
-    "@tamagui/core": "1.12.2",
-    "@tamagui/create-context": "1.12.2",
-    "@tamagui/dismissable": "1.12.2",
-    "@tamagui/polyfill-dev": "1.12.2",
-    "@tamagui/portal": "1.12.2",
-    "@tamagui/stacks": "1.12.2",
-    "@tamagui/text": "1.12.2",
-    "@tamagui/use-controllable-state": "1.12.2",
-    "@tamagui/visually-hidden": "1.12.2"
+    "@tamagui/animate-presence": "1.13.0",
+    "@tamagui/compose-refs": "1.13.0",
+    "@tamagui/core": "1.13.0",
+    "@tamagui/create-context": "1.13.0",
+    "@tamagui/dismissable": "1.13.0",
+    "@tamagui/polyfill-dev": "1.13.0",
+    "@tamagui/portal": "1.13.0",
+    "@tamagui/stacks": "1.13.0",
+    "@tamagui/text": "1.13.0",
+    "@tamagui/use-controllable-state": "1.13.0",
+    "@tamagui/visually-hidden": "1.13.0"
   },
   "peerDependencies": {
+    "burnt": "^0.10.0",
     "react": "*",
     "react-native": "*"
   },
   "devDependencies": {
-    "@tamagui/build": "1.12.2",
+    "@tamagui/build": "1.13.0",
+    "burnt": "^0.10.0",
     "react": "^18.2.0",
     "react-native": "^0.71.4"
   },

package/src/Toast.tsx

@@ -38,10 +38,10 @@ const TITLE_NAME = 'ToastTitle'
 
 const ToastTitleFrame = styled(SizableText, {
   name: TITLE_NAME,
-  color: '$color',
   variants: {
     unstyled: {
       false: {
+        color: '$color',
         size: '$4',
       },
     },
@@ -50,6 +50,7 @@ const ToastTitleFrame = styled(SizableText, {
     unstyled: false,
   },
 })
+
 type PrimitiveDivProps = GetProps<typeof ToastTitleFrame>
 type ToastTitleProps = PrimitiveDivProps & {}
 
@@ -70,18 +71,21 @@ const DESCRIPTION_NAME = 'ToastDescription'
 
 const ToastDescriptionFrame = styled(SizableText, {
   name: DESCRIPTION_NAME,
-  color: '$color11',
+
   variants: {
     unstyled: {
       false: {
+        color: '$color11',
         size: '$1',
       },
     },
   },
+
   defaultVariants: {
     unstyled: false,
   },
 })
+
 type ToastDescriptionFrameProps = GetProps<typeof ToastDescriptionFrame>
 type ToastDescriptionProps = ToastDescriptionFrameProps & {}
 

package/src/ToastImperative.tsx

@@ -1,6 +1,5 @@
 import { isWeb } from '@tamagui/core'
-import { Scope, createContextScope } from '@tamagui/create-context'
-import React, { useRef } from 'react'
+import React, { createContext, useContext, useMemo, useRef } from 'react'
 import { Platform } from 'react-native'
 
 import { createNativeToast } from './createNativeToast'
@@ -11,13 +10,13 @@ import {
   ToastNativeValue,
 } from './types'
 
-interface ToastImperativeOptions extends Omit<CreateNativeToastOptions, "message"> {
+interface ToastImperativeOptions extends Omit<CreateNativeToastOptions, 'message'> {
   /**
    * Will show a native toast if is true or is set to the current platform. On iOS, it wraps `SPIndicator` and `SPAlert`. On Android, it wraps `ToastAndroid`. On web, it wraps Notification API. Mobile's native features are handled by `burnt`.
    */
   native?: ToastNativeValue
 }
-interface ShowToastOptions extends CreateNativeToastOptions {
+interface ShowOptions extends CreateNativeToastOptions {
   /**
    * Used when need custom data
    */
@@ -27,46 +26,47 @@ interface ShowToastOptions extends CreateNativeToastOptions {
    */
   native?: ToastNativeValue
 }
-type ScopedProps<P> = P & { __scopeToast?: Scope }
 
 type ToastData = { title: string; id: string } & CreateNativeToastOptions & {
     isHandledNatively: boolean
   }
 
-interface ImperativeToastContextValue {
-  currentToast: ToastData | null
+interface ToastContextI {
   nativeToast: NativeToastRef | null
-  showToast: (title: string, options?: ShowToastOptions) => boolean
-  hideToast: () => void
+
+  /**
+   * Call it to show a new toast. If you're using native toasts, you can pass native options using \`burntOptions\` or \`notificationOptions\` depending on the native platform (mobile/web).
+   */
+  show: (title: string, options?: ShowOptions) => boolean
+
+  /**
+   * Call it to hide the currently displayed toast.
+   *
+   * _NOTE_: does not work on Android native toasts
+   *
+   * _NOTE_: hides the last toast on web notification toasts
+   */
+  hide: () => void
+
   options?: ToastImperativeOptions
 }
 
-const [createImperativeToastContext, createImperativeToastScope] =
-  createContextScope('ImperativeToast')
+const ToastContext = createContext<ToastContextI>({} as any)
+const ToastCurrentContext = createContext<ToastData | null>(null)
 
-const [ToastImperativeProviderProvider, useToastProviderContext] =
-  createImperativeToastContext<ImperativeToastContextValue>('ToastImperativeProvider')
+export const useToastController = () => {
+  return useContext(ToastContext)
+}
 
-const useToast = () => {
-  const context = useToastProviderContext('useToast', undefined)
+export const useToastState = () => {
+  return useContext(ToastCurrentContext)
+}
 
+/** @deprecated use `useToastController` and `useToastState` instead to avoid performance pitfalls */
+export const useToast = () => {
   return {
-    /**
-     * The currently displaying toast
-     */
-    currentToast: context.currentToast,
-    /**
-     * Call it to show a new toast. If you're using native toasts, you can pass native options using \`burntOptions\` or \`notificationOptions\` depending on the native platform (mobile/web).
-     */
-    show: context.showToast,
-    /**
-     * Call it to hide the currently displayed toast.
-     * 
-     * _NOTE_: does not work on Android native toasts
-     * 
-     * _NOTE_: hides the last toast on web notification toasts
-     */
-    hide: context.hideToast,
+    ...useToastController(),
+    currentToast: useToastState(),
   }
 }
 
@@ -77,19 +77,21 @@ interface ToastImperativeProviderProps {
    */
   options: ToastImperativeOptions
 }
-const ToastImperativeProvider = ({
+
+export const ToastImperativeProvider = ({
   children,
   options,
-  __scopeToast,
-}: ScopedProps<ToastImperativeProviderProps>) => {
+}: ToastImperativeProviderProps) => {
   const counterRef = useRef(0)
-  const [toast, setToast] =
-    React.useState<ImperativeToastContextValue['currentToast']>(null)
+
+  const [toast, setToast] = React.useState<ToastData | null>(null)
+
   const [lastNativeToastRef, setLastNativeToastRef] =
-    React.useState<ImperativeToastContextValue['nativeToast']>(null)
-  const showToast = React.useCallback<ImperativeToastContextValue['showToast']>(
-    (title, showToastOptions) => {
-      const native = showToastOptions?.native ?? options.native
+    React.useState<ToastContextI['nativeToast']>(null)
+
+  const show = React.useCallback<ToastContextI['show']>(
+    (title, showOptions) => {
+      const native = showOptions?.native ?? options.native
       const isWebNative = Array.isArray(native)
         ? native.includes('web')
         : native === 'web'
@@ -111,7 +113,7 @@ const ToastImperativeProvider = ({
         (Platform.OS === 'ios' && isIosNative)
 
       if (isHandledNatively) {
-        const nativeToastResult = createNativeToast(title, showToastOptions ?? {})
+        const nativeToastResult = createNativeToast(title, showOptions ?? {})
         if (typeof nativeToastResult === 'object' && nativeToastResult.nativeToastRef) {
           setLastNativeToastRef(nativeToastResult.nativeToastRef)
         }
@@ -120,31 +122,36 @@ const ToastImperativeProvider = ({
       setToast({
         title,
         id: counterRef.current.toString(),
-        ...showToastOptions,
+        ...showOptions,
         isHandledNatively,
       })
       return true
     },
     [setToast, options.native]
   )
-  const hideToast = React.useCallback(() => {
+  const hide = React.useCallback(() => {
     lastNativeToastRef?.close()
     setToast(null)
   }, [setToast, lastNativeToastRef])
 
+  const contextValue = useMemo(() => {
+    return {
+      show,
+      hide,
+      nativeToast: lastNativeToastRef,
+      options,
+    }
+  }, [show, hide, lastNativeToastRef, JSON.stringify(options || null)])
+
+  const currentContextValue = useMemo(() => {}, [])
+
   return (
-    <ToastImperativeProviderProvider
-      scope={__scopeToast}
-      showToast={showToast}
-      hideToast={hideToast}
-      currentToast={toast}
-      nativeToast={lastNativeToastRef}
-      options={options}
-    >
-      {children}
-    </ToastImperativeProviderProvider>
+    <ToastContext.Provider value={contextValue}>
+      <ToastCurrentContext.Provider value={toast}>
+        {children}
+      </ToastCurrentContext.Provider>
+    </ToastContext.Provider>
   )
 }
 
-export { ToastImperativeProvider, useToast }
 export type { ToastImperativeProviderProps, ToastNativePlatform, ToastNativeValue }

package/src/createNativeToast.native.tsx

@@ -5,7 +5,7 @@ export const createNativeToast: CreateNativeToastsFn = (
   { message, duration, burntOptions }
 ) => {
   // import inline to allow lazy usage of native dependecy:
-  const Burnt: { toast: (options: BurntToastOptions) => any } = require('burnt')
+  const Burnt = require('burnt') as typeof import('burnt')
 
   Burnt.toast({
     title,
@@ -17,6 +17,6 @@ export const createNativeToast: CreateNativeToastsFn = (
 }
 
 export const hideNativeToast: HideNativeToastsFn = () => {
-  const Burnt: { dismissAllAlerts: () => any } = require('burnt')
+  const Burnt = require('burnt') as typeof import('burnt')
   Burnt.dismissAllAlerts()
 }

package/types/Toast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Toast.d.ts","sourceRoot":"","sources":["../src/Toast.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,cAAc,EAOf,MAAM,eAAe,CAAA;AAItB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AACtF,OAAO,EAGL,UAAU,EAEX,MAAM,aAAa,CAAA;AACpB,OAAO,EAEL,aAAa,EACb,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAQnE,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;GAanB,CAAA;AACF,KAAK,iBAAiB,GAAG,QAAQ,CAAC,OAAO,eAAe,CAAC,CAAA;AACzD,KAAK,eAAe,GAAG,iBAAiB,GAAG,EAAE,CAAA;AAiB7C,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;GAazB,CAAA;AACF,KAAK,0BAA0B,GAAG,QAAQ,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACxE,KAAK,qBAAqB,GAAG,0BAA0B,GAAG,EAAE,CAAA;AAiB5D,KAAK,gBAAgB,GAAG,eAAe,GAAG;IACxC;;;;;OAKG;IACH,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AA+BD,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGnB,CAAA;AACF,KAAK,oBAAoB,GAAG,QAAQ,CAAC,OAAO,eAAe,CAAC,CAAA;AAC5D,KAAK,eAAe,GAAG,oBAAoB,GAAG,EAAE,CAAA;AA6DhD,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAxGT;;;;;WAKG;iBACM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QANf;;;;;WAKG;iBACM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0GhB,CAAA;AAID,OAAO,EACL,KAAK,EACL,aAAa,EACb,aAAa,EAEb,gBAAgB,EAEhB,QAAQ,GACT,CAAA;AACD,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,qBAAqB,EACrB,UAAU,EACV,kBAAkB,EAClB,eAAe,EACf,kBAAkB,EAElB,gBAAgB,EAChB,mBAAmB,GACpB,CAAA"}
+{"version":3,"file":"Toast.d.ts","sourceRoot":"","sources":["../src/Toast.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,cAAc,EAOf,MAAM,eAAe,CAAA;AAItB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AACtF,OAAO,EAGL,UAAU,EAEX,MAAM,aAAa,CAAA;AACpB,OAAO,EAEL,aAAa,EACb,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAQnE,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;GAanB,CAAA;AAEF,KAAK,iBAAiB,GAAG,QAAQ,CAAC,OAAO,eAAe,CAAC,CAAA;AACzD,KAAK,eAAe,GAAG,iBAAiB,GAAG,EAAE,CAAA;AAiB7C,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;GAezB,CAAA;AAEF,KAAK,0BAA0B,GAAG,QAAQ,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACxE,KAAK,qBAAqB,GAAG,0BAA0B,GAAG,EAAE,CAAA;AAiB5D,KAAK,gBAAgB,GAAG,eAAe,GAAG;IACxC;;;;;OAKG;IACH,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AA+BD,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGnB,CAAA;AACF,KAAK,oBAAoB,GAAG,QAAQ,CAAC,OAAO,eAAe,CAAC,CAAA;AAC5D,KAAK,eAAe,GAAG,oBAAoB,GAAG,EAAE,CAAA;AA6DhD,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAxGT;;;;;WAKG;iBACM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QANf;;;;;WAKG;iBACM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0GhB,CAAA;AAID,OAAO,EACL,KAAK,EACL,aAAa,EACb,aAAa,EAEb,gBAAgB,EAEhB,QAAQ,GACT,CAAA;AACD,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,qBAAqB,EACrB,UAAU,EACV,kBAAkB,EAClB,eAAe,EACf,kBAAkB,EAElB,gBAAgB,EAChB,mBAAmB,GACpB,CAAA"}

package/types/ToastImperative.d.ts

@@ -1,13 +1,12 @@
-import { Scope } from '@tamagui/create-context';
 import React from 'react';
-import { CreateNativeToastOptions, ToastNativePlatform, ToastNativeValue } from './types';
-interface ToastImperativeOptions extends Omit<CreateNativeToastOptions, "message"> {
+import { CreateNativeToastOptions, NativeToastRef, ToastNativePlatform, ToastNativeValue } from './types';
+interface ToastImperativeOptions extends Omit<CreateNativeToastOptions, 'message'> {
     /**
      * Will show a native toast if is true or is set to the current platform. On iOS, it wraps `SPIndicator` and `SPAlert`. On Android, it wraps `ToastAndroid`. On web, it wraps Notification API. Mobile's native features are handled by `burnt`.
      */
     native?: ToastNativeValue;
 }
-interface ShowToastOptions extends CreateNativeToastOptions {
+interface ShowOptions extends CreateNativeToastOptions {
     /**
      * Used when need custom data
      */
@@ -17,24 +16,38 @@ interface ShowToastOptions extends CreateNativeToastOptions {
      */
     native?: ToastNativeValue;
 }
-type ScopedProps<P> = P & {
-    __scopeToast?: Scope;
-};
 type ToastData = {
     title: string;
     id: string;
 } & CreateNativeToastOptions & {
     isHandledNatively: boolean;
 };
-declare const useToast: () => {
+interface ToastContextI {
+    nativeToast: NativeToastRef | null;
     /**
-     * The currently displaying toast
+     * Call it to show a new toast. If you're using native toasts, you can pass native options using \`burntOptions\` or \`notificationOptions\` depending on the native platform (mobile/web).
      */
+    show: (title: string, options?: ShowOptions) => boolean;
+    /**
+     * Call it to hide the currently displayed toast.
+     *
+     * _NOTE_: does not work on Android native toasts
+     *
+     * _NOTE_: hides the last toast on web notification toasts
+     */
+    hide: () => void;
+    options?: ToastImperativeOptions;
+}
+export declare const useToastController: () => ToastContextI;
+export declare const useToastState: () => ToastData | null;
+/** @deprecated use `useToastController` and `useToastState` instead to avoid performance pitfalls */
+export declare const useToast: () => {
     currentToast: ToastData | null;
+    nativeToast: NativeToastRef | null;
     /**
      * Call it to show a new toast. If you're using native toasts, you can pass native options using \`burntOptions\` or \`notificationOptions\` depending on the native platform (mobile/web).
      */
-    show: (title: string, options?: ShowToastOptions) => boolean;
+    show: (title: string, options?: ShowOptions) => boolean;
     /**
      * Call it to hide the currently displayed toast.
      *
@@ -43,6 +56,7 @@ declare const useToast: () => {
      * _NOTE_: hides the last toast on web notification toasts
      */
     hide: () => void;
+    options?: ToastImperativeOptions | undefined;
 };
 interface ToastImperativeProviderProps {
     children: React.ReactNode;
@@ -51,7 +65,6 @@ interface ToastImperativeProviderProps {
      */
     options: ToastImperativeOptions;
 }
-declare const ToastImperativeProvider: ({ children, options, __scopeToast, }: ScopedProps<ToastImperativeProviderProps>) => JSX.Element;
-export { ToastImperativeProvider, useToast };
+export declare const ToastImperativeProvider: ({ children, options, }: ToastImperativeProviderProps) => JSX.Element;
 export type { ToastImperativeProviderProps, ToastNativePlatform, ToastNativeValue };
 //# sourceMappingURL=ToastImperative.d.ts.map

package/types/ToastImperative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ToastImperative.d.ts","sourceRoot":"","sources":["../src/ToastImperative.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAsB,MAAM,yBAAyB,CAAA;AACnE,OAAO,KAAiB,MAAM,OAAO,CAAA;AAIrC,OAAO,EACL,wBAAwB,EAExB,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,SAAS,CAAA;AAEhB,UAAU,sBAAuB,SAAQ,IAAI,CAAC,wBAAwB,EAAE,SAAS,CAAC;IAChF;;OAEG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAA;CAC1B;AACD,UAAU,gBAAiB,SAAQ,wBAAwB;IACzD;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACpC;;OAEG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAA;CAC1B;AACD,KAAK,WAAW,CAAC,CAAC,IAAI,CAAC,GAAG;IAAE,YAAY,CAAC,EAAE,KAAK,CAAA;CAAE,CAAA;AAElD,KAAK,SAAS,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,wBAAwB,GAAG;IACxE,iBAAiB,EAAE,OAAO,CAAA;CAC3B,CAAA;AAgBH,QAAA,MAAM,QAAQ;IAIV;;OAEG;;IAEH;;OAEG;kBArBc,MAAM,YAAY,gBAAgB,KAAK,OAAO;IAuB/D;;;;;;OAMG;gBA5BY,IAAI;CA+BtB,CAAA;AAED,UAAU,4BAA4B;IACpC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB;;OAEG;IACH,OAAO,EAAE,sBAAsB,CAAA;CAChC;AACD,QAAA,MAAM,uBAAuB,yCAI1B,YAAY,4BAA4B,CAAC,gBA+D3C,CAAA;AAED,OAAO,EAAE,uBAAuB,EAAE,QAAQ,EAAE,CAAA;AAC5C,YAAY,EAAE,4BAA4B,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,CAAA"}
+{"version":3,"file":"ToastImperative.d.ts","sourceRoot":"","sources":["../src/ToastImperative.tsx"],"names":[],"mappings":"AACA,OAAO,KAAqD,MAAM,OAAO,CAAA;AAIzE,OAAO,EACL,wBAAwB,EACxB,cAAc,EACd,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,SAAS,CAAA;AAEhB,UAAU,sBAAuB,SAAQ,IAAI,CAAC,wBAAwB,EAAE,SAAS,CAAC;IAChF;;OAEG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAA;CAC1B;AACD,UAAU,WAAY,SAAQ,wBAAwB;IACpD;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACpC;;OAEG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAA;CAC1B;AAED,KAAK,SAAS,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,wBAAwB,GAAG;IACxE,iBAAiB,EAAE,OAAO,CAAA;CAC3B,CAAA;AAEH,UAAU,aAAa;IACrB,WAAW,EAAE,cAAc,GAAG,IAAI,CAAA;IAElC;;OAEG;IACH,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAA;IAEvD;;;;;;OAMG;IACH,IAAI,EAAE,MAAM,IAAI,CAAA;IAEhB,OAAO,CAAC,EAAE,sBAAsB,CAAA;CACjC;AAKD,eAAO,MAAM,kBAAkB,qBAE9B,CAAA;AAED,eAAO,MAAM,aAAa,wBAEzB,CAAA;AAED,qGAAqG;AACrG,eAAO,MAAM,QAAQ;;iBA/BN,cAAc,GAAG,IAAI;IAElC;;OAEG;kBACW,MAAM,YAAY,WAAW,KAAK,OAAO;IAEvD;;;;;;OAMG;UACG,MAAM,IAAI;;CAsBjB,CAAA;AAED,UAAU,4BAA4B;IACpC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB;;OAEG;IACH,OAAO,EAAE,sBAAsB,CAAA;CAChC;AAED,eAAO,MAAM,uBAAuB,2BAGjC,4BAA4B,gBAuE9B,CAAA;AAED,YAAY,EAAE,4BAA4B,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,CAAA"}