vue-spear-tip 0.3.5 → 0.4.0-bata.1

package/dist/{FieldComponent.vue_vue_type_script_lang-jsRPTb1I.js → FieldComponent.vue_vue_type_script_lang-CbZEWDkH.js}

@@ -1,6 +1,6 @@
 var e = Object.defineProperty;
 var r = (x, c) => e(x, "name", { value: c, configurable: !0 });
-import { F as f } from "./index-tFjvTAxv.js";
+import { F as f } from "./index-CNjoKQFy.js";
 const a = class a extends f {
 };
 r(a, "FieldComponentUnoCss");

package/dist/{FieldComponent.vue_vue_type_script_lang-BC3VLZoe.cjs → FieldComponent.vue_vue_type_script_lang-CnauMYh0.cjs}

@@ -1 +1 @@
-"use strict";var r=Object.defineProperty;var t=(c,i)=>r(c,"name",{value:i,configurable:!0});const d=require("./index-Ccp2Ps3f.cjs"),s=class s extends d.FieldComponent{};t(s,"FieldComponentUnoCss");let e=s;exports.FieldComponentUnoCss=e;
+"use strict";var r=Object.defineProperty;var t=(c,i)=>r(c,"name",{value:i,configurable:!0});const d=require("./index-CSUnkSRo.cjs"),s=class s extends d.FieldComponent{};t(s,"FieldComponentUnoCss");let e=s;exports.FieldComponentUnoCss=e;

package/dist/Interfaces/IBaseVueComponent.d.ts

@@ -7,4 +7,27 @@ export default interface IBaseVueComponent extends IVueClass {
     };
     /** Event on window change */
     onViewPortResize(): void;
+    /** Event when user click or tap on component. Generate @clickTap event by default. */
+    onComponentClickOrTap(): void;
+    /**
+     * Хук-синтаксический сахар, для группировки отписок пред размонированием компонента.
+     * @param end Метод, который будет выполнен, перед размонтрованием.
+     */
+    hookWhenComponentDestroy(end: () => any): void;
+    /**
+     * Регистрация события на сочетания клавиш. Заменит действие по умолчанию. Повторная регистрация комбинации
+     * заменяет прошлую. Будет отключена при размонтировании или удалении компонента со страницы.
+     * e.preventDefault() может привести к ошибкам
+     * @param key Название клавиши на английском языке в нижнем регистре
+     * @param callback Метод выполняющийся при нажатии клавиши
+     * @param ctrlOrCommand Удерживается ли CTRL или COMMAND на Mac OS. По умолчанию отслеживание включено.
+     * @param alt Удерживается ли alt
+     * @param shift Удерживается ли shift
+     * @protected
+     * @example
+     * this.registerHotKey('k', (e: KeyboardEvent) => console.log('CTRL+K pressed'))
+     * this.registerHotKey('f', (e: KeyboardEvent) => console.log('ALT+F pressed'), false, false, true)
+     * this.registerHotKey('f12', (e: KeyboardEvent) => console.log('CTRL+SHIFT+F12 pressed'), true, true)
+     */
+    registerHotKey(key: '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '-' | '=' | 'q' | 'w' | 'e' | 'r' | 't' | 'y' | 'u' | 'i' | 'o' | 'p' | '[' | ']' | 'a' | 's' | 'd' | 'f' | 'g' | 'h' | 'j' | 'k' | 'l' | ';' | "'" | '\\' | 'z' | 'x' | 'c' | 'v' | 'b' | 'n' | 'm' | ',' | '.' | '/' | 'f1' | 'f2' | 'f3' | 'f4' | 'f5' | 'f6' | 'f7' | 'f8' | 'f9' | 'f10' | 'f11' | 'f12', callback: (e: Event) => any, ctrlOrCommand: boolean, alt: boolean, shift: boolean): void;
 }

package/dist/Interfaces/IDeviceInfo.d.ts

