@dxtmisha/constructor 0.23.0 → 0.39.3

package/dist/constructors/Window/WindowVerification.d.ts

@@ -0,0 +1,126 @@
+import { WindowPersistent } from './WindowPersistent';
+import { WindowClasses } from './WindowClasses';
+import { WindowElement } from './WindowElement';
+import { WindowStatic } from './WindowStatic';
+import { WindowOpen } from './WindowOpen';
+import { WindowProps } from './props';
+/**
+ * Class for managing the opening and closing of the window.
+ *
+ * Класс для управления открытием и закрытием окна.
+ */
+export declare class WindowVerification {
+    protected readonly props: WindowProps;
+    protected readonly persistent: WindowPersistent;
+    protected readonly classes: WindowClasses;
+    protected readonly element: WindowElement;
+    protected readonly staticMode: WindowStatic;
+    protected readonly open: WindowOpen;
+    protected target?: HTMLElement;
+    protected focus?: HTMLElement;
+    /**
+     * Constructor
+     * @param props input data/ входные данные
+     * @param persistent object for working with the animation before turning off the window/ объект для работы с анимацией перед выключением окна
+     * @param classes an object for working with classes and searching for elements/ объект для работы с классами и поиском элементов
+     * @param element an object of the class for working with elements/ объект класса для работы с элементами
+     * @param staticMode class object for working with static status/ объект класса для работы со статическим статусом
+     * @param open the class object for working with the status of closing or opening the window/ объект класса для работы со статусом закрытия или открытия окна
+     */
+    constructor(props: WindowProps, persistent: WindowPersistent, classes: WindowClasses, element: WindowElement, staticMode: WindowStatic, open: WindowOpen);
+    /**
+     * Updates the window opening status.
+     *
+     * Обновления статус открытия окно.
+     * @param target the selected window/ выбранное окно
+     */
+    update(target: HTMLElement): Promise<void>;
+    /**
+     * Returns the element in focus.
+     *
+     * Возвращает элемент в фокусе.
+     */
+    getFocus(): HTMLElement | undefined;
+    protected getTarget<R extends HTMLElement>(): R;
+    /**
+     * Checks if the selected element is in focus.
+     *
+     * Проверяет, находится ли выбранный элемент в фокусе.
+     */
+    protected isFocus(): boolean;
+    /**
+     * Checks if the target element is the window itself.
+     *
+     * Проверяет, является ли элемент-цель самим окном.
+     */
+    protected isTarget(): boolean;
+    protected isTargetInBody(): boolean;
+    /**
+     * Checks if the selected window is under other windows.
+     *
+     * Проверяет, находится ли выбранное окно под другими окнами.
+     * @param target the selected window/ выбранное окно
+     */
+    protected isChildren(target?: HTMLElement): boolean;
+    /**
+     * Checks if the window is enabled or if the conditions for opening the window are met.
+     *
+     * Проверяет, включено ли окно или подходят ли условия для открытия окна.
+     */
+    protected isEnabled(): boolean;
+    /**
+     * Checks if the window needs to be closed automatically.
+     *
+     * Проверяет, нужно ли автоматически закрывать окно.
+     */
+    protected isAutoClose(): boolean;
+    /**
+     * Checks if the change of the opening status of the window is blocked.
+     *
+     * Проверяет, заблокировано ли изменение статуса открытия окна.
+     */
+    protected isNotBlock(): boolean;
+    /**
+     * Checks if the change of the opening status of the window is blocked.
+     *
+     * Проверяет, заблокировано ли изменение статуса открытия окна.
+     * @param item element for testing/ элемент для проверки
+     */
+    protected isNotBlockItem(item?: HTMLElement): boolean;
+    /**
+     * Checks if there is an element with a close lock.
+     *
+     * Проверяет, есть ли элемент с блокировкой закрытия.
+     */
+    protected isNotBlockChildren(): boolean;
+    /**
+     * Checks if there is a blocking element from other windows.
+     *
+     * Проверяет, есть ли блокирующий элемент от других окон.
+     */
+    protected isBlockOther(): boolean;
+    /**
+     * Checks if it needs to be opened when the right button is pressed.
+     *
+     * Проверяет, нужно ли открывать при нажатии правой кнопки.
+     */
+    protected isContextmenu(): boolean;
+    /**
+     * Checks if the window can be closed.
+     *
+     * Проверяет, можно ли закрыть окно.
+     */
+    protected isClose(): boolean;
+    /**
+     * Checks if the element is a menu.
+     *
+     * Проверяет, является ли элемент меню.
+     */
+    protected isMenu(element?: HTMLElement | undefined): boolean;
+    /**
+     * Checks if the element should only open.
+     *
+     * Проверяет, должен ли элемент только открываться.
+     */
+    protected isOpenOnly(): boolean;
+}

