ads-fe 0.0.1

package/skills/vueuse-functions/references/useMemory.md

@@ -0,0 +1,70 @@
+---
+category: Browser
+---
+
+# useMemory
+
+Reactive Memory Info.
+
+## Usage
+
+```ts
+import { useMemory } from '@vueuse/core'
+
+const { isSupported, memory } = useMemory()
+```
+
+## Type Declarations
+
+```ts
+/**
+ * Performance.memory
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Performance/memory
+ */
+export interface MemoryInfo {
+  /**
+   * The maximum size of the heap, in bytes, that is available to the context.
+   */
+  readonly jsHeapSizeLimit: number
+  /**
+   *  The total allocated heap size, in bytes.
+   */
+  readonly totalJSHeapSize: number
+  /**
+   * The currently active segment of JS heap, in bytes.
+   */
+  readonly usedJSHeapSize: number
+  [Symbol.toStringTag]: "MemoryInfo"
+}
+export interface UseMemoryOptions extends ConfigurableScheduler {
+  /**
+   * Start the timer immediately
+   *
+   * @deprecated Please use `scheduler` option instead
+   * @default true
+   */
+  immediate?: boolean
+  /**
+   * Execute the callback immediately after calling `resume`
+   *
+   * @deprecated Please use `scheduler` option instead
+   * @default false
+   */
+  immediateCallback?: boolean
+  /** @deprecated Please use `scheduler` option instead */
+  interval?: number
+}
+export interface UseMemoryReturn extends Supportable {
+  memory: ShallowRef<MemoryInfo | undefined>
+}
+/**
+ * Reactive Memory Info.
+ *
+ * @see https://vueuse.org/useMemory
+ * @param options
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useMemory(options?: UseMemoryOptions): UseMemoryReturn
+```

package/skills/vueuse-functions/references/useMin.md

@@ -0,0 +1,36 @@
+---
+category: '@Math'
+---
+
+# useMin
+
+Reactive `Math.min`.
+
+## Usage
+
+```ts
+import { useMin } from '@vueuse/math'
+
+const array = ref([1, 2, 3, 4])
+const min = useMin(array) // Ref<1>
+```
+
+```ts
+import { useMin } from '@vueuse/math'
+
+const a = ref(1)
+const b = ref(3)
+
+const min = useMin(a, b, 2) // Ref<1>
+```
+
+## Type Declarations
+
+```ts
+export declare function useMin(
+  array: MaybeRefOrGetter<MaybeRefOrGetter<number>[]>,
+): ComputedRef<number>
+export declare function useMin(
+  ...args: MaybeRefOrGetter<number>[]
+): ComputedRef<number>
+```

package/skills/vueuse-functions/references/useMounted.md

@@ -0,0 +1,38 @@
+---
+category: Component
+---
+
+# useMounted
+
+Mounted state in ref.
+
+## Usage
+
+```ts
+import { useMounted } from '@vueuse/core'
+
+const isMounted = useMounted()
+```
+
+Which is essentially a shorthand of:
+
+```ts
+const isMounted = ref(false)
+
+onMounted(() => {
+  isMounted.value = true
+})
+```
+
+## Type Declarations
+
+```ts
+/**
+ * Mounted state in ref.
+ *
+ * @see https://vueuse.org/useMounted
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useMounted(): ShallowRef<boolean, boolean>
+```

package/skills/vueuse-functions/references/useMouse.md

