@endge/ui-vue 0.23.3

package/dist/throttle-Cpk1LoGk-5dM_0aHc.js

@@ -0,0 +1,183 @@
+import { g as h } from "./viewport.helpers-CoCAvmZs-f555rwPU.js";
+import { as as d, l as m } from "./main-CQv-nkoD.js";
+/*!
+ * Built by Revolist OU ❤️
+ */
+const c = {
+  contentSize: 0,
+  clientSize: 0,
+  virtualSize: 0,
+  maxSize: 0
+}, e = -1;
+function C(a, i, t = 0) {
+  return h({
+    contentSize: a,
+    clientSize: i,
+    virtualSize: t
+  }).physicalContentSize;
+}
+class v {
+  constructor(i) {
+    this.cfg = i, this.preventArtificialScroll = {
+      rgRow: null,
+      rgCol: null
+    }, this.previousScroll = {
+      rgRow: e,
+      rgCol: e
+    }, this.previousLogicalScroll = {
+      rgRow: 0,
+      rgCol: 0
+    }, this.params = {
+      rgRow: Object.assign({}, c),
+      rgCol: Object.assign({}, c)
+    };
+  }
+  setParams(i, t) {
+    const o = h(i), l = o.physicalContentSize;
+    this.params[t] = Object.assign(Object.assign({}, i), {
+      maxSize: l - i.clientSize,
+      virtualContentSize: l,
+      scrollDimension: o
+    });
+  }
+  // apply scroll values after scroll done
+  async setScroll(i) {
+    this.cancelScroll(i.dimension);
+    const t = new Promise((o, l) => {
+      if (this.cfg.skipAnimationFrame)
+        return o();
+      const r = window.requestAnimationFrame(() => {
+        o();
+      });
+      this.preventArtificialScroll[i.dimension] = l.bind(null, r);
+    });
+    try {
+      await t;
+      const o = this.getParams(i.dimension);
+      i.coordinate = Math.ceil(i.coordinate), this.previousLogicalScroll[i.dimension] = this.wrapLogicalCoordinate(i.coordinate, o);
+      const l = this.toPhysicalCoordinate(i.coordinate, o);
+      this.previousScroll[i.dimension] = this.wrapPhysicalCoordinate(l, o), this.preventArtificialScroll[i.dimension] = null, this.cfg.applyScroll(Object.assign(Object.assign({}, i), { coordinate: l }));
+    } catch (o) {
+      window.cancelAnimationFrame(o);
+    }
+  }
+  async setScrollByDelta(i, t) {
+    var o;
+    const l = this.getParams(i.dimension), r = this.previousScroll[i.dimension] === e ? this.toLogicalCoordinate(t, l) : this.previousLogicalScroll[i.dimension], s = this.wrapLogicalCoordinate(r + ((o = i.delta) !== null && o !== void 0 ? o : 0), l), n = Object.assign(Object.assign({}, i), { coordinate: s });
+    return await this.setScroll(n), n;
+  }
+  /**
+   * On scroll event started
+   */
+  scroll(i, t, o = !1, l, r = !1) {
+    if (this.cancelScroll(t), !o && this.previousScroll[t] === i) {
+      this.previousScroll[t] = e;
+      return;
+    }
+    const s = this.getParams(t), n = this.toLogicalScrollCoordinate(i, t, s, l);
+    this.cfg.runScroll({
+      dimension: t,
+      coordinate: n,
+      delta: l,
+      outside: r
+    }), this.previousLogicalScroll[t] = n;
+  }
+  getParams(i) {
+    return this.params[i];
+  }
+  // check if scroll outside of region to avoid looping
+  wrapPhysicalCoordinate(i, t) {
+    return i < 0 ? e : typeof t.maxSize == "number" && i > t.maxSize ? t.maxSize : i;
+  }
+  wrapLogicalCoordinate(i, t) {
+    var o, l;
+    return i < 0 ? 0 : Math.min(i, (l = (o = t.scrollDimension) === null || o === void 0 ? void 0 : o.logicalScrollSize) !== null && l !== void 0 ? l : i);
+  }
+  // prevent already started scroll, performance optimization
+  cancelScroll(i) {
+    var t, o;
+    (o = (t = this.preventArtificialScroll)[i]) === null || o === void 0 || o.call(t), this.preventArtificialScroll[i] = null;
+  }
+  toLogicalScrollCoordinate(i, t, o, l) {
+    const r = o.scrollDimension;
+    if (!r)
+      return i;
+    if (typeof l == "number" && r.isCompressed) {
+      const s = this.previousScroll[t] === e ? r.toLogicalCoordinate(i - l) : this.previousLogicalScroll[t];
+      return r.toLogicalCoordinate(r.toPhysicalCoordinate(s + l));
+    }
+    return r.toLogicalCoordinate(i);
+  }
+  toPhysicalCoordinate(i, t) {
+    var o, l;
+    return (l = (o = t.scrollDimension) === null || o === void 0 ? void 0 : o.toPhysicalCoordinate(i)) !== null && l !== void 0 ? l : i;
+  }
+  toLogicalCoordinate(i, t) {
+    var o, l;
+    return (l = (o = t.scrollDimension) === null || o === void 0 ? void 0 : o.toLogicalCoordinate(i)) !== null && l !== void 0 ? l : i;
+  }
+}
+class p {
+  constructor(i = 10) {
+    this.scrollThrottling = i, this.mouseWheelScrollTimestamp = {
+      rgCol: 0,
+      rgRow: 0
+    }, this.lastKnownScrollCoordinate = {
+      rgCol: 0,
+      rgRow: 0
+    }, this.lastScrollUpdateCallbacks = {};
+  }
+  setCoordinate(i) {
+    this.lastKnownScrollCoordinate[i.dimension] = i.coordinate;
+  }
+  setCoordinateFromScroll(i) {
+    this.setCoordinate(i), this.mouseWheelScrollTimestamp[i.dimension] = 0;
+  }
+  /**
+   * Remember last mw event time
+   */
+  latestScrollUpdate(i) {
+    this.mouseWheelScrollTimestamp[i] = (/* @__PURE__ */ new Date()).getTime();
+  }
+  isReady(i, t) {
+    return this.lastScrollUpdateCallbacks[i] && this.clearLastScrollUpdate(i), this.verifyChange(i, t);
+  }
+  verifyChange(i, t) {
+    return (/* @__PURE__ */ new Date()).getTime() - this.mouseWheelScrollTimestamp[i] > this.scrollThrottling && t !== this.lastKnownScrollCoordinate[i];
+  }
+  clearLastScrollUpdate(i) {
+    var t, o;
+    clearTimeout((o = (t = this.lastScrollUpdateCallbacks[i]) === null || t === void 0 ? void 0 : t.timeout) !== null && o !== void 0 ? o : 0), delete this.lastScrollUpdateCallbacks[i];
+  }
+  throttleLastScrollUpdate(i, t, o) {
+    if (this.scrollThrottling) {
+      this.clearLastScrollUpdate(i);
+      const l = this.lastScrollUpdateCallbacks[i] = {
+        callback: o,
+        timestamp: (/* @__PURE__ */ new Date()).getTime(),
+        coordinate: t,
+        timeout: 0
+      };
+      l.timeout = setTimeout(() => {
+        this.clearLastScrollUpdate(i), this.mouseWheelScrollTimestamp[i] < l.timestamp && this.verifyChange(i, l.coordinate) && l.callback();
+      }, this.scrollThrottling + 50);
+    }
+  }
+}
+var g = "Expected a function";
+function f(a, i, t) {
+  var o = !0, l = !0;
+  if (typeof a != "function")
+    throw new TypeError(g);
+  return d(t) && (o = "leading" in t ? !!t.leading : o, l = "trailing" in t ? !!t.trailing : l), m(a, i, {
+    leading: o,
+    maxWait: i,
+    trailing: l
+  });
+}
+export {
+  p as L,
+  v as a,
+  C as g,
+  f as t
+};

