@agrotools1/at-components 0.2.5 → 0.2.8-5

package/dist/Search/test.mocks.d.ts

@@ -1,3 +1,3 @@
-import type { DropdownListItem } from "../Dropdown/List/Dropdown.list";
+import type { DropdownListItem } from "../Dropdown/List/Dropdown.List";
 declare const autoCompleteListMock: DropdownListItem[];
 export { autoCompleteListMock };

package/dist/Search/utils.d.ts

@@ -1,3 +1,3 @@
-import type { DropdownListItem } from "../Dropdown/List/Dropdown.list";
+import type { DropdownListItem } from "../Dropdown/List/Dropdown.List";
 declare function filterAutoCompleteList(autoCompleteList: DropdownListItem[] | undefined, value: string): DropdownListItem[] | undefined;
 export { filterAutoCompleteList };

package/dist/Select/Item/Item.d.ts

@@ -0,0 +1,104 @@
+export interface CheckboxProps extends MouseEvent {
+    value: boolean;
+    isChecked: boolean;
+    item: {
+        text: string;
+        value: string;
+    };
+}
+export interface SelectItemProps {
+    text: string;
+    value: string;
+    onClick?: (payload: MouseEvent) => void;
+    onCheckboxChange?: (payload: CheckboxProps) => void;
+    checkboxValue?: boolean;
+    isSelected?: boolean;
+    type?: "text" | "multiple" | "with-icon";
+    icon?: string;
+}
+declare const _default: import("vue").DefineComponent<{
+    text: {
+        type: StringConstructor;
+        required: true;
+        validator: (value: string) => boolean;
+    };
+    value: {
+        type: StringConstructor;
+        required: true;
+        validator: (value: string) => boolean;
+    };
+    onClick: {
+        default: () => void;
+        type: () => (payload: MouseEvent) => void;
+        required: false;
+        validator: (value: (payload: MouseEvent) => void) => boolean;
+    };
+    onCheckboxChange: {
+        default: () => void;
+        type: () => (payload: CheckboxProps) => void;
+        required: false;
+        validator: (value: (payload: MouseEvent) => void) => boolean;
+    };
+    checkboxValue: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: boolean) => boolean;
+    };
+    type: {
+        type: () => SelectItemProps["type"];
+        default: string;
+        validator: (value: SelectItemProps["type"]) => boolean;
+    };
+    icon: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+}, {
+    checkboxRef: import("vue").Ref<null>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    text: {
+        type: StringConstructor;
+        required: true;
+        validator: (value: string) => boolean;
+    };
+    value: {
+        type: StringConstructor;
+        required: true;
+        validator: (value: string) => boolean;
+    };
+    onClick: {
+        default: () => void;
+        type: () => (payload: MouseEvent) => void;
+        required: false;
+        validator: (value: (payload: MouseEvent) => void) => boolean;
+    };
+    onCheckboxChange: {
+        default: () => void;
+        type: () => (payload: CheckboxProps) => void;
+        required: false;
+        validator: (value: (payload: MouseEvent) => void) => boolean;
+    };
+    checkboxValue: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: boolean) => boolean;
+    };
+    type: {
+        type: () => SelectItemProps["type"];
+        default: string;
+        validator: (value: SelectItemProps["type"]) => boolean;
+    };
+    icon: {
+        type: StringConstructor;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+}>>, {
+    type: "text" | "multiple" | "with-icon" | undefined;
+    onClick: (payload: MouseEvent) => void;
+    icon: string;
+    onCheckboxChange: (payload: CheckboxProps) => void;
+    checkboxValue: boolean;
+}, {}>;
+export default _default;

package/dist/Select/Multiple/Select.multiple.d.ts