@@ -0,0 +1,30 @@
+export default interface IDeviceInfo {
+    /** Полная информация */
+    userAgentData(): {
+        [key: string]: any;
+    };
+    /** Название браузера */
+    browserName(): string;
+    /** Версия браузера */
+    browserVersion(): string;
+    /** Мажорная версия браузера */
+    browserMajor(): string;
+    /** Движок браузера */
+    browserEngine(): string;
+    /** Версия движка браузера */
+    browserEngineVersion(): string;
+    /** Модель устройства */
+    deviceModel(): string;
+    /** Поставщик устройства */
+    deviceVendor(): string;
+    /** Операционная система */
+    osName(): string;
+    /** Распознанный тип устройства по User Agent строке */
+    device(): 'desktop' | 'mobile' | 'tablet';
+    /** Поставщик операционной системы */
+    osVendor(): string;
+    /** Версия операционной системы */
+    osVersion(): string;
+    /** Архитектура процессора */
+    cpuArchitecture(): string;
+}

package/dist/Interfaces/IGlobalVST.d.ts

@@ -1,10 +1,38 @@
 import { Temporal } from 'temporal-polyfill';
+import IDeviceInfo from './IDeviceInfo';
+import IHammer from './IHammer';
 export interface IGlobalVST {
-    $r: IGlobalReactiveElements;
+    /** Параметры, которые будут отработаны реактивно внутри шаблонов */
+    $reactive: IGlobalReactiveElements;
+    /**
+     * Подписаться на событие
+     * @param event
+     * @param callback
+     */
     $on(event: string, callback: (message: any) => any): void;
+    /**
+     * Отписаться от события
+     * @param event
+     * @param callback
+     */
     $off(event: string, callback: (message: any) => any): void;
+    /**
+     * Эмиттировать событие (запустить)
+     * @param event
+     * @param message
+     */
     $emit(event: string, message?: any): void;
+    /**
+     * Работа со временем
+     * @param dateTimeString
+     * @param timeZone
+     * @constructor
+     */
     DT(dateTimeString?: string | number | Temporal.ZonedDateTime | Date, timeZone?: string): Temporal.ZonedDateTime;
+    /**
+     * Скопировать текст в буфер обмена
+     * @param text
+     */
     copyToClipboard(text: string): void;
     /**
      * Генерация случайного сложного пароля
@@ -21,21 +49,47 @@ export interface IGlobalVST {
      * @param any
      */
     safeStringify(any: any): string;
+    /** Информация об устройстве  */
+    device(): IDeviceInfo;
     /** Default time zone on $VST.DT() method (like Europe/Moscow). As default use browser tz */
     DT_TZ?: string;
+    /** Класс для обработки событий на базе Hammer.js */
+    readonly Hammer: IHammer;
+    /** Зарегистрированные замыкания на горячие клавиши внутри компонентов. Системное свойство. */
+    readonly __REGISTERED_HOTKEYS: {
+        [k: string]: {
+            callback: (e: KeyboardEvent) => void;
+            ctrlOrCommand: boolean;
+            alt: boolean;
+            shift: boolean;
+        };
+    };
 }
 /** Интерфейс реактивных глобальных элементов доступных в любом компоненте наследуемым от BaseComponent */
 interface IGlobalReactiveElements {
-    locale: string;
-    isMobile: boolean;
-    isTablet: boolean;
-    isNotebook: boolean;
-    isDesktop: boolean;
+    /** Локаль браузера */
+    readonly locale: string;
+    /** Отображается ли компонент в мобильной версии экрана */
+    readonly isMobile: boolean;
+    /** Отображается ли компонент в планшетной версии экрана */
+    readonly isTablet: boolean;
+    /** Отображается ли компонент в версии экрана для ноутбука */
+    readonly isNotebook: boolean;
+    /** Отображается ли компонент в планшетной версии экрана */
+    readonly isDesktop: boolean;
+    /** Присутствует ли тачпад */
+    readonly hasTouchpad: boolean;
+    /** Определено ли устройство как iPhone */
+    readonly isIphone: boolean;
+    /** Определено ли устройство как Apple (используется WebKit движок) */
+    readonly isApple: boolean;
+    /** Определено ли устройство как Android */
+    readonly isAndroid: boolean;
     /** Тип экрана пользователя */
-    viewPortType: 'mobile' | 'tablet' | 'notebook' | 'desktop';
+    readonly viewPortType: 'mobile' | 'tablet' | 'notebook' | 'desktop';
     /** Длина экрана пользователя в пикселях */
-    viewPortWidth: number;
+    readonly viewPortWidth: number;
     /** Высота экрана пользователя в пикселях */
-    viewPortHeight: number;
+    readonly viewPortHeight: number;
 }
 export {};