package/dist/constructors/Window/basicTypes.d.ts

@@ -0,0 +1,173 @@
+import { ComputedRef, Ref } from 'vue';
+import { ConstrBind } from '@dxtmisha/functional';
+import { AriaList } from '../../types/ariaTypes';
+import { WindowExpose } from './types';
+import { WindowPropsBasic } from './props';
+/**
+ * Window status items for different states of window lifecycle/
+ * Элементы статуса окна для различных состояний жизненного цикла окна
+ */
+export declare enum WindowStatusItem {
+    /** Display state/ Состояние отображения */
+    display = "display",
+    /** Preparation state/ Состояние подготовки */
+    preparation = "preparation",
+    /** Flash state/ Состояние вспышки */
+    flash = "flash",
+    /** Open state/ Состояние открытия */
+    open = "open",
+    /** Hide state/ Состояние скрытия */
+    hide = "hide",
+    /** Close state/ Состояние закрытия */
+    close = "close"
+}
+/**
+ * Window status control items for managing window behavior and appearance/
+ * Элементы управления статусом окна для управления поведением и внешним видом окна
+ */
+export declare enum WindowStatusControlItem {
+    /** Block interaction/ Блокировка взаимодействия */
+    block = "block",
+    /**
+     * Block window closing, class added to elements inside window/
+     * Блокировка закрытия окна, класс добавляется к элементам внутри окна
+     */
+    blockChildren = "blockChildren",
+    /** Block other windows/ Блокировка других окон */
+    blockOther = "blockOther",
+    /** Close window/ Закрыть окно */
+    close = "close",
+    /** Static positioning/ Статическое позиционирование */
+    static = "static",
+    /** Static control/ Статическое управление */
+    controlStatic = "controlStatic",
+    /** Control only when open/ Управление только когда открыто */
+    controlOpenOnly = "controlOpenOnly",
+    /** Active control/ Активное управление */
+    controlActive = "controlActive",
+    /** Persistent window/ Постоянное окно */
+    persistent = "persistent"
+}
+/**
+ * Options for window events/
+ * Опции для событий окна
+ */
+export type WindowEmitOptions = {
+    /** Unique window identifier/ Уникальный идентификатор окна */
+    id: string;
+    /** Window DOM element/ DOM элемент окна */
+    element: HTMLDivElement;
+    /** Control DOM element/ DOM элемент управления */
+    control: HTMLElement;
+    /** Window open state/ Состояние открытия окна */
+    open: boolean;
+};
+/**
+ * List of CSS classes for window styling/
+ * Список CSS классов для стилизации окна
+ */
+export type WindowClassesList = {
+    /** Main block class/ Основной класс блока */
+    block: string;
+    /** Block children class/ Класс дочерних элементов блока */
+    blockChildren: string;
+    /** Block other windows class/ Класс блокировки других окон */
+    blockOther: string;
+    /** Close button class/ Класс кнопки закрытия */
+    close: string;
+    /** Static positioning class/ Класс статического позиционирования */
+    static: string;
+    /** Control element class/ Класс элемента управления */
+    control: string;
+    /** Control ID class/ Класс ID управления */
+    controlId: string;
+    /** Static control class/ Класс статического управления */
+    controlStatic: string;
+    /** Open-only control class/ Класс управления только для открытого состояния */
+    controlOpenOnly: string;
+    /** Active control class/ Класс активного управления */
+    controlActive: string;
+    /** Persistent window class/ Класс постоянного окна */
+    persistent: string;
+};
+/**
+ * Window event click handler/
+ * Обработчик события клика окна
+ */
+export type WindowEventClick = (event: MouseEvent & TouchEvent) => Promise<void>;
+/**
+ * Interface for window classes inclusion/
+ * Интерфейс для включения классов окна
+ */
+export type WindowControlBasic = {
+    /** Window CSS classes list/ Список CSS классов окна */
+    classesWindow: WindowClassesList;
+};
+/**
+ * Control item data for window management/
+ * Данные элемента управления для управления окном
+ */
+export type WindowControlItem = WindowControlBasic & {
+    /** CSS class string/ Строка CSS класса */
+    class: string;
+    /** Reactive open state/ Реактивное состояние открытия */
+    open: Ref<boolean>;
+    /** Click event handler/ Обработчик события клика */
+    onclick: WindowEventClick;
+    /** Context menu event handler/ Обработчик события контекстного меню */
+    oncontextmenu: WindowEventClick;
+    /** Binding properties/ Свойства привязки */
+    binds: AriaList & {
+        /** Binding class/ Класс привязки */
+        class: string;
+        /** Click event handler for binding/ Обработчик события клика для привязки */
+        onclick: WindowEventClick;
+        /** Context menu event handler for binding/ Обработчик события контекстного меню для привязки */
+        oncontextmenu: WindowEventClick;
+    };
+};
+/**
+ * Component map for including the Window component/
+ * Карта компонентов для подключения компонента Window
+ */
+export type WindowComponentInclude = {
+    window?: object;
+};
+/**
+ * Event map for Window include/
+ * Карта событий для подключения Window
+ */
+export type WindowEmitsInclude = {
+    window: [options: WindowEmitOptions];
+};
+/**
+ * Interface for window expose inclusion/
+ * Интерфейс для включения expose окна
+ */
+export interface WindowExposeInclude {
+    id: ComputedRef<string | undefined>;
+    open: ComputedRef<boolean>;
+    control: ComputedRef<WindowControlItem | undefined>;
+    setOpen: WindowExpose['setOpen'];
+    toOpen: WindowExpose['toOpen'];
+    toClose: WindowExpose['toClose'];
+    toggle: WindowExpose['toggle'];
+    windowElement: Ref<ConstrBind<WindowExpose> | undefined>;
+}
+/**
+ * Props used to include and configure the Window component/
+ * Свойства для подключения и настройки компонента Window
+ */
+export interface WindowPropsInclude<Window extends WindowPropsBasic = WindowPropsBasic> {
+    /** Disabled state/ Отключённое состояние */
+    disabled?: boolean;
+    /** Enable auto close on outside click/ Включить авто-закрытие при клике вне */
+    autoClose?: boolean;
+    /** Additional attributes for Window component/ Дополнительные атрибуты для компонента Window */
+    windowAttrs?: ConstrBind<Window>;
+}
+/**
+ * CSS variable name for MotionTransform body type/
+ * Имя CSS‑переменной для типа тела MotionTransform
+ */
+export declare const __WINDOW_TYPE_BODY_NAME = "--sys-type-body";