@@ -0,0 +1,113 @@
+---
+category: Sensors
+---
+
+# useMouse
+
+Reactive mouse position
+
+## Basic Usage
+
+```ts twoslash
+import { useMouse } from '@vueuse/core'
+
+const { x, y, sourceType } = useMouse()
+```
+
+Touch is enabled by default. To only detect mouse changes, set `touch` to `false`.
+The `dragover` event is used to track mouse position while dragging.
+
+```ts twoslash
+import { useMouse } from '@vueuse/core'
+// ---cut---
+const { x, y } = useMouse({ touch: false })
+```
+
+## Custom Extractor
+
+It's also possible to provide a custom extractor function to get the position from the event.
+
+```ts twoslash
+import type { UseMouseEventExtractor } from '@vueuse/core'
+import { useMouse, useParentElement } from '@vueuse/core'
+
+const parentEl = useParentElement()
+
+const extractor: UseMouseEventExtractor = event => (
+  event instanceof MouseEvent
+    ? [event.offsetX, event.offsetY]
+    : null
+)
+
+const { x, y, sourceType } = useMouse({ target: parentEl, type: extractor })
+```
+
+## Component Usage
+
+```vue
+<template>
+  <UseMouse v-slot="{ x, y }">
+    x: {{ x }}
+    y: {{ y }}
+  </UseMouse>
+</template>
+```
+
+## Type Declarations
+
+```ts
+export type UseMouseCoordType = "page" | "client" | "screen" | "movement"
+export type UseMouseSourceType = "mouse" | "touch" | null
+export type UseMouseEventExtractor = (
+  event: MouseEvent | Touch,
+) => [x: number, y: number] | null | undefined
+export interface UseMouseOptions
+  extends ConfigurableWindow, ConfigurableEventFilter {
+  /**
+   * Mouse position based by page, client, screen, or relative to previous position
+   *
+   * @default 'page'
+   */
+  type?: UseMouseCoordType | UseMouseEventExtractor
+  /**
+   * Listen events on `target` element
+   *
+   * @default 'Window'
+   */
+  target?: MaybeRefOrGetter<Window | EventTarget | null | undefined>
+  /**
+   * Listen to `touchmove` events
+   *
+   * @default true
+   */
+  touch?: boolean
+  /**
+   * Listen to `scroll` events on window, only effective on type `page`
+   *
+   * @default true
+   */
+  scroll?: boolean
+  /**
+   * Reset to initial value when `touchend` event fired
+   *
+   * @default false
+   */
+  resetOnTouchEnds?: boolean
+  /**
+   * Initial values
+   */
+  initialValue?: Position
+}
+export interface UseMouseReturn {
+  x: ShallowRef<number>
+  y: ShallowRef<number>
+  sourceType: ShallowRef<UseMouseSourceType>
+}
+/**
+ * Reactive mouse position.
+ *
+ * @see https://vueuse.org/useMouse
+ * @param options
+ */
+export declare function useMouse(options?: UseMouseOptions): UseMouseReturn
+```

package/skills/vueuse-functions/references/useMouseInElement.md

@@ -0,0 +1,132 @@
+---
+category: Elements
+---
+
+# useMouseInElement
+
+Reactive mouse position related to an element
+
+## Usage
+
+```vue
+<script setup lang="ts">
+import { useMouseInElement } from '@vueuse/core'
+import { useTemplateRef } from 'vue'
+
+const target = useTemplateRef('target')
+
+const { x, y, isOutside } = useMouseInElement(target)
+</script>
+
+<template>
+  <div ref="target">
+    <h1>Hello world</h1>
+  </div>
+</template>
+```
+
+## Component Usage
+
+```vue
+<template>
+  <UseMouseInElement v-slot="{ elementX, elementY, isOutside }">
+    x: {{ elementX }}
+    y: {{ elementY }}
+    Is Outside: {{ isOutside }}
+  </UseMouseInElement>
+</template>
+```
+
+## Directive Usage
+
+```vue
+<script setup lang="ts">
+import { vMouseInElement } from '@vueuse/components'
+import { UseMouseSourceType } from '@vueuse/core'
+
+interface MouseInElementType {
+  x: number
+  y: number
+  sourceType: UseMouseSourceType
+  elementX: number
+  elementY: number
+  elementPositionX: number
+  elementPositionY: number
+  elementHeight: number
+  elementWidth: number
+  isOutside: boolean
+}
+
+const options = {
+  handleOutside: true
+}
+function onMouseInElement({ x, y, sourceType, elementX, elementY, elementPositionX, elementPositionY, elementHeight, elementWidth, isOutside }: MouseInElementType) {
+  console.log(x, y, sourceType, elementX, elementY, elementPositionX, elementPositionY, elementHeight, elementWidth, isOutside)
+}
+</script>
+
+<template>
+  <textarea v-mouse-in-element="onMouseInElement" />
+  <!-- with options -->
+  <textarea v-mouse-in-element="[onMouseInElement, options]" />
+</template>
+```
+
+## Type Declarations
+
+```ts
+export interface MouseInElementOptions extends UseMouseOptions {
+  /**
+   * Whether to handle mouse events when the cursor is outside the target element.
+   * When enabled, mouse position will continue to be tracked even when outside the element bounds.
+   *
+   * @default true
+   */
+  handleOutside?: boolean
+  /**
+   * Listen to window resize event
+   *
+   * @default true
+   */
+  windowScroll?: boolean
+  /**
+   * Listen to window scroll event
+   *
+   * @default true
+   */
+  windowResize?: boolean
+}
+export interface UseMouseInElementReturn extends UseMouseReturn {
+  elementX: ShallowRef<number>
+  elementY: ShallowRef<number>
+  elementPositionX: ShallowRef<number>
+  elementPositionY: ShallowRef<number>
+  elementHeight: ShallowRef<number>
+  elementWidth: ShallowRef<number>
+  isOutside: ShallowRef<boolean>
+  stop: () => void
+}
+/**
+ * Reactive mouse position related to an element.
+ *
+ * @see https://vueuse.org/useMouseInElement
+ * @param target
+ * @param options
+ */
+export declare function useMouseInElement(
+  target?: MaybeElementRef,
+  options?: MouseInElementOptions,
+): {
+  x: ShallowRef<number>
+  y: ShallowRef<number>
+  sourceType: ShallowRef<UseMouseSourceType>
+  elementX: ShallowRef<number, number>
+  elementY: ShallowRef<number, number>
+  elementPositionX: ShallowRef<number, number>
+  elementPositionY: ShallowRef<number, number>
+  elementHeight: ShallowRef<number, number>
+  elementWidth: ShallowRef<number, number>
+  isOutside: ShallowRef<boolean, boolean>
+  stop: () => void
+}
+```