package/dist/Interfaces/IHammer.d.ts

@@ -0,0 +1,271 @@
+export default interface IHammer {
+    new (element: HTMLElement | SVGElement, options?: HammerOptions): HammerManager;
+    defaults: HammerDefaults;
+    VERSION: number;
+    INPUT_START: 1;
+    INPUT_MOVE: 2;
+    INPUT_END: 4;
+    INPUT_CANCEL: 8;
+    STATE_POSSIBLE: 1;
+    STATE_BEGAN: 2;
+    STATE_CHANGED: 4;
+    STATE_ENDED: 8;
+    STATE_RECOGNIZED: 8;
+    STATE_CANCELLED: 16;
+    STATE_FAILED: 32;
+    DIRECTION_NONE: 1;
+    DIRECTION_LEFT: 2;
+    DIRECTION_RIGHT: 4;
+    DIRECTION_UP: 8;
+    DIRECTION_DOWN: 16;
+    DIRECTION_HORIZONTAL: 6;
+    DIRECTION_VERTICAL: 24;
+    DIRECTION_ALL: 30;
+    Manager: HammerManagerConstructor;
+    Input: HammerInput;
+    TouchAction: TouchAction;
+    TouchInput: TouchInput;
+    MouseInput: MouseInput;
+    PointerEventInput: PointerEventInput;
+    TouchMouseInput: TouchMouseInput;
+    SingleTouchInput: SingleTouchInput;
+    Recognizer: RecognizerStatic;
+    AttrRecognizer: AttrRecognizerStatic;
+    Tap: TapRecognizerStatic;
+    Pan: PanRecognizerStatic;
+    Swipe: SwipeRecognizerStatic;
+    Pinch: PinchRecognizerStatic;
+    Rotate: RotateRecognizerStatic;
+    Press: PressRecognizerStatic;
+    on(target: EventTarget, types: string, handler: Function): void;
+    off(target: EventTarget, types: string, handler: Function): void;
+    each(obj: any, iterator: Function, context: any): void;
+    merge(dest: any, src: any): any;
+    extend(dest: any, src: any, merge: boolean): any;
+    inherit(child: Function, base: Function, properties: any): any;
+    bindFn(fn: Function, context: any): Function;
+    prefixed(obj: any, property: string): string;
+}
+type RecognizerTuple = [RecognizerStatic] | [RecognizerStatic, RecognizerOptions] | [RecognizerStatic, RecognizerOptions, string | string[]] | [RecognizerStatic, RecognizerOptions, string | string[], (string | Recognizer) | Array<string | Recognizer>];
+interface HammerDefaults extends HammerOptions {
+    domEvents: boolean;
+    enable: boolean;
+    preset: RecognizerTuple[];
+    touchAction: string;
+    cssProps: CssProps;
+    inputClass: HammerInput;
+    inputTarget: EventTarget;
+}
+interface CssProps {
+    contentZooming: string;
+    tapHighlightColor: string;
+    touchCallout: string;
+    touchSelect: string;
+    userDrag: string;
+    userSelect: string;
+}
+interface HammerOptions {
+    cssProps?: CssProps | undefined;
+    domEvents?: boolean | undefined;
+    enable?: boolean | ((manager: HammerManager) => boolean) | undefined;
+    preset?: RecognizerTuple[] | undefined;
+    touchAction?: string | undefined;
+    recognizers?: RecognizerTuple[] | undefined;
+    inputClass?: HammerInput | undefined;
+    inputTarget?: EventTarget | undefined;
+}
+interface HammerManagerConstructor {
+    new (element: EventTarget, options?: HammerOptions): HammerManager;
+}
+interface HammerListener {
+    (event: HammerInput): void;
+}
+type HammerEvents = 
+/** Тап / Касание (короткое нажатие) или клик */
+'tap'
+/** Сдвиг / Панорамирование (перетаскивание с удержанием) */
+ | 'pan' | 'panstart' | 'panmove' | 'panend' | 'pancancel' | 'panleft' | 'panright' | 'panup' | 'pandown'
+/** Щипок (жест масштабирования двумя пальцами) */
+ | 'pinch' | 'pinchstart' | 'pinchmove' | 'pinchend' | 'pinchcancel' | 'pinchin' | 'pinchout'
+/** Нажатие (долгое нажатие без движения) */
+ | 'press' | 'pressup'
+/** Поворот (вращение двумя пальцами) */
+ | 'rotate' | 'rotatestart' | 'rotatemove' | 'rotateend' | 'rotatecancel'
+/** Свайп (быстрый провод в направлении) */
+ | 'swipe' | 'swipeleft' | 'swiperight' | 'swipeup' | 'swipedown';
+type HammerEventsString = HammerEvents | `${HammerEvents} ${HammerEvents}` | `${HammerEvents} ${HammerEvents} ${HammerEvents}`;
+interface HammerManager {
+    add(recogniser: Recognizer): Recognizer;
+    add(recogniser: Recognizer): HammerManager;
+    add(recogniser: Recognizer[]): Recognizer;
+    add(recogniser: Recognizer[]): HammerManager;
+    destroy(): void;
+    emit(event: string, data: any): void;
+    get(recogniser: Recognizer): Recognizer;
+    get(recogniser: string): Recognizer;
+    off(events: HammerEventsString, handler?: HammerListener): void;
+    on(events: HammerEventsString, handler: HammerListener): void;
+    recognize(inputData: any): void;
+    remove(recogniser: Recognizer): HammerManager;
+    remove(recogniser: string): HammerManager;
+    set(options: HammerOptions): HammerManager;
+    stop(force: boolean): void;
+}
+declare class HammerInput {
+    constructor(manager: HammerManager, callback: Function);
+    destroy(): void;
+    handler(): void;
+    init(): void;
+    /** Name of the event. Like panstart. */
+    type: string;
+    /** Movement of the X axis. */
+    deltaX: number;
+    /** Movement of the Y axis. */
+    deltaY: number;
+    /** Total time in ms since the first input. */
+    deltaTime: number;
+    /** Distance moved. */
+    distance: number;
+    /** Angle moved. */
+    angle: number;
+    /** Velocity on the X axis, in px/ms. */
+    velocityX: number;
+    /** Velocity on the Y axis, in px/ms */
+    velocityY: number;
+    /** Highest velocityX/Y value. */
+    velocity: number;
+    overallVelocity: number;
+    overallVelocityX: number;
+    overallVelocityY: number;
+    /** Direction moved. Matches the DIRECTION constants. */
+    direction: number;
+    /** Direction moved from it's starting point. Matches the DIRECTION constants. */
+    offsetDirection: number;
+    /** Scaling that has been done when multi-touch. 1 on a single touch. */
+    scale: number;
+    /** Rotation that has been done when multi-touch. 0 on a single touch. */
+    rotation: number;
+    /** Center position for multi-touch, or just the single pointer. */
+    center: HammerPoint;
+    /** The amount of multi-taps being recognized. */
+    tapCount?: number;
+    /** Source event object, type TouchEvent, MouseEvent or PointerEvent. */
+    srcEvent: TouchEvent | MouseEvent | PointerEvent;
+    /** Target that received the event. */
+    target: HTMLElement;
+    /** Primary pointer type, could be touch, mouse, pen or kinect. */
+    pointerType: string;
+    /** Event type, matches the INPUT constants. */
+    eventType: HammerStatic["INPUT_START"] | HammerStatic["INPUT_MOVE"] | HammerStatic["INPUT_END"] | HammerStatic["INPUT_CANCEL"];
+    /** true when the first input. */
+    isFirst: boolean;
+    /** true when the final (last) input. */
+    isFinal: boolean;
+    /** Array with all pointers, including the ended pointers (touchend, mouseup). */
+    pointers: any[];
+    /** Array with all new/moved/lost pointers. */
+    changedPointers: any[];
+    /** Maximum number of pointers detected in the gesture */
+    maxPointers: number;
+    /** Timestamp of a gesture */
+    timeStamp: number;
+    /** Reference to the srcEvent.preventDefault() method. Only for experts! */
+    preventDefault: Function;
+}
+declare class MouseInput extends HammerInput {
+    constructor(manager: HammerManager, callback: Function);
+}
+declare class PointerEventInput extends HammerInput {
+    constructor(manager: HammerManager, callback: Function);
+}
+declare class SingleTouchInput extends HammerInput {
+    constructor(manager: HammerManager, callback: Function);
+}
+declare class TouchInput extends HammerInput {
+    constructor(manager: HammerManager, callback: Function);
+}
+declare class TouchMouseInput extends HammerInput {
+    constructor(manager: HammerManager, callback: Function);
+}
+interface RecognizerOptions {
+    direction?: number | undefined;
+    enable?: boolean | ((recognizer: Recognizer, inputData: HammerInput) => boolean) | undefined;
+    event?: string | undefined;
+    interval?: number | undefined;
+    pointers?: number | undefined;
+    posThreshold?: number | undefined;
+    taps?: number | undefined;
+    threshold?: number | undefined;
+    time?: number | undefined;
+    velocity?: number | undefined;
+}
+interface RecognizerStatic {
+    new (options?: RecognizerOptions): Recognizer;
+}
+interface Recognizer {
+    defaults: any;
+    canEmit(): boolean;
+    canRecognizeWith(otherRecognizer: Recognizer): boolean;
+    dropRecognizeWith(otherRecognizer: Recognizer | Recognizer[] | string): Recognizer;
+    dropRequireFailure(otherRecognizer: Recognizer | Recognizer[] | string): Recognizer;
+    emit(input: HammerInput): void;
+    getTouchAction(): any[];
+    hasRequireFailures(): boolean;
+    process(inputData: HammerInput): string;
+    recognize(inputData: HammerInput): void;
+    recognizeWith(otherRecognizer: Recognizer | Recognizer[] | string): Recognizer;
+    requireFailure(otherRecognizer: Recognizer | Recognizer[] | string): Recognizer;
+    reset(): void;
+    set(options?: RecognizerOptions): Recognizer;
+    tryEmit(input: HammerInput): void;
+}
+interface AttrRecognizerStatic {
+    attrTest(input: HammerInput): boolean;
+    process(input: HammerInput): any;
+}
+interface AttrRecognizer extends Recognizer {
+    new (options?: RecognizerOptions): AttrRecognizer;
+}
+interface PanRecognizerStatic {
+    new (options?: RecognizerOptions): PanRecognizer;
+}
+interface PanRecognizer extends AttrRecognizer {
+}
+interface PinchRecognizerStatic {
+    new (options?: RecognizerOptions): PinchRecognizer;
+}
+interface PinchRecognizer extends AttrRecognizer {
+}
+interface PressRecognizerStatic {
+    new (options?: RecognizerOptions): PressRecognizer;
+}
+interface PressRecognizer extends AttrRecognizer {
+}
+interface RotateRecognizerStatic {
+    new (options?: RecognizerOptions): RotateRecognizer;
+}
+interface RotateRecognizer extends AttrRecognizer {
+}
+interface SwipeRecognizerStatic {
+    new (options?: RecognizerOptions): SwipeRecognizer;
+}
+interface SwipeRecognizer extends AttrRecognizer {
+}
+interface TapRecognizerStatic {
+    new (options?: RecognizerOptions): TapRecognizer;
+}
+interface TapRecognizer extends AttrRecognizer {
+}
+declare class TouchAction {
+    constructor(manager: HammerManager, value: string);
+    compute(): string;
+    preventDefaults(input: HammerInput): void;
+    preventSrc(srcEvent: any): void;
+    set(value: string): void;
+    update(): void;
+}
+interface HammerPoint {
+    x: number;
+    y: number;
+}
+export {};