zartui 3.1.2 → 3.1.4

package/lib/radio-picker/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+module.exports = __toCommonJS(stdin_exports);

package/lib/radio-picker/utils.d.ts

@@ -0,0 +1,13 @@
+import type { Ref } from 'vue';
+import type { Numeric } from '../utils';
+import type { PickerColumn, PickerFieldNames, RadioPickerOption } from './types';
+declare const name: string, bem: (el?: import("../utils").Mods | undefined, mods?: import("../utils").Mods | undefined) => import("../utils").Mods, t: (path: string, ...args: unknown[]) => any;
+export { bem, name, t };
+export declare const getFirstEnabledOption: (options: RadioPickerOption[]) => RadioPickerOption | undefined;
+export declare function getColumnsType(columns: PickerColumn | PickerColumn[], fields: Required<PickerFieldNames>): "default" | "multiple" | "cascade";
+export declare function findIndexOfEnabledOption(options: RadioPickerOption[], index: number): number;
+export declare const isOptionExist: (options: RadioPickerOption[], value: Numeric | undefined, fields: Required<PickerFieldNames>) => boolean;
+export declare function findOptionByValue(options: RadioPickerOption[], value: Numeric, fields: Required<PickerFieldNames>): RadioPickerOption | undefined;
+export declare function formatCascadeColumns(columns: PickerColumn | PickerColumn[], fields: Required<PickerFieldNames>, selectedValues: Ref<Numeric[]>): PickerColumn[];
+export declare function getElementTranslateY(element: Element): number;
+export declare function assignDefaultFields(fields: PickerFieldNames | undefined): Required<PickerFieldNames>;

package/lib/radio-picker/utils.js

@@ -0,0 +1,99 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  assignDefaultFields: () => assignDefaultFields,
+  bem: () => bem,
+  findIndexOfEnabledOption: () => findIndexOfEnabledOption,
+  findOptionByValue: () => findOptionByValue,
+  formatCascadeColumns: () => formatCascadeColumns,
+  getColumnsType: () => getColumnsType,
+  getElementTranslateY: () => getElementTranslateY,
+  getFirstEnabledOption: () => getFirstEnabledOption,
+  isOptionExist: () => isOptionExist,
+  name: () => name,
+  t: () => t
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_utils = require("../utils");
+const [name, bem, t] = (0, import_utils.createNamespace)("radio-picker");
+const getFirstEnabledOption = (options) => options.find((option) => !option.disabled) || options[0];
+function getColumnsType(columns, fields) {
+  const firstColumn = columns[0];
+  if (firstColumn) {
+    if (Array.isArray(firstColumn)) {
+      return "multiple";
+    }
+    if (fields.children in firstColumn) {
+      return "cascade";
+    }
+  }
+  return "default";
+}
+function findIndexOfEnabledOption(options, index) {
+  index = (0, import_utils.clamp)(index, 0, options.length);
+  for (let i = index; i < options.length; i++) {
+    if (!options[i].disabled)
+      return i;
+  }
+  for (let i = index - 1; i >= 0; i--) {
+    if (!options[i].disabled)
+      return i;
+  }
+  return 0;
+}
+const isOptionExist = (options, value, fields) => value !== void 0 && !!options.find((option) => option[fields.value] === value);
+function findOptionByValue(options, value, fields) {
+  const index = options.findIndex((option) => option[fields.value] === value);
+  const enabledIndex = findIndexOfEnabledOption(options, index);
+  return options[enabledIndex];
+}
+function formatCascadeColumns(columns, fields, selectedValues) {
+  const formatted = [];
+  let cursor = {
+    [fields.children]: columns
+  };
+  let columnIndex = 0;
+  while (cursor && cursor[fields.children]) {
+    const options = cursor[fields.children];
+    const value = selectedValues.value[columnIndex];
+    cursor = (0, import_utils.isDef)(value) ? findOptionByValue(options, value, fields) : void 0;
+    if (!cursor && options.length) {
+      const firstValue = getFirstEnabledOption(options)[fields.value];
+      cursor = findOptionByValue(options, firstValue, fields);
+    }
+    columnIndex++;
+    formatted.push(options);
+  }
+  return formatted;
+}
+function getElementTranslateY(element) {
+  const { transform } = window.getComputedStyle(element);
+  const translateY = transform.slice(7, transform.length - 1).split(", ")[5];
+  return Number(translateY);
+}
+function assignDefaultFields(fields) {
+  return (0, import_utils.extend)(
+    {
+      text: "text",
+      value: "value",
+      children: "children"
+    },
+    fields
+  );
+}

package/lib/utils/debounce.d.ts