package/dist/constructors/Window/index.d.ts

@@ -0,0 +1,7 @@
+export * from './Window';
+export * from './WindowDesign';
+export * from './WindowInclude';
+export * from './WindowClassesInclude';
+export * from './props';
+export type * from './types';
+export type * from './basicTypes';

package/dist/constructors/Window/props.d.ts

@@ -0,0 +1,64 @@
+import { ElementOrString, NormalOrPromise } from '@dxtmisha/functional';
+import { AriaByPropsInclude, AriaHaspopupPropsInclude, AriaRoleByPropsInclude } from '../../types/ariaTypes';
+import { ImagePropsBasic, ImagePropsInclude } from '../Image';
+import { ScrollbarPropsBasic, ScrollbarPropsInclude } from '../Scrollbar';
+import { TextClosePropsInclude } from '../../types/textTypes';
+interface WindowPropsToken {
+    width?: string | 'auto' | 'max' | 'custom';
+    height?: string | 'auto' | 'max' | 'custom';
+    hide?: boolean;
+    axis?: 'x' | 'y' | 'on';
+    imagePosition?: 'top' | 'left';
+    dense?: boolean;
+    alignment?: 'center' | 'top' | 'topRight' | 'topLeft' | 'topFull' | 'right' | 'rightFull' | 'bottom' | 'bottomRight' | 'bottomLeft' | 'bottomFull' | 'left' | 'leftFull';
+    origin?: 'center' | 'top' | 'right' | 'bottom' | 'left' | 'topToBottom' | 'rightToLeft' | 'bottomToTop' | 'leftToRight';
+    adaptive?: 'menu' | 'menuWindow' | 'modal' | 'modalDynamic' | 'actionSheetRight' | 'actionSheetBottom' | 'static';
+    fullscreen?: boolean;
+    overscroll?: boolean;
+    closeMobileHide?: boolean;
+    widthMatch?: boolean;
+}
+export interface WindowPropsBasic<Scrollbar extends ScrollbarPropsBasic = ScrollbarPropsBasic, Image extends ImagePropsBasic = ImagePropsBasic> extends ScrollbarPropsInclude<Scrollbar>, ImagePropsInclude<Image>, AriaRoleByPropsInclude, AriaByPropsInclude, AriaHaspopupPropsInclude, TextClosePropsInclude {
+    'open'?: boolean;
+    'disabled'?: boolean;
+    'preparation'?(): NormalOrPromise<void>;
+    'beforeOpening'?(): NormalOrPromise<boolean>;
+    'opening'?(): NormalOrPromise<boolean>;
+    'beforeClosing'?(): NormalOrPromise<boolean>;
+    'closing'?(): NormalOrPromise<boolean>;
+    'contextmenu'?: boolean;
+    'staticMode'?: boolean;
+    'overElement'?: ElementOrString<HTMLElement>;
+    'autoClose'?: boolean;
+    'persistent'?: boolean;
+    'flash'?: boolean;
+    'inDom'?: boolean;
+    'indent'?: number;
+    'divider'?: boolean;
+    'closeButton'?: boolean;
+    'iconClose'?: string;
+    'modelOpen'?: boolean;
+    'onUpdate:open'?: (value: boolean) => void;
+    'onUpdate:modelOpen'?: (value: boolean) => void;
+}
+/**
+ * Type describing incoming properties.
+ *
+ * Тип, описывающий входящие свойства.
+ */
+export interface WindowProps extends WindowPropsBasic, WindowPropsToken {
+}
+/**
+ * Default value for property.
+ *
+ * Значение по умолчанию для свойства.
+ */
+export declare const defaultsWindow: {
+    axis: string;
+    imagePosition: string;
+    overscroll: boolean;
+    indent: number;
+    ariaHaspopup: string;
+    role: string;
+};
+export {};