package/skills/vueuse-functions/references/useMousePressed.md

@@ -0,0 +1,116 @@
+---
+category: Sensors
+---
+
+# useMousePressed
+
+Reactive mouse pressing state. Triggered by `mousedown` `touchstart` on target element and released by `mouseup` `mouseleave` `touchend` `touchcancel` on window.
+
+## Basic Usage
+
+```ts
+import { useMousePressed } from '@vueuse/core'
+
+const { pressed } = useMousePressed()
+```
+
+Touching is enabled by default. To make it only detects mouse changes, set `touch` to `false`
+
+```ts
+import { useMousePressed } from '@vueuse/core'
+// ---cut---
+const { pressed } = useMousePressed({ touch: false })
+```
+
+To only capture `mousedown` and `touchstart` on specific element, you can specify `target` by passing a ref of the element.
+
+```vue
+<script setup lang="ts">
+import { useMousePressed } from '@vueuse/core'
+// ---cut---
+import { useTemplateRef } from 'vue'
+
+const el = useTemplateRef('el')
+
+const { pressed } = useMousePressed({ target: el })
+</script>
+
+<template>
+  <div ref="el">
+    Only clicking on this element will trigger the update.
+  </div>
+</template>
+```
+
+## Component Usage
+
+```vue
+<template>
+  <UseMousePressed v-slot="{ pressed }">
+    Is Pressed: {{ pressed }}
+  </UseMousePressed>
+</template>
+```
+
+## Type Declarations
+
+```ts
+export interface UseMousePressedOptions extends ConfigurableWindow {
+  /**
+   * Listen to `touchstart` `touchend` events
+   *
+   * @default true
+   */
+  touch?: boolean
+  /**
+   * Listen to `dragstart` `drop` and `dragend` events
+   *
+   * @default true
+   */
+  drag?: boolean
+  /**
+   * Add event listeners with the `capture` option set to `true`
+   * (see [MDN](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#capture))
+   *
+   * @default false
+   */
+  capture?: boolean
+  /**
+   * Initial values
+   *
+   * @default false
+   */
+  initialValue?: boolean
+  /**
+   * Element target to be capture the click
+   */
+  target?: MaybeComputedElementRef
+  /**
+   * Callback to be called when the mouse is pressed
+   *
+   * @param event
+   */
+  onPressed?: (event: MouseEvent | TouchEvent | DragEvent) => void
+  /**
+   * Callback to be called when the mouse is released
+   *
+   * @param event
+   */
+  onReleased?: (event: MouseEvent | TouchEvent | DragEvent) => void
+}
+/** @deprecated use {@link UseMousePressedOptions} instead */
+export type MousePressedOptions = UseMousePressedOptions
+export interface UseMousePressedReturn {
+  pressed: ShallowRef<boolean>
+  sourceType: ShallowRef<UseMouseSourceType>
+}
+/**
+ * Reactive mouse pressing state.
+ *
+ * @see https://vueuse.org/useMousePressed
+ * @param options
+ */
+export declare function useMousePressed(
+  options?: UseMousePressedOptions,
+): UseMousePressedReturn
+```

package/skills/vueuse-functions/references/useMutationObserver.md

