origam 0.3.4 → 0.3.5

package/dist/src/composables/DataTable/pagination.composable.cjs

@@ -7,9 +7,9 @@ exports.createPagination = createPagination;
 exports.providePagination = providePagination;
 exports.usePaginatedItems = usePaginatedItems;
 exports.usePagination = usePagination;
-var _composables = require("@/composables");
-var _consts = require("@/consts");
-var _utils = require("@/utils");
+var _composables = require("../../composables/index.cjs");
+var _consts = require("../../consts/index.cjs");
+var _utils = require("../../utils/index.cjs");
 var _vue = require("vue");
 function createPagination(props) {
   const page = (0, _composables.useVModel)(props, "page", void 0, value => +(value ?? 1));

package/dist/src/composables/DataTable/pagination.composable.d.ts

@@ -1,20 +1,31 @@
-import type { IDataTableGroup, IDataTablePaginationProps, IDataTableProvidePagination } from '@/interfaces';
+import type { IDataTableGroup, IDataTablePaginationProps, IDataTableProvidePagination } from '../../interfaces';
 import { Ref } from 'vue';
 export declare function createPagination(props: IDataTablePaginationProps): {
-    page: any;
-    itemsPerPage: any;
+    page: import("../../types").TVModel<IDataTablePaginationProps, "page", number>;
+    itemsPerPage: import("../../types").TVModel<IDataTablePaginationProps, "itemsPerPage", number>;
 };
 export declare function providePagination(options: {
     page: Ref<number>;
     itemsPerPage: Ref<number>;
     itemsLength: Ref<number>;
 }): IDataTableProvidePagination;
-export declare function usePagination(): {};
+export declare function usePagination(): {
+    page: Ref<number>;
+    itemsPerPage: Ref<number>;
+    startIndex: Ref<number>;
+    stopIndex: Ref<number>;
+    pageCount: Ref<number>;
+    itemsLength: Ref<number>;
+    prevPage: () => void;
+    nextPage: () => void;
+    setPage: (value: number) => void;
+    setItemsPerPage: (value: number) => void;
+};
 export declare function usePaginatedItems<T>(options: {
     items: Ref<readonly (T | IDataTableGroup<T>)[]>;
     startIndex: Ref<number>;
     stopIndex: Ref<number>;
     itemsPerPage: Ref<number>;
 }): {
-    paginatedItems: import("vue").ComputedRef<readonly any[]>;
+    paginatedItems: import("vue").ComputedRef<readonly (T | IDataTableGroup<T>)[]>;
 };

package/dist/src/composables/DataTable/pagination.composable.js

@@ -1,6 +1,6 @@
-import { useVModel } from "@/composables";
-import { ORIGAM_DATA_TABLE_PAGINATION_KEY } from "@/consts";
-import { clamp, getCurrentInstance } from "@/utils";
+import { useVModel } from "../../composables/index.js";
+import { ORIGAM_DATA_TABLE_PAGINATION_KEY } from "../../consts/index.js";
+import { clamp, getCurrentInstance } from "../../utils/index.js";
 import { computed, inject, provide, watch, watchEffect } from "vue";
 export function createPagination(props) {
   const page = useVModel(props, "page", void 0, (value) => +(value ?? 1));

package/dist/src/composables/DataTable/select.composable.cjs

@@ -5,10 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.provideSelection = provideSelection;
 exports.useSelection = useSelection;
-var _composables = require("@/composables");
-var _consts = require("@/consts");
-var _enums = require("@/enums");
-var _utils = require("@/utils");
+var _composables = require("../../composables/index.cjs");
+var _consts = require("../../consts/index.cjs");
+var _enums = require("../../enums/index.cjs");
+var _utils = require("../../utils/index.cjs");
 var _vue = require("vue");
 function provideSelection(props, {
   allItems,

package/dist/src/composables/DataTable/select.composable.d.ts

@@ -1,7 +1,7 @@
-import type { IDataTableProvideSelection, IDataTableSelectableItem, IDataTableSelectProps } from '@/interfaces';
+import type { IDataTableProvideSelection, IDataTableSelectableItem, IDataTableSelectProps } from '../../interfaces';
 import { Ref } from 'vue';
 export declare function provideSelection(props: IDataTableSelectProps, { allItems, currentPage }: {
     allItems: Ref<Array<IDataTableSelectableItem>>;
     currentPage: Ref<Array<IDataTableSelectableItem>>;
 }): IDataTableProvideSelection;
-export declare function useSelection(): {};
+export declare function useSelection(): IDataTableProvideSelection;

package/dist/src/composables/DataTable/select.composable.js

@@ -1,7 +1,7 @@
-import { useVModel } from "@/composables";
-import { allSelectStrategy, ORIGAM_DATA_TABLE_SELECT_KEY, pageSelectStrategy, singleSelectStrategy } from "@/consts";
-import { DATATABLE_SELECT_STRATEGY } from "@/enums";
-import { deepEqual, wrapInArray } from "@/utils";
+import { useVModel } from "../../composables/index.js";
+import { allSelectStrategy, ORIGAM_DATA_TABLE_SELECT_KEY, pageSelectStrategy, singleSelectStrategy } from "../../consts/index.js";
+import { DATATABLE_SELECT_STRATEGY } from "../../enums/index.js";
+import { deepEqual, wrapInArray } from "../../utils/index.js";
 import { computed, inject, provide } from "vue";
 export function provideSelection(props, { allItems, currentPage }) {
   const valueComparator = computed(() => {

package/dist/src/composables/DataTable/sort.composable.cjs

@@ -7,10 +7,10 @@ exports.createSort = createSort;
 exports.provideSort = provideSort;
 exports.useSort = useSort;
 exports.useSortedItems = useSortedItems;
-var _composables = require("@/composables");
-var _consts = require("@/consts");
-var _enums = require("@/enums");
-var _utils = require("@/utils");
+var _composables = require("../../composables/index.cjs");
+var _consts = require("../../consts/index.cjs");
+var _enums = require("../../enums/index.cjs");
+var _utils = require("../../utils/index.cjs");
 var _vue = require("vue");
 function createSort(props) {
   const sortBy = (0, _composables.useVModel)(props, "sortBy", []);

package/dist/src/composables/DataTable/sort.composable.d.ts

@@ -1,10 +1,10 @@
-import type { IDataTableProvideSort, IDataTableSortItem, IDataTableSortProps, IInternalItem } from '@/interfaces';
-import type { TDataTableCompareFunction } from '@/types';
+import type { IDataTableProvideSort, IDataTableSortItem, IDataTableSortProps, IInternalDataTableHeader, IInternalItem } from '../../interfaces';
+import type { TDataTableCompareFunction } from '../../types';
 import { Ref } from 'vue';
 export declare function createSort(props: IDataTableSortProps): {
-    sortBy: any;
-    mustSort: any;
-    multiSort: any;
+    sortBy: import("../../types").TVModel<IDataTableSortProps, "sortBy", IDataTableSortItem[] | undefined>;
+    mustSort: Ref<boolean | undefined, boolean | undefined>;
+    multiSort: Ref<boolean | undefined, boolean | undefined>;
 };
 export declare function provideSort(options: {
     sortBy: Ref<Array<IDataTableSortItem>>;
@@ -12,7 +12,11 @@ export declare function provideSort(options: {
     multiSort: Ref<boolean>;
     page?: Ref<number>;
 }): IDataTableProvideSort;
-export declare function useSort(): {};
+export declare function useSort(): {
+    sortBy: Ref<Array<IDataTableSortItem>>;
+    toggleSort: (column: IInternalDataTableHeader) => void;
+    isSorted: (column: IInternalDataTableHeader) => boolean;
+};
 export declare function useSortedItems<T extends IInternalItem>(props: {
     customKeySort: TDataTableCompareFunction | undefined;
 }, items: Ref<T[]>, sortBy: Ref<Array<IDataTableSortItem>>, options?: {
@@ -20,5 +24,5 @@ export declare function useSortedItems<T extends IInternalItem>(props: {
     sortFunctions?: Ref<Record<string, TDataTableCompareFunction> | undefined>;
     sortRawFunctions?: Ref<Record<string, TDataTableCompareFunction> | undefined>;
 }): {
-    sortedItems: import("vue").ComputedRef<any>;
+    sortedItems: import("vue").ComputedRef<T[]>;
 };

package/dist/src/composables/DataTable/sort.composable.js

@@ -1,7 +1,7 @@
-import { useVModel } from "@/composables";
-import { ORIGAM_DATA_TABLE_SORT_KEY } from "@/consts";
-import { SORT_DIRECTION } from "@/enums";
-import { sortItems } from "@/utils";
+import { useVModel } from "../../composables/index.js";
+import { ORIGAM_DATA_TABLE_SORT_KEY } from "../../consts/index.js";
+import { SORT_DIRECTION } from "../../enums/index.js";
+import { sortItems } from "../../utils/index.js";
 import { computed, inject, provide, toRef } from "vue";
 export function createSort(props) {
   const sortBy = useVModel(props, "sortBy", []);

package/dist/src/composables/Form/form.composable.cjs

@@ -4,9 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useForm = useForm;
-var _composables = require("@/composables");
-var _consts = require("@/consts");
-var _utils = require("@/utils");
+var _composables = require("../../composables/index.cjs");
+var _consts = require("../../consts/index.cjs");
+var _utils = require("../../utils/index.cjs");
 var _vue = require("vue");
 function useForm(props) {
   const model = (0, _composables.useVModel)(props, "modelValue");

package/dist/src/composables/Form/form.composable.d.ts

@@ -1,14 +1,39 @@
-import type { IFormProps } from '@/interfaces';
+import type { IFormField, IFormProps, IValidationFieldResult } from '../../interfaces';
 export declare function useForm(props: IFormProps): {
-    errors: import("vue").Ref<any, any>;
-    isDisabled: import("vue").ComputedRef<any>;
-    isReadonly: import("vue").ComputedRef<any>;
+    errors: import("vue").Ref<{
+        id: number | string;
+        errorMessages: Array<string>;
+    }[], IValidationFieldResult[] | {
+        id: number | string;
+        errorMessages: Array<string>;
+    }[]>;
+    isDisabled: import("vue").ComputedRef<boolean>;
+    isReadonly: import("vue").ComputedRef<boolean>;
     isValidating: import("vue").ShallowRef<boolean, boolean>;
-    isValid: any;
-    items: import("vue").Ref<any, any>;
+    isValid: import("../../types").TVModel<IFormProps, "modelValue", boolean | null | undefined>;
+    items: import("vue").Ref<{
+        id: number | string;
+        validate: () => Promise<Array<string>>;
+        reset: () => Promise<void>;
+        resetValidation: () => Promise<void>;
+        vm: import("vue").Raw<import("vue").ComponentInternalInstance>;
+        isValid?: boolean | null | undefined;
+        errorMessages: Array<string>;
+    }[], IFormField[] | {
+        id: number | string;
+        validate: () => Promise<Array<string>>;
+        reset: () => Promise<void>;
+        resetValidation: () => Promise<void>;
+        vm: import("vue").Raw<import("vue").ComponentInternalInstance>;
+        isValid?: boolean | null | undefined;
+        errorMessages: Array<string>;
+    }[]>;
     validate: () => Promise<{
         valid: boolean;
-        errors: any;
+        errors: {
+            id: number | string;
+            errorMessages: Array<string>;
+        }[];
     }>;
     reset: () => void;
     resetValidation: () => void;

package/dist/src/composables/Form/form.composable.js

@@ -1,6 +1,6 @@
-import { useVModel } from "@/composables";
-import { ORIGAM_FORM_KEY } from "@/consts";
-import { consoleWarn } from "@/utils";
+import { useVModel } from "../../composables/index.js";
+import { ORIGAM_FORM_KEY } from "../../consts/index.js";
+import { consoleWarn } from "../../utils/index.js";
 import { computed, markRaw, provide, ref, shallowRef, toRef, watch } from "vue";
 export function useForm(props) {
   const model = useVModel(props, "modelValue");

package/dist/src/composables/Icon/icon.composable.cjs

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createIcons = createIcons;
 exports.useIcon = void 0;
-var _components = require("@/components");
-var _consts = require("@/consts");
-var _utils = require("@/utils");
+var _components = require("../../components/index.cjs");
+var _consts = require("../../consts/index.cjs");
+var _utils = require("../../utils/index.cjs");
 var _vue = require("vue");
 const useIcon = props => {
   const icons = (0, _vue.inject)(_consts.ORIGAM_ICONS_KEY);

package/dist/src/composables/Icon/icon.composable.d.ts

@@ -1,6 +1,6 @@
-import type { TIcon, TIconOptions } from '@/types';
+import type { TIcon, TIconInstance, TIconOptions } from '../../types';
 import { Ref } from 'vue';
 export declare const useIcon: (props: Ref<TIcon | undefined>) => {
     iconData: import("vue").ComputedRef<TIconInstance>;
 };
-export declare function createIcons(options?: TIconOptions): any;
+export declare function createIcons(options?: TIconOptions): Record<string, unknown>;

package/dist/src/composables/Icon/icon.composable.js

@@ -1,6 +1,6 @@
-import { OrigamComponentIcon, OrigamSvgIcon } from "@/components";
-import { DEFAULT_SETS, MDI, MDI_ALIASES, ORIGAM_ICONS_KEY } from "@/consts";
-import { mergeDeep } from "@/utils";
+import { OrigamComponentIcon, OrigamSvgIcon } from "../../components/index.js";
+import { DEFAULT_SETS, MDI, MDI_ALIASES, ORIGAM_ICONS_KEY } from "../../consts/index.js";
+import { mergeDeep } from "../../utils/index.js";
 import { computed, inject, unref } from "vue";
 export const useIcon = (props) => {
   const icons = inject(ORIGAM_ICONS_KEY);

package/dist/src/composables/List/list.composable.cjs

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useCreateList = useCreateList;
 exports.useList = useList;
-var _consts = require("@/consts");
+var _consts = require("../../consts/index.cjs");
 var _vue = require("vue");
 function useCreateList() {
   const parent = (0, _vue.inject)(_consts.ORIGAM_LIST_KEY, {

package/dist/src/composables/List/list.composable.d.ts

@@ -1,7 +1,13 @@
+import { ComputedRef } from 'vue';
 export declare function useCreateList(): {
-    hasPrepend: import("vue").ShallowRef<boolean, boolean>;
-    updateHasPrepend: () => null;
-    hasAppend: import("vue").ShallowRef<boolean, boolean>;
-    updateHasAppend: () => null;
+    hasPrepend: import("vue").Ref<boolean>;
+    updateHasPrepend: (value: ComputedRef<boolean>) => void;
+    hasAppend: import("vue").Ref<boolean>;
+    updateHasAppend: (value: ComputedRef<boolean>) => void;
 };
-export declare function useList(): null;
+export declare function useList(): {
+    hasPrepend: import("vue").Ref<boolean>;
+    updateHasPrepend: (value: ComputedRef<boolean>) => void;
+    hasAppend: import("vue").Ref<boolean>;
+    updateHasAppend: (value: ComputedRef<boolean>) => void;
+} | null;

package/dist/src/composables/List/list.composable.js

@@ -1,4 +1,4 @@
-import { ORIGAM_LIST_KEY } from "@/consts";
+import { ORIGAM_LIST_KEY } from "../../consts/index.js";
 import { inject, provide, shallowRef } from "vue";
 export function useCreateList() {
   const parent = inject(ORIGAM_LIST_KEY, {

package/dist/src/composables/PageBuilder/editor.composable.cjs

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createEditor = createEditor;
 exports.useEditor = useEditor;
-var _composables = require("@/composables");
-var _consts = require("@/consts");
-var _utils = require("@/utils");
+var _composables = require("../../composables/index.cjs");
+var _consts = require("../../consts/index.cjs");
+var _utils = require("../../utils/index.cjs");
 var _vue = require("vue");
 function createEditor(props, name = (0, _utils.getCurrentInstanceName)()) {
   const children = (0, _vue.ref)(/* @__PURE__ */new Map());

package/dist/src/composables/PageBuilder/editor.composable.d.ts

@@ -1,2 +1,18 @@
-export declare function createEditor(props: any, name?: any): any;
-export declare function useEditor(props: any): any;
+export declare function createEditor(props: any, name?: string): {
+    children: import("vue").Ref<Map<unknown, Array<unknown>>>;
+    parents: import("vue").Ref<Map<unknown, unknown>>;
+    edit: import("vue").Ref<Set<unknown>>;
+    lock: import("vue").Ref<Set<unknown>>;
+};
+export declare function useEditor(props: any): {
+    id: import("vue").ComputedRef<symbol>;
+    props: any;
+    isEdited: import("vue").ComputedRef<boolean>;
+    isLocked: import("vue").ComputedRef<boolean>;
+    root: {
+        children: import("vue").Ref<Map<unknown, Array<unknown>>>;
+        parents: import("vue").Ref<Map<unknown, unknown>>;
+        edit: import("vue").Ref<Set<unknown>>;
+        lock: import("vue").Ref<Set<unknown>>;
+    };
+};

package/dist/src/composables/PageBuilder/editor.composable.js

@@ -1,6 +1,6 @@
-import { useVModel } from "@/composables";
-import { EMPTY_EDIT, ORIGAM_EDIT_KEY } from "@/consts";
-import { getCurrentInstanceName, getUid } from "@/utils";
+import { useVModel } from "../../composables/index.js";
+import { EMPTY_EDIT, ORIGAM_EDIT_KEY } from "../../consts/index.js";
+import { getCurrentInstanceName, getUid } from "../../utils/index.js";
 import { computed, inject, provide, ref } from "vue";
 export function createEditor(props, name = getCurrentInstanceName()) {
   const children = ref(/* @__PURE__ */ new Map());

package/dist/src/composables/Parallax/transform.composable.cjs

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useParallaxTransform = useParallaxTransform;
-var _enums = require("@/enums");
+var _enums = require("../../enums/index.cjs");
 var _vue = require("vue");
 function useParallaxTransform(props) {
   const strength = (0, _vue.computed)(() => {

package/dist/src/composables/Parallax/transform.composable.d.ts

@@ -1,5 +1,5 @@
-import type { IParallaxElementProps } from '@/interfaces';
+import type { IParallaxElementProps } from '../../interfaces';
 export declare function useParallaxTransform(props: IParallaxElementProps): {
     transformStyles: (x: number, y: number) => any;
-    strength: import("vue").ComputedRef<any>;
+    strength: import("vue").ComputedRef<number>;
 };

package/dist/src/composables/Parallax/transform.composable.js

@@ -1,4 +1,4 @@
-import { AXIS, PARALLAX_ELEMENT_TYPE } from "@/enums";
+import { AXIS, PARALLAX_ELEMENT_TYPE } from "../../enums/index.js";
 import { computed } from "vue";
 export function useParallaxTransform(props) {
   const strength = computed(() => {

package/dist/src/composables/Progress/progress.composable.cjs

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useProgress = useProgress;
-var _composables = require("@/composables");
-var _utils = require("@/utils");
+var _composables = require("../../composables/index.cjs");
+var _utils = require("../../utils/index.cjs");
 var _vue = require("vue");
 function useProgress(props) {
   const progress = (0, _composables.useVModel)(props, "modelValue");

package/dist/src/composables/Progress/progress.composable.d.ts

@@ -1,10 +1,16 @@
-import type { IProgressTypeProps } from '@/interfaces';
+import type { IProgressTypeProps } from '../../interfaces';
 export declare function useProgress(props: IProgressTypeProps): {
-    progressClasses: import("vue").ComputedRef<any[]>;
-    progressStyles: import("vue").ComputedRef<any[]>;
+    progressClasses: import("vue").ComputedRef<(string | string[] | {
+        'origam-progress--indeterminate': boolean | undefined;
+        'origam-progress--visible': boolean;
+        'origam-progress--active': boolean | undefined;
+        'origam-progress--striped': boolean | undefined;
+        'origam-progress--absolute': boolean | undefined;
+    })[]>;
+    progressStyles: import("vue").ComputedRef<string[][]>;
     normalizedValue: import("vue").ComputedRef<number>;
     thickness: import("vue").ComputedRef<number>;
-    max: import("vue").ComputedRef<any>;
-    progress: any;
+    max: import("vue").ComputedRef<number>;
+    progress: import("../../types").TVModel<IProgressTypeProps, "modelValue", string | number | undefined>;
     hasContent: import("vue").ComputedRef<import("vue").Slot<any> | undefined>;
 };

package/dist/src/composables/Progress/progress.composable.js

@@ -1,5 +1,5 @@
-import { useIntersectionObserver, useMargin, usePadding, useVModel } from "@/composables";
-import { int } from "@/utils";
+import { useIntersectionObserver, useMargin, usePadding, useVModel } from "../../composables/index.js";
+import { int } from "../../utils/index.js";
 import { computed, useSlots } from "vue";
 export function useProgress(props) {
   const progress = useVModel(props, "modelValue");

package/dist/src/composables/SelectionControl/selection-control.composable.cjs

@@ -4,9 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useSelectionControl = useSelectionControl;
-var _composables = require("@/composables");
-var _consts = require("@/consts");
-var _utils = require("@/utils");
+var _composables = require("../../composables/index.cjs");
+var _consts = require("../../consts/index.cjs");
+var _utils = require("../../utils/index.cjs");
 var _vue = require("vue");
 function useSelectionControl(props) {
   const group = (0, _vue.inject)(_consts.ORIGAM_SELECTION_CONTROL_GROUP_KEY, void 0);

package/dist/src/composables/SelectionControl/selection-control.composable.d.ts

@@ -1,11 +1,11 @@
-import type { ISelectionControlProps } from "@/interfaces";
+import type { ISelectionControlProps } from "../../interfaces";
 export declare function useSelectionControl(props: ISelectionControlProps): {
-    group: undefined;
-    densityClasses: any;
+    group: import("../../interfaces").ISelectionGroupContext | undefined;
+    densityClasses: import("vue").ComputedRef<string[]>;
     trueValue: import("vue").ComputedRef<any>;
     falseValue: import("vue").ComputedRef<any>;
-    model: import("vue").WritableComputedRef<any, boolean>;
-    textColorStyles: any;
-    backgroundColorStyles: any;
-    icon: import("vue").ComputedRef<any>;
+    model: import("vue").WritableComputedRef<boolean, boolean>;
+    textColorStyles: import("vue").ComputedRef<never[]>;
+    backgroundColorStyles: import("vue").ComputedRef<never[]>;
+    icon: import("vue").ComputedRef<import("../../types").TIcon | undefined>;
 };

package/dist/src/composables/SelectionControl/selection-control.composable.js

@@ -1,6 +1,6 @@
-import { useBackgroundColor, useDensity, useTextColor, useVModel } from "@/composables";
-import { ORIGAM_SELECTION_CONTROL_GROUP_KEY } from "@/consts";
-import { deepEqual, wrapInArray } from "@/utils";
+import { useBackgroundColor, useDensity, useTextColor, useVModel } from "../../composables/index.js";
+import { ORIGAM_SELECTION_CONTROL_GROUP_KEY } from "../../consts/index.js";
+import { deepEqual, wrapInArray } from "../../utils/index.js";
 import { computed, inject } from "vue";
 export function useSelectionControl(props) {
   const group = inject(ORIGAM_SELECTION_CONTROL_GROUP_KEY, void 0);

package/dist/src/composables/SliderField/slider-field.composable.cjs

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useSlider = useSlider;
 exports.useSteps = useSteps;
-var _consts = require("@/consts");
-var _enums = require("@/enums");
-var _utils = require("@/utils");
+var _consts = require("../../consts/index.cjs");
+var _enums = require("../../enums/index.cjs");
+var _utils = require("../../utils/index.cjs");
 var _vue = require("vue");
 function useSteps(props) {
   const min = (0, _vue.computed)(() => {

package/dist/src/composables/SliderField/slider-field.composable.d.ts

@@ -1,4 +1,4 @@
-import type { ISliderField, ISliderFieldProps } from '@/interfaces';
+import type { ISliderField, ISliderFieldProps, ISliderFieldProvide } from '../../interfaces';
 export declare function useSteps(props: ISliderFieldProps): {
     min: import("vue").ComputedRef<number>;
     max: import("vue").ComputedRef<number>;

package/dist/src/composables/SliderField/slider-field.composable.js

@@ -1,6 +1,6 @@
-import { ORIGAM_SLIDER_FIELD_KEY } from "@/consts";
-import { BLOCK, CLIENT_POSITION, DIMENSIONS, DIRECTION, INLINE } from "@/enums";
-import { clamp, createRange, getDecimals, getPosition, getSliderFieldOffset, int } from "@/utils";
+import { ORIGAM_SLIDER_FIELD_KEY } from "../../consts/index.js";
+import { BLOCK, CLIENT_POSITION, DIMENSIONS, DIRECTION, INLINE } from "../../enums/index.js";
+import { clamp, createRange, getDecimals, getPosition, getSliderFieldOffset, int } from "../../utils/index.js";
 import { computed, provide, ref, shallowRef, toRef } from "vue";
 export function useSteps(props) {
   const min = computed(() => {

package/dist/src/composables/Transition/transition.composable.cjs

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.useCssTransition = useCssTransition;
 exports.useTransition = useTransition;
 exports.useWindowTransition = useWindowTransition;
-var _consts = require("@/consts");
-var _utils = require("@/utils");
+var _consts = require("../../consts/index.cjs");
+var _utils = require("../../utils/index.cjs");
 var _vue = require("vue");
 function useTransition(props) {
   const isDisabled = (0, _vue.computed)(() => {

package/dist/src/composables/Transition/transition.composable.d.ts

@@ -1,21 +1,21 @@
-import type { ITransitionProps } from '@/interfaces';
+import type { ITransitionProps } from '../../interfaces';
 import { Component, ShallowRef } from 'vue';
 export declare function useTransition(props: ITransitionProps): {
-    name: import("vue").ComputedRef<any>;
-    isDisabled: import("vue").ComputedRef<any>;
+    name: import("vue").ComputedRef<string | undefined>;
+    isDisabled: import("vue").ComputedRef<boolean | undefined>;
 };
 export declare function useCssTransition(props: ITransitionProps): {
     tag: ShallowRef<Component>;
-    name: import("vue").ComputedRef<any>;
-    isDisabled: import("vue").ComputedRef<any>;
+    name: import("vue").ComputedRef<string | undefined>;
+    isDisabled: import("vue").ComputedRef<boolean | undefined>;
     transitionProps: import("vue").ComputedRef<{
         [key: string]: any;
     }>;
 };
 export declare function useWindowTransition(props: ITransitionProps): {
     tag: ShallowRef<Component>;
-    name: import("vue").ComputedRef<any>;
-    isDisabled: import("vue").ComputedRef<any>;
+    name: import("vue").ComputedRef<string | undefined>;
+    isDisabled: import("vue").ComputedRef<boolean | undefined>;
     transitionProps: import("vue").ComputedRef<{
         [key: string]: any;
     }>;

package/dist/src/composables/Transition/transition.composable.js

@@ -1,5 +1,5 @@
-import { ORIGAM_WINDOW_KEY } from "@/consts";
-import { convertToUnit } from "@/utils";
+import { ORIGAM_WINDOW_KEY } from "../../consts/index.js";
+import { convertToUnit } from "../../utils/index.js";
 import { computed, inject, nextTick, shallowRef, Transition, TransitionGroup } from "vue";
 export function useTransition(props) {
   const isDisabled = computed(() => {

package/dist/src/consts/Btn/btn-toggle.const.d.ts

@@ -1,3 +1,3 @@
-import type { IGroupProvide } from '@/interfaces';
+import type { IGroupProvide } from '../../interfaces';
 import type { InjectionKey } from 'vue';
 export declare const ORIGAM_BTN_TOGGLE_KEY: InjectionKey<IGroupProvide>;

package/dist/src/consts/ColorPicker/color-picker.const.cjs

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.COLOR_PICKER_MODES = exports.COLOR_NULL = void 0;
-var _utils = require("@/utils");
+var _utils = require("../../utils/index.cjs");
 const COLOR_NULL = exports.COLOR_NULL = {
   h: 0,
   s: 0,

package/dist/src/consts/ColorPicker/color-picker.const.d.ts

@@ -1,3 +1,4 @@
+import type { IColorPickerMode } from "../../interfaces";
 export declare const COLOR_NULL: {
     h: number;
     s: number;
@@ -9,6 +10,15 @@ export declare const COLOR_PICKER_MODES: {
     rgba: IColorPickerMode;
     hsl: IColorPickerMode;
     hsla: IColorPickerMode;
-    hex: any;
+    hex: {
+        inputs: {
+            label: string;
+            getValue: (c: string) => string;
+            getColor: (_c: string, v: string) => string;
+        }[];
+        inputProps: Record<string, unknown>;
+        from: (color: any) => import("../../types").THSVA;
+        to: (color: import("../../types").THSVA) => any;
+    };
     hexa: IColorPickerMode;
 };

package/dist/src/consts/ColorPicker/color-picker.const.js

@@ -1,4 +1,4 @@
-import { HexToHSV, HSLtoHSV, HSVtoHex, HSVtoHSL, HSVtoRGB, RGBtoHSV } from "@/utils";
+import { HexToHSV, HSLtoHSV, HSVtoHex, HSVtoHSL, HSVtoRGB, RGBtoHSV } from "../../utils/index.js";
 export const COLOR_NULL = { h: 0, s: 0, v: 0, a: 1 };
 const COLOR_PICKER_MODE_RGBA = {
   inputProps: {