@@ -0,0 +1,46 @@
+import { Ref } from 'vue';
+export interface FunctionWrapperOptions<Args extends any[] = any[], This = any> {
+    fn: FunctionArgs<Args, This>;
+    args: Args;
+    thisArg: This;
+}
+export type EventFilter<Args extends any[] = any[], This = any, Invoke extends AnyFn = AnyFn> = (invoke: Invoke, options: FunctionWrapperOptions<Args, This>) => ReturnType<Invoke> | Promise<ReturnType<Invoke>>;
+export type AnyFn = (...args: any[]) => any;
+export type MaybeRef<T> = T | Ref<T>;
+export type FunctionArgs<Args extends any[] = any[], Return = void> = (...args: Args) => Return;
+export type MaybeRefOrGetter<T> = MaybeRef<T> | (() => T);
+export type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+export type PromisifyFn<T extends AnyFn> = (...args: ArgumentsType<T>) => Promise<ReturnType<T>>;
+export interface DebounceFilterOptions {
+    /**
+     * The maximum time allowed to be delayed before it's invoked.
+     * In milliseconds.
+     */
+    maxWait?: MaybeRefOrGetter<number>;
+    /**
+     * Whether to reject the last call if it's been cancel.
+     *
+     * @default false
+     */
+    rejectOnCancel?: boolean;
+}
+/**
+ * Get the value of value/ref/getter.
+ */
+export declare function toValue<T>(r: MaybeRefOrGetter<T>): T;
+/**
+ * Create an EventFilter that debounce the events
+ */
+export declare function debounceFilter(ms: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): EventFilter<any[], any, AnyFn>;
+export declare function createFilterWrapper<T extends AnyFn>(filter: EventFilter, fn: T): (this: any, ...args: ArgumentsType<T>) => Promise<ReturnType<T>>;
+/**
+ * Debounce execution of a function.
+ *
+ * @see https://vueuse.org/useDebounceFn
+ * @param  fn          A function to be executed after delay milliseconds debounced.
+ * @param  ms          A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
+ * @param  opts        options
+ *
+ * @return A new, debounce, function.
+ */
+export declare function useDebounceFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): PromisifyFn<T>;

package/lib/utils/debounce.js

@@ -0,0 +1,84 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  createFilterWrapper: () => createFilterWrapper,
+  debounceFilter: () => debounceFilter,
+  toValue: () => toValue,
+  useDebounceFn: () => useDebounceFn
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_utils = require("../utils");
+function toValue(r) {
+  return typeof r === "function" ? r() : (0, import_vue.unref)(r);
+}
+function debounceFilter(ms, options = {}) {
+  let timer;
+  let maxTimer;
+  let lastRejector = import_utils.noop;
+  const _clearTimeout = (timer2) => {
+    clearTimeout(timer2);
+    lastRejector();
+    lastRejector = import_utils.noop;
+  };
+  const filter = (invoke) => {
+    const duration = toValue(ms);
+    const maxDuration = toValue(options.maxWait);
+    if (timer)
+      _clearTimeout(timer);
+    if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
+      if (maxTimer) {
+        _clearTimeout(maxTimer);
+        maxTimer = null;
+      }
+      return Promise.resolve(invoke());
+    }
+    return new Promise((resolve, reject) => {
+      lastRejector = options.rejectOnCancel ? reject : resolve;
+      if (maxDuration && !maxTimer) {
+        maxTimer = setTimeout(() => {
+          if (timer)
+            _clearTimeout(timer);
+          maxTimer = null;
+          resolve(invoke());
+        }, maxDuration);
+      }
+      timer = setTimeout(() => {
+        if (maxTimer)
+          _clearTimeout(maxTimer);
+        maxTimer = null;
+        resolve(invoke());
+      }, duration);
+    });
+  };
+  return filter;
+}
+function createFilterWrapper(filter, fn) {
+  function wrapper(...args) {
+    return new Promise((resolve, reject) => {
+      Promise.resolve(
+        filter(() => fn.apply(this, args), { fn, thisArg: this, args })
+      ).then(resolve).catch(reject);
+    });
+  }
+  return wrapper;
+}
+function useDebounceFn(fn, ms = 200, options = {}) {
+  return createFilterWrapper(debounceFilter(ms, options), fn);
+}

package/lib/vue-sfc-shim.d.ts

@@ -1,6 +1,6 @@
-declare module '*.vue' {
-  // eslint-disable-next-line
-  import { DefineComponent } from 'vue';
-  const Component: DefineComponent;
-  export default Component;
-}
+declare module '*.vue' {
+  // eslint-disable-next-line
+  import { DefineComponent } from 'vue';
+  const Component: DefineComponent;
+  export default Component;
+}

package/lib/vue-tsx-shim.d.ts

@@ -1,23 +1,23 @@
-import 'vue';
-
-type EventHandler = (...args: any[]) => void;
-
-declare module 'vue' {
-  interface ComponentCustomProps {
-    id?: string;
-    role?: string;
-    tabindex?: number;
-    onClick?: EventHandler;
-    onTouchend?: EventHandler;
-    onTouchmove?: EventHandler;
-    onTouchstart?: EventHandler;
-    onTouchcancel?: EventHandler;
-    onTouchmovePassive?: EventHandler;
-    onTouchstartPassive?: EventHandler;
-  }
-
-  interface HTMLAttributes {
-    onTouchmovePassive?: EventHandler;
-    onTouchstartPassive?: EventHandler;
-  }
-}
+import 'vue';
+
+type EventHandler = (...args: any[]) => void;
+
+declare module 'vue' {
+  interface ComponentCustomProps {
+    id?: string;
+    role?: string;
+    tabindex?: number;
+    onClick?: EventHandler;
+    onTouchend?: EventHandler;
+    onTouchmove?: EventHandler;
+    onTouchstart?: EventHandler;
+    onTouchcancel?: EventHandler;
+    onTouchmovePassive?: EventHandler;
+    onTouchstartPassive?: EventHandler;
+  }
+
+  interface HTMLAttributes {
+    onTouchmovePassive?: EventHandler;
+    onTouchstartPassive?: EventHandler;
+  }
+}