@@ -0,0 +1,60 @@
+---
+category: Elements
+---
+
+# useMutationObserver
+
+Watch for changes being made to the DOM tree. [MutationObserver MDN](https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver)
+
+## Usage
+
+```vue
+<script setup lang="ts">
+import { useMutationObserver } from '@vueuse/core'
+import { ref, useTemplateRef } from 'vue'
+
+const el = useTemplateRef('el')
+const messages = ref([])
+
+useMutationObserver(el, (mutations) => {
+  if (mutations[0])
+    messages.value.push(mutations[0].attributeName)
+}, {
+  attributes: true,
+})
+</script>
+
+<template>
+  <div ref="el">
+    Hello VueUse
+  </div>
+</template>
+```
+
+## Type Declarations
+
+```ts
+export interface UseMutationObserverOptions
+  extends MutationObserverInit, ConfigurableWindow {}
+export interface UseMutationObserverReturn extends Supportable {
+  stop: () => void
+  takeRecords: () => MutationRecord[] | undefined
+}
+/**
+ * Watch for changes being made to the DOM tree.
+ *
+ * @see https://vueuse.org/useMutationObserver
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver MutationObserver MDN
+ * @param target
+ * @param callback
+ * @param options
+ */
+export declare function useMutationObserver(
+  target:
+    | MaybeComputedElementRef
+    | MaybeComputedElementRef[]
+    | MaybeRefOrGetter<MaybeElement[]>,
+  callback: MutationCallback,
+  options?: UseMutationObserverOptions,
+): UseMutationObserverReturn
+```

package/skills/vueuse-functions/references/useNProgress.md

@@ -0,0 +1,78 @@
+---
+category: '@Integrations'
+---
+
+# useNProgress
+
+Reactive wrapper for [`nprogress`](https://github.com/rstacruz/nprogress).
+
+## Install
+
+```bash
+npm i nprogress@^0
+```
+
+## Usage
+
+```ts {6}
+import { useNProgress } from '@vueuse/integrations/useNProgress'
+
+const { isLoading } = useNProgress()
+
+function toggle() {
+  isLoading.value = !isLoading.value
+}
+```
+
+### Passing a progress percentage
+
+You can pass a percentage to indicate where the bar should start from.
+
+```ts {3}
+import { useNProgress } from '@vueuse/integrations/useNProgress'
+
+const { progress } = useNProgress(0.5)
+
+function done() {
+  progress.value = 1.0
+}
+```
+
+> To change the progress percentage, set `progress.value = n`, where n is a number between 0..1.
+
+### Customization
+
+Just edit [nprogress.css](https://github.com/rstacruz/nprogress/blob/master/nprogress.css) to your liking. Tip: you probably only want to find and replace occurrences of #29d.
+
+You can [configure](https://github.com/rstacruz/nprogress#configuration) it by passing an object as a second parameter.
+
+```ts {4}
+import { useNProgress } from '@vueuse/integrations/useNProgress'
+
+useNProgress(null, {
+  minimum: 0.1,
+  // ...
+})
+```
+
+## Type Declarations
+
+```ts
+export type UseNProgressOptions = Partial<NProgressOptions>
+export interface UseNProgressReturn {
+  isLoading: WritableComputedRef<boolean, boolean>
+  progress: Ref<number | null | undefined>
+  start: () => NProgress
+  done: (force?: boolean) => NProgress
+  remove: () => void
+}
+/**
+ * Reactive progress bar.
+ *
+ * @see https://vueuse.org/useNProgress
+ */
+export declare function useNProgress(
+  currentProgress?: MaybeRefOrGetter<number | null | undefined>,
+  options?: UseNProgressOptions,
+): UseNProgressReturn
+```

package/skills/vueuse-functions/references/useNavigatorLanguage.md

@@ -0,0 +1,57 @@
+---
+category: Sensors
+---
+
+# useNavigatorLanguage
+
+Reactive [navigator.language](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/language).
+
+## Usage
+
+```ts
+import { useNavigatorLanguage } from '@vueuse/core'
+
+const { language } = useNavigatorLanguage()
+
+watch(language, () => {
+  // Listen to the value changing
+})
+```
+
+## Type Declarations
+
+```ts
+export interface NavigatorLanguageState extends Supportable {
+  /**
+   *
+   * ISO 639-1 standard Language Code
+   *
+   * @info The detected user agent language preference as a language tag
+   * (which is sometimes referred to as a "locale identifier").
+   * This consists of a 2-3 letter base language tag that indicates a
+   * language, optionally followed by additional subtags separated by
+   * '-'. The most common extra information is the country or region
+   * variant (like 'en-US' or 'fr-CA').
+   *
+   *
+   * @see https://www.iso.org/iso-639-language-codes.html
+   * @see https://www.loc.gov/standards/iso639-2/php/code_list.php
+   *
+   */
+  language: ShallowRef<string | undefined>
+}
+export interface UseNavigatorLanguageOptions extends ConfigurableWindow {}
+export type UseNavigatorLanguageReturn = Readonly<NavigatorLanguageState>
+/**
+ *
+ * Reactive useNavigatorLanguage
+ *
+ * Detects the currently selected user language and returns a reactive language
+ * @see https://vueuse.org/useNavigatorLanguage
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare function useNavigatorLanguage(
+  options?: UseNavigatorLanguageOptions,
+): UseNavigatorLanguageReturn
+```