package/dist/constructors/Window/types.d.ts

@@ -0,0 +1,100 @@
+import { ComputedRef, Ref } from 'vue';
+import { ConstrClass } from '@dxtmisha/functional';
+import { ScrollbarComponentsInclude, ScrollbarEmitsInclude } from '../Scrollbar';
+import { ButtonComponentInclude } from '../Button';
+import { ImageComponentsInclude, ImageEmitsInclude } from '../Image';
+import { WindowControlItem, WindowEmitOptions } from './basicTypes';
+/**
+ * Interface for describing which components need to be connected for work.
+ *
+ * Интерфейс для описания, какие компоненты надо подключить для работы.
+ */
+export type WindowComponents = ScrollbarComponentsInclude & ButtonComponentInclude & ImageComponentsInclude;
+/**
+ * Type describing available events.
+ *
+ * Тип, описывающий доступные события.
+ */
+export type WindowEmits = ScrollbarEmitsInclude & ImageEmitsInclude & {
+    'window': [options: WindowEmitOptions];
+    'update:open': [value: boolean];
+    'update:modelOpen': [value: boolean];
+};
+/**
+ * Type describing available properties.
+ *
+ * Тип, описывающий доступные свойства.
+ */
+export interface WindowExpose {
+    /**
+     * Unique identifier of the window/
+     * Уникальный идентификатор окна
+     */
+    id: string;
+    /**
+     * Reactive state of window visibility/
+     * Реактивное состояние видимости окна
+     */
+    open: Ref<boolean>;
+    /**
+     * Control item data for window management/
+     * Данные элемента управления для управления окном
+     */
+    control: ComputedRef<WindowControlItem>;
+    /**
+     * Sets window open state/
+     * Устанавливает состояние открытия окна
+     */
+    setOpen(open: boolean): Promise<void>;
+    /** Transition to opening state/ Переход в состояние открытия */
+    toOpen(): Promise<void>;
+    /** Transition to closing state/ Переход в состояние закрытия */
+    toClose(): Promise<void>;
+    /**
+     * Toggles window visibility/
+     * Переключает видимость окна
+     */
+    toggle(): Promise<void>;
+}
+/**
+ * Type describing available slots.
+ *
+ * Тип, описывающий доступные слоты.
+ */
+export interface WindowSlots {
+    /**
+     * Control slot for window management/
+     * Слот управления для управления окном
+     */
+    control?(props: WindowControlItem): any;
+    /**
+     * Title slot for window header/
+     * Слот заголовка для шапки окна
+     */
+    title?(props: WindowControlItem): any;
+    /**
+     * Footer slot for window bottom/
+     * Слот подвала для низа окна
+     */
+    footer?(props: WindowControlItem): any;
+    /**
+     * Default slot for main content/
+     * Основной слот для главного содержимого
+     */
+    default?(props: WindowControlItem): any;
+}
+/**
+ * Type describing subclasses.
+ *
+ * Тип, описывающий подклассы.
+ */
+export type WindowClasses = {
+    main: ConstrClass;
+    body: string;
+    bodyGroup: string;
+    bodyContext: string;
+    control: string;
+    image: string;
+    close: string;
+    teleport: string;
+};