@@ -0,0 +1,101 @@
+import type { PropType } from "vue";
+import type { SelectItemProps } from "../Item/Item";
+import type { SelectCoreProps } from "../Select.core";
+export interface SelectMultipleProps extends SelectCoreProps {
+}
+declare const _default: import("vue").DefineComponent<{
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    modelValue: {
+        type: PropType<string[] | SelectItemProps[]>;
+        default: () => SelectItemProps[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    emitValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    items: {
+        type: () => Array<SelectItemProps>;
+        default: () => SelectItemProps[];
+        validator: (value: Array<SelectItemProps>) => boolean;
+    };
+    separator: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {
+    onSelectedValueChange: (item: SelectItemProps, isChecked: boolean) => void;
+    onSelectedItemClick: (selectedValue: string, isOpen?: boolean) => void;
+    rotateIcon: () => void;
+    myItems: import("vue").Ref<{
+        text: string;
+        value: string;
+        onClick?: ((payload: MouseEvent) => void) | undefined;
+        onCheckboxChange?: ((payload: import("../Item/Item").CheckboxProps) => void) | undefined;
+        checkboxValue?: boolean | undefined;
+        isSelected?: boolean | undefined;
+        type?: "text" | "multiple" | "with-icon" | undefined;
+        icon?: string | undefined;
+    }[]>;
+    values: import("vue").ComputedRef<string>;
+    selectedValues: import("vue").Ref<{
+        text: string;
+        value: string;
+        onClick?: ((payload: MouseEvent) => void) | undefined;
+        onCheckboxChange?: ((payload: import("../Item/Item").CheckboxProps) => void) | undefined;
+        checkboxValue?: boolean | undefined;
+        isSelected?: boolean | undefined;
+        type?: "text" | "multiple" | "with-icon" | undefined;
+        icon?: string | undefined;
+    }[]>;
+    isInternalChange: import("vue").Ref<boolean>;
+    isOpen: import("vue").Ref<boolean>;
+    containerRef: import("vue").Ref<HTMLDivElement | null>;
+    icons: {
+        indicatorSvg: string;
+    };
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "update:items" | "update:selectedItems")[], "update:modelValue" | "update:items" | "update:selectedItems", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    modelValue: {
+        type: PropType<string[] | SelectItemProps[]>;
+        default: () => SelectItemProps[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    emitValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    items: {
+        type: () => Array<SelectItemProps>;
+        default: () => SelectItemProps[];
+        validator: (value: Array<SelectItemProps>) => boolean;
+    };
+    separator: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:items"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:selectedItems"?: ((...args: any[]) => any) | undefined;
+}, {
+    label: string;
+    disabled: boolean;
+    modelValue: string[] | SelectItemProps[];
+    separator: string;
+    items: SelectItemProps[];
+    emitValue: boolean;
+}, {}>;
+export default _default;

package/dist/Select/Select.core.d.ts

@@ -0,0 +1,87 @@
+import { type PropType } from "vue";
+import { type SelectItemProps } from "./Item/Item";
+export interface SelectCoreProps {
+    defaultValue: string | null;
+    label: string;
+    items: Array<SelectItemProps>;
+    selectedItems?: Array<SelectItemProps>;
+    separator?: string;
+    onSelectedItemClick: (separatedValue: string) => void;
+}
+declare const _default: import("vue").DefineComponent<{
+    value: {
+        type: PropType<string | SelectItemProps>;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    items: {
+        type: () => Array<SelectItemProps>;
+    };
+    separator: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectedItems: {
+        type: () => Array<SelectItemProps>;
+        default: () => SelectItemProps[];
+    };
+    onSelectedItemClick: {
+        type: () => (separatedValue: string) => void;
+        required: false;
+    };
+    isMultiple: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}, {
+    id: string;
+    handleValue: () => string | undefined;
+    atInput: import("vue").Ref<null>;
+    inputModelValue: import("vue").Ref<string>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: PropType<string | SelectItemProps>;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    items: {
+        type: () => Array<SelectItemProps>;
+    };
+    separator: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectedItems: {
+        type: () => Array<SelectItemProps>;
+        default: () => SelectItemProps[];
+    };
+    onSelectedItemClick: {
+        type: () => (separatedValue: string) => void;
+        required: false;
+    };
+    isMultiple: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}>>, {
+    label: string;
+    disabled: boolean;
+    separator: string;
+    isMultiple: boolean;
+    selectedItems: SelectItemProps[];
+}, {}>;
+export default _default;

package/dist/Select/Single/Select.single.d.ts

@@ -0,0 +1,68 @@
+import { type PropType } from "vue";
+import type { SelectItemProps } from "../Item/Item";
+import type { SelectCoreProps } from "../Select.core";
+export interface SelectSingleProps extends SelectCoreProps {
+}
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: PropType<string | SelectItemProps>;
+        required: false;
+        default: string;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    items: {
+        type: () => Array<SelectItemProps>;
+        default: () => SelectItemProps[];
+        validator: (value: Array<SelectItemProps>) => boolean;
+    };
+    emitValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    onSelectedValueChange: (item: SelectItemProps) => void;
+    selectedValue: import("vue").Ref<string | {
+        text: string;
+        value: string;
+        onClick?: ((payload: MouseEvent) => void) | undefined;
+        onCheckboxChange?: ((payload: import("../Item/Item").CheckboxProps) => void) | undefined;
+        checkboxValue?: boolean | undefined;
+        isSelected?: boolean | undefined;
+        type?: "text" | "multiple" | "with-icon" | undefined;
+        icon?: string | undefined;
+    }>;
+    open: import("vue").Ref<boolean>;
+    valueOfModel: import("vue").ComputedRef<string>;
+    containerRef: import("vue").Ref<HTMLDivElement | null>;
+    rotateIcon: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: PropType<string | SelectItemProps>;
+        required: false;
+        default: string;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    items: {
+        type: () => Array<SelectItemProps>;
+        default: () => SelectItemProps[];
+        validator: (value: Array<SelectItemProps>) => boolean;
+    };
+    emitValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}, {
+    label: string;
+    modelValue: string | SelectItemProps;
+    items: SelectItemProps[];
+    emitValue: boolean;
+}, {}>;
+export default _default;

package/dist/Select/index.d.ts

@@ -36,6 +36,8 @@ export declare const AtSelect: {
         }>;
         open: import("vue").Ref<boolean>;
         valueOfModel: import("vue").ComputedRef<string>;
+        containerRef: import("vue").Ref<HTMLDivElement | null>;
+        rotateIcon: () => void;
     }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
         modelValue: {
             type: import("vue").PropType<string | ISelectItemProps>;
@@ -72,6 +74,10 @@ export declare const AtSelect: {
             type: import("vue").PropType<string[] | ISelectItemProps[]>;
             default: () => ISelectItemProps[];
         };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
         emitValue: {
             type: BooleanConstructor;
             default: boolean;
@@ -88,6 +94,7 @@ export declare const AtSelect: {
     }, {
         onSelectedValueChange: (item: ISelectItemProps, isChecked: boolean) => void;
         onSelectedItemClick: (selectedValue: string, isOpen?: boolean) => void;
+        rotateIcon: () => void;
         myItems: import("vue").Ref<{
             text: string;
             value: string;
@@ -109,6 +116,7 @@ export declare const AtSelect: {
             type?: "text" | "multiple" | "with-icon" | undefined;
             icon?: string | undefined;
         }[]>;
+        isInternalChange: import("vue").Ref<boolean>;
         isOpen: import("vue").Ref<boolean>;
         containerRef: import("vue").Ref<HTMLDivElement | null>;
         icons: {
@@ -123,6 +131,10 @@ export declare const AtSelect: {
             type: import("vue").PropType<string[] | ISelectItemProps[]>;
             default: () => ISelectItemProps[];
         };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
         emitValue: {
             type: BooleanConstructor;
             default: boolean;
@@ -142,6 +154,7 @@ export declare const AtSelect: {
         "onUpdate:selectedItems"?: ((...args: any[]) => any) | undefined;
     }, {
         label: string;
+        disabled: boolean;
         modelValue: string[] | ISelectItemProps[];
         separator: string;
         items: ISelectItemProps[];

package/dist/ShadedColorMaterial.glsl-8dd39e79.js

@@ -0,0 +1,64 @@
+import "./vec4f64-043e974c.js";
+import "./index-a450f76b.js";
+import "./mat4f64-cce69db4.js";
+import "./BindType-5e76c8e1.js";
+import "./OrderIndependentTransparency-3eadfe42.js";
+import "./VertexColor.glsl-e1468339.js";
+import "./mat3f64-03233387.js";
+import "./VertexAttribute-faad30bf.js";
+import { p as eo } from "./InteractiveAnalysisViewModel-cc8c864a.js";
+import "vue";
+import "./enums-2c166c09.js";
+import "./basicInterfaces-fa4f5fa7.js";
+import "./Texture-08e8abdd.js";
+import "./vec42-1641eab7.js";
+import "./Util-b8d78341.js";
+import "./Indices-d59209a8.js";
+import "./triangle-cac8dd7a.js";
+import "./ObjectStack-5e8cdae7.js";
+import "./lineSegment-53f5f3d5.js";
+import "./plane-ee1849b4.js";
+import "./quatf64-bec1af25.js";
+import "./doublePrecisionUtils-46e21550.js";
+import "./lengthUtils-15c44621.js";
+import "./requestImageUtils-6a0b710a.js";
+import "./sphere-8103ac36.js";
+import "./orientedBoundingBox-75e679bc.js";
+import "./quat-48b188ff.js";
+import "./computeTranslationToOriginAndRotation-466bc2c5.js";
+import "./BufferView-c2f86567.js";
+import "./geometryEngineBase-292b6d6f.js";
+import "./colorUtils-1a8cc2f8.js";
+import "./projectVectorToVector-fdcb00cb.js";
+import "./projectPointToVector-5800baf2.js";
+import "./elevationInfoUtils-96b1ac38.js";
+import "./unitConversionUtils-ad9151e0.js";
+import "./vec4f32-b2628ced.js";
+import "./Octree-0cab1591.js";
+import "./DoubleArray-61325dbc.js";
+import "./glUtil-8f8bce6b.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./InterleavedLayout-31a7340e.js";
+import "./types-adba9034.js";
+import "./VertexArrayObject-4c6a6897.js";
+import "./BufferObject-faafd842.js";
+import "./axisAngleDegrees-abd6e971.js";
+import "./RenderState-b244097f.js";
+import "./NestedMap-83f8e815.js";
+import "./floatRGBA-8dd8f77f.js";
+import "./MemCache-6249a3f0.js";
+import "./Scheduler-b0e8df04.js";
+import "./vec3f32-304a6a9c.js";
+import "./MeasurementWidgetContent-31e1b266.js";
+import "./meshVertexSpaceUtils-3647b869.js";
+import "./MeshLocalVertexSpace-a0c9365a.js";
+import "./vec3-0abe1464.js";
+import "./quantityUtils-ab7a657b.js";
+import "./FeatureFilter-0babb1a1.js";
+import "./floorFilterUtils-936f7587.js";
+import "./layerViewUtils-052e603c.js";
+import "./geometryEngine-170fd2fc.js";
+import "./hydrated-e88a116e.js";
+export {
+  eo as build
+};

package/dist/SnappingOperation-726320a3.js

@@ -0,0 +1,48 @@
+import { e as r, y as l, c as u, S as c, k as P, a as h, l as _ } from "./index-a450f76b.js";
+import { I as d, F as g } from "./Scheduler-b0e8df04.js";
+let a = class extends c {
+  constructor(t) {
+    super(t), this.constrainResult = (s) => s, this._snapPoints = null, this._frameTask = null, this._abortController = null, this._stagedPoint = null, this._snap = P(async (s, n, o, i) => {
+      const e = this._frameTask;
+      if (e == null)
+        return;
+      const p = await e.schedule(() => n.snap({ ...s, context: o, signal: i }), i);
+      p.valid && await e.schedule(() => {
+        this.stagedPoint = p.apply(), s !== this._snapPoints && this._snapPoints != null && (this.stagedPoint = n.update({ ...this._snapPoints, context: o }));
+      }, i);
+    });
+  }
+  get stagedPoint() {
+    return this._stagedPoint;
+  }
+  set stagedPoint(t) {
+    this._stagedPoint = this.constrainResult(t);
+  }
+  initialize() {
+    var s, n;
+    const t = this.view.type === "3d" ? (n = (s = this.view) == null ? void 0 : s.resourceController) == null ? void 0 : n.scheduler : null;
+    this._frameTask = t != null ? t.registerTask(d.SNAPPING) : g;
+  }
+  destroy() {
+    this._abortController = h(this._abortController), this._frameTask = _(this._frameTask);
+  }
+  update(t, s, n) {
+    this._snapPoints = t;
+    const { point: o, scenePoint: i } = t, e = s.update({ point: o, scenePoint: i, context: n });
+    return this.stagedPoint = e, e;
+  }
+  async snap(t, s, n) {
+    const { point: o, scenePoint: i } = t;
+    return this.stagedPoint = s.update({ point: o, scenePoint: i, context: n }), this._snapPoints = t, this._abortController == null && (this._abortController = new AbortController()), this._snap(t, s, n, this._abortController.signal);
+  }
+  async snapAgainNearPreviousMapPoint(t, s) {
+    this._snapPoints != null && await this.snap(this._snapPoints, t, s);
+  }
+  abort() {
+    this._abortController = h(this._abortController), this._snapPoints = null;
+  }
+};
+r([l({ constructOnly: !0 })], a.prototype, "view", void 0), r([l()], a.prototype, "stagedPoint", null), r([l()], a.prototype, "constrainResult", void 0), r([l()], a.prototype, "_stagedPoint", void 0), a = r([u("esri.views.interactive.snapping.SnappingOperation")], a);
+export {
+  a as p
+};

package/dist/SourceLayerData-b2da5f90.js

@@ -0,0 +1,116 @@
+import { h as g } from "./GeometryUtils-42ae242b.js";
+var u;
+(function(c) {
+  c[c.moveTo = 1] = "moveTo", c[c.lineTo = 2] = "lineTo", c[c.close = 7] = "close";
+})(u || (u = {}));
+class m {
+  constructor(e, t, o = 0) {
+    this.values = {}, this._geometry = void 0, this._pbfGeometry = null, this.featureIndex = o;
+    const s = t.keys, l = t.values, r = e.asUnsafe();
+    for (; r.next(); )
+      switch (r.tag()) {
+        case 1:
+          this.id = r.getUInt64();
+          break;
+        case 2: {
+          const i = r.getMessage().asUnsafe(), a = this.values;
+          for (; !i.empty(); ) {
+            const n = i.getUInt32(), h = i.getUInt32();
+            a[s[n]] = l[h];
+          }
+          i.release();
+          break;
+        }
+        case 3:
+          this.type = r.getUInt32();
+          break;
+        case 4:
+          this._pbfGeometry = r.getMessage();
+          break;
+        default:
+          r.skip();
+      }
+  }
+  getGeometry(e) {
+    if (this._geometry !== void 0)
+      return this._geometry;
+    if (!this._pbfGeometry)
+      return null;
+    const t = this._pbfGeometry.asUnsafe();
+    let o, s;
+    this._pbfGeometry = null, e ? e.reset(this.type) : o = [];
+    let l, r = u.moveTo, i = 0, a = 0, n = 0;
+    for (; !t.empty(); ) {
+      if (i === 0) {
+        const h = t.getUInt32();
+        r = 7 & h, i = h >> 3;
+      }
+      switch (i--, r) {
+        case u.moveTo:
+          a += t.getSInt32(), n += t.getSInt32(), e ? e.moveTo(a, n) : o && (s && o.push(s), s = [], s.push(new g(a, n)));
+          break;
+        case u.lineTo:
+          a += t.getSInt32(), n += t.getSInt32(), e ? e.lineTo(a, n) : s && s.push(new g(a, n));
+          break;
+        case u.close:
+          e ? e.close() : s && !s[0].equals(a, n) && s.push(s[0].clone());
+          break;
+        default:
+          throw t.release(), new Error("Invalid path operation");
+      }
+    }
+    return e ? l = e.result() : o && (s && o.push(s), l = o), t.release(), this._geometry = l, l;
+  }
+}
+class p {
+  constructor(e) {
+    this.extent = 4096, this.keys = [], this.values = [], this._pbfLayer = e.clone();
+    const t = e.asUnsafe();
+    for (; t.next(); )
+      switch (t.tag()) {
+        case 1:
+          this.name = t.getString();
+          break;
+        case 3:
+          this.keys.push(t.getString());
+          break;
+        case 4:
+          this.values.push(t.processMessage(p._parseValue));
+          break;
+        case 5:
+          this.extent = t.getUInt32();
+          break;
+        default:
+          t.skip();
+      }
+  }
+  getData() {
+    return this._pbfLayer;
+  }
+  static _parseValue(e) {
+    for (; e.next(); )
+      switch (e.tag()) {
+        case 1:
+          return e.getString();
+        case 2:
+          return e.getFloat();
+        case 3:
+          return e.getDouble();
+        case 4:
+          return e.getInt64();
+        case 5:
+          return e.getUInt64();
+        case 6:
+          return e.getSInt64();
+        case 7:
+          return e.getBool();
+        default:
+          e.skip();
+      }
+    return null;
+  }
+}
+export {
+  p as e,
+  m as s
+};