package/dist/ui/filter/EndgeFilterControlRenderer.d.ts

@@ -0,0 +1,33 @@
+import { FilterViewRenderField, SourceFieldOption } from '@endge/core';
+import { PropType } from 'vue';
+/** Делегирует один semantic control активному Vue adapter-у. */
+export declare const EndgeFilterControlRenderer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    field: {
+        type: PropType<FilterViewRenderField>;
+        required: true;
+    };
+    options: {
+        type: PropType<SourceFieldOption[]>;
+        default: () => never[];
+    };
+    readonly: BooleanConstructor;
+    label: StringConstructor;
+}>, () => import('../../domain/types/sfc-render.type').SFCVueRenderResult, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    'update:value': (_value: unknown) => true;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    field: {
+        type: PropType<FilterViewRenderField>;
+        required: true;
+    };
+    options: {
+        type: PropType<SourceFieldOption[]>;
+        default: () => never[];
+    };
+    readonly: BooleanConstructor;
+    label: StringConstructor;
+}>> & Readonly<{
+    "onUpdate:value"?: ((_value: unknown) => any) | undefined;
+}>, {
+    readonly: boolean;
+    options: SourceFieldOption[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/ui/filter/EndgeFilterField.vue.d.ts

@@ -0,0 +1,13 @@
+import { FilterViewRenderField } from '@endge/core';
+type __VLS_Props = {
+    field: FilterViewRenderField;
+    label?: string;
+    showLabel?: boolean;
+    readonly?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:value": (value: unknown) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:value"?: ((value: unknown) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/ui/filter/EndgeFilterRenderer.vue.d.ts

@@ -0,0 +1,3 @@
+import { EndgeFilterRendererProps } from '../../domain/types/filter-renderer.type';
+declare const _default: import('vue').DefineComponent<EndgeFilterRendererProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<EndgeFilterRendererProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/ui/filter/index.d.ts

@@ -0,0 +1,2 @@
+export { default as EndgeFilterField } from './EndgeFilterField.vue';
+export { default as EndgeFilterRenderer } from './EndgeFilterRenderer.vue';

package/dist/ui/layout/EndgeShell.vue.d.ts

@@ -0,0 +1,22 @@
+import { EndgeEnvId, EndgeProjectId } from '@endge/core';
+interface Props {
+    project: EndgeProjectId;
+    env: EndgeEnvId;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/ui/overlay/EndgeContextMenuRoot.vue.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    menuRef: HTMLDivElement;
+}, any>;
+export default _default;

package/dist/ui/overlay/context-menu-manager.d.ts

@@ -0,0 +1,46 @@
+import { ContextMenuDescriptor, ContextMenuItemDescriptor, ContextMenuNodeDescriptor, RuntimeActionContext } from '@endge/core';
+export interface EndgeContextMenuOpenInput<TContext extends RuntimeActionContext = RuntimeActionContext> {
+    ownerId: string;
+    x: number;
+    y: number;
+    menu: ContextMenuDescriptor;
+    context: TContext;
+}
+export interface EndgeContextMenuState {
+    open: boolean;
+    ownerId: string | null;
+    x: number;
+    y: number;
+    menu: ContextMenuDescriptor | null;
+    context: RuntimeActionContext | null;
+}
+export declare const endgeContextMenuState: {
+    open: boolean;
+    ownerId: string | null;
+    x: number;
+    y: number;
+    menu: {
+        kind: "context-menu";
+        items: ({
+            kind: "item";
+            id: string;
+            label: string;
+            action: import('@endge/core').RuntimeActionId;
+            input?: unknown;
+            icon?: string | undefined;
+        } | {
+            kind: "separator";
+            id: string;
+        })[];
+    } | null;
+    context: {
+        surface: import('@endge/core').RuntimeActionSurface;
+        runtimeId?: string | undefined;
+        target?: unknown;
+    } | null;
+};
+export declare function openEndgeContextMenu(input: EndgeContextMenuOpenInput): void;
+export declare function closeEndgeContextMenu(ownerId?: string): void;
+export declare function getExecutableContextMenuItems(): ContextMenuNodeDescriptor[];
+export declare function executeEndgeContextMenuItem(item: ContextMenuItemDescriptor): Promise<void>;
+export declare function resolveEndgeContextMenuItemLabel(item: ContextMenuItemDescriptor): string;