package/dist/dialog.js

@@ -0,0 +1,211 @@
+var g = Object.defineProperty;
+var f = (s, e, t) => e in s ? g(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var i = (s, e, t) => f(s, typeof e != "symbol" ? e + "" : e, t);
+import { computed as d, readonly as p, h as C } from "vue";
+import { getBind as b, toBinds as w } from "@dxtmisha/functional";
+import { L as v } from "./LabelInclude-BtZrrbCf.js";
+import { D as k } from "./DescriptionInclude-DxWNon_J.js";
+import { T as I } from "./TextInclude-i1OBAFTG.js";
+import { M as S, a as x } from "./ModalDesignAbstract-CjDr5JaN.js";
+import { I as D } from "./IconInclude-CLqwI29Q.js";
+import { W as A } from "./WindowClassesInclude-B56usxgx.js";
+class B extends S {
+  /**
+   * Constructor
+   * @param props input data/ входные данные
+   * @param refs input data in the form of reactive elements/ входные данные в виде реактивных элементов
+   * @param element input element/ элемент ввода
+   * @param classDesign design name/ название дизайна
+   * @param className class name/ название класса
+   * @param components object for working with components/ объект для работы с компонентами
+   * @param slots object for working with slots/ объект для работы со слотами
+   * @param emits the function is called when an event is triggered/ функция вызывается, когда срабатывает событие
+   */
+  constructor(t, l, u, a, o, h, r, m) {
+    super(
+      t,
+      l,
+      u,
+      a,
+      o,
+      h,
+      r,
+      m,
+      d(() => ({
+        open: t.open,
+        image: t.image,
+        adaptive: "modal",
+        imagePosition: t.imagePosition,
+        closeButton: this.props.closeButton
+      })),
+      void 0,
+      d(() => {
+        const c = [];
+        return t.buttonClose !== null && c.push(
+          b(
+            t.buttonClose,
+            {
+              label: this.text.close.value,
+              value: "close",
+              class: this.windowClasses.get().close,
+              onClick: () => {
+                var n;
+                return (n = this.emits) == null ? void 0 : n.call(this, "close");
+              }
+            },
+            "label",
+            !0
+          )
+        ), t.buttonOk !== null && c.push(
+          b(
+            t.buttonOk,
+            {
+              label: this.text.ok.value,
+              value: "ok",
+              class: this.props.clickOkAndClose ? this.windowClasses.get().close : void 0,
+              onClick: () => {
+                var n;
+                return (n = this.emits) == null ? void 0 : n.call(this, "ok");
+              }
+            },
+            "label",
+            !0
+          )
+        ), {
+          list: c,
+          align: "center"
+        };
+      })
+    );
+    i(this, "icon");
+    i(this, "label");
+    i(this, "description");
+    i(this, "windowClasses");
+    i(this, "text");
+    /**
+     * Returns the icon for display.
+     *
+     * Возвращает иконку для отображения.
+     */
+    i(this, "iconValue", d(() => this.props.success ? this.props.iconSuccess : this.props.error ? this.props.iconError : this.props.icon));
+    this.props = t, this.refs = l, this.element = u, this.classDesign = a, this.className = o, this.components = h, this.slots = r, this.emits = m, this.icon = new D(
+      p({ icon: this.iconValue }),
+      o,
+      h,
+      l.iconAttrs
+    ), this.label = new v(
+      t,
+      o,
+      void 0,
+      r,
+      void 0,
+      void 0,
+      !0
+    ), this.description = new k(t, o, r), this.windowClasses = new A(a), this.text = new I(this.props);
+  }
+}
+const E = {
+  barsBackHide: !0,
+  barsHide: !0,
+  clickOkAndClose: !0,
+  // :default [!] System label / Системная метка
+  imagePosition: "top"
+};
+class F extends x {
+  constructor() {
+    super(...arguments);
+    /**
+     * Render for the body layer.
+     *
+     * Рендер для слоя тела.
+     * @param props data for window management/ данные для управления окном
+     */
+    i(this, "renderContent", (t) => [
+      ...this.renderInformation(),
+      ...this.renderDefault(t)
+    ]);
+    /**
+     * Render information block.
+     *
+     * Рендер информационного блока.
+     */
+    i(this, "renderInformation", () => {
+      var t;
+      return [
+        C(
+          "div",
+          { class: (t = this.classes) == null ? void 0 : t.value.information },
+          [
+            ...this.item.icon.renderIcon(),
+            ...this.item.label.render(),
+            ...this.item.description.render()
+          ]
+        )
+      ];
+    });
+  }
+  /**
+   * A method for creating an instance of the class.
+   *
+   * Метод для создания экземпляра класса.
+   */
+  initItem() {
+    return new B(
+      this.props,
+      this.refs,
+      this.element,
+      this.getDesign(),
+      this.getName(),
+      this.components,
+      this.slots,
+      this.emits
+    );
+  }
+  /**
+   * Improvement of the obtained list of classes.
+   *
+   * Доработка полученного списка классов.
+   */
+  initClasses() {
+    return {
+      main: {},
+      // :classes [!] System label / Системная метка
+      title: this.getSubClass("title"),
+      header: this.getSubClass("header"),
+      information: this.getSubClass("information"),
+      icon: this.getSubClass("icon"),
+      label: this.getSubClass("label"),
+      description: this.getSubClass("description"),
+      body: this.getSubClass("body"),
+      footer: this.getSubClass("footer")
+    };
+  }
+  /**
+   * A method for rendering.
+   *
+   * Метод для рендеринга.
+   */
+  initRender() {
+    var t;
+    return this.item.window.render(
+      {
+        control: this.renderControl,
+        title: this.renderTitle,
+        default: this.renderContent,
+        footer: this.renderFooter
+      },
+      w(
+        {
+          class: (t = this.classes) == null ? void 0 : t.value.main,
+          "data-touch": "touch"
+        },
+        this.getAttrs()
+      )
+    );
+  }
+}
+export {
+  B as Dialog,
+  F as DialogDesign,
+  E as defaultsDialog
+};