@wirekyt/vue 0.0.1 → 0.0.3

package/dist/image-cropper.js

@@ -0,0 +1,235 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { c as normalizeProps$1, d as useForwardExpose, m as createContext, s as useMachine } from "./utils-D95V66v9.js";
+import { a as DEFAULT_LOCALE, d as useEnvironmentContext, o as useLocaleContext, u as DEFAULT_ENVIRONMENT } from "./providers-C3XQH-uu.js";
+import { t as cleanProps } from "./clean-props--1kqQE0Y.js";
+import { n as wire } from "./factory-8Ao0DEy3.js";
+import { computed, createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, toValue, unref, useId, withCtx } from "vue";
+import * as imageCropper from "@wirekyt/dom/machines/image-cropper";
+import { anatomy, handles } from "@wirekyt/dom/machines/image-cropper";
+//#region src/components/image-cropper/use-context.ts
+const [ImageCropperProvider, useImageCropperContext] = createContext("ImageCropperContext");
+//#endregion
+//#region src/components/image-cropper/context.vue
+const _sfc_main = /*@__PURE__*/ defineComponent({
+	__name: "context",
+	setup(__props) {
+		const imageCropper = useImageCropperContext();
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(imageCropper))));
+		};
+	}
+});
+//#endregion
+//#region src/components/image-cropper/grid.vue
+const _sfc_main$1 = /*@__PURE__*/ defineComponent({
+	__name: "grid",
+	props: {
+		asChild: { type: Boolean },
+		axis: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const imageCropper = useImageCropperContext();
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(wire).div, mergeProps(unref(imageCropper).getGridProps({ axis: props.axis }), { "as-child": __props.asChild }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as-child"]);
+		};
+	}
+});
+//#endregion
+//#region src/components/image-cropper/handle.vue
+const _sfc_main$2 = /*@__PURE__*/ defineComponent({
+	__name: "handle",
+	props: {
+		asChild: { type: Boolean },
+		position: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const imageCropper = useImageCropperContext();
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(wire).div, mergeProps(unref(imageCropper).getHandleProps({ position: props.position }), { "as-child": __props.asChild }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as-child"]);
+		};
+	}
+});
+//#endregion
+//#region src/components/image-cropper/image.vue
+const _sfc_main$3 = /*@__PURE__*/ defineComponent({
+	__name: "image",
+	props: { asChild: { type: Boolean } },
+	setup(__props) {
+		const imageCropper = useImageCropperContext();
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(wire).img, mergeProps(unref(imageCropper).getImageProps(), { "as-child": __props.asChild }), null, 16, ["as-child"]);
+		};
+	}
+});
+//#endregion
+//#region src/components/image-cropper/use-image-cropper.ts
+const useImageCropper = (props = {}, emit) => {
+	const id = useId();
+	const env = useEnvironmentContext(DEFAULT_ENVIRONMENT);
+	const locale = useLocaleContext(DEFAULT_LOCALE);
+	const context = computed(() => {
+		const localProps = toValue(props);
+		return {
+			id,
+			dir: locale.value.dir,
+			getRootNode: env?.value.getRootNode,
+			...cleanProps(localProps),
+			onZoomChange(details) {
+				emit?.("zoomChange", details);
+				emit?.("update:zoom", details.zoom);
+				localProps.onZoomChange?.(details);
+			},
+			onRotationChange(details) {
+				emit?.("rotationChange", details);
+				emit?.("update:rotation", details.rotation);
+				localProps.onRotationChange?.(details);
+			},
+			onFlipChange(details) {
+				emit?.("flipChange", details);
+				emit?.("update:flip", details.flip);
+				localProps.onFlipChange?.(details);
+			},
+			onCropChange(details) {
+				emit?.("cropChange", details);
+				emit?.("update:crop", details.crop);
+				localProps.onCropChange?.(details);
+			}
+		};
+	});
+	const service = useMachine(imageCropper.machine, context);
+	return computed(() => imageCropper.connect(service, normalizeProps$1));
+};
+//#endregion
+//#region src/components/image-cropper/root.vue
+const _sfc_main$4 = /*@__PURE__*/ defineComponent({
+	__name: "root",
+	props: {
+		ids: {},
+		translations: {},
+		initialCrop: {},
+		minWidth: {},
+		minHeight: {},
+		maxWidth: {},
+		maxHeight: {},
+		aspectRatio: {},
+		cropShape: {},
+		zoom: {},
+		rotation: {},
+		flip: {},
+		defaultZoom: {},
+		defaultRotation: {},
+		defaultFlip: {},
+		zoomStep: {},
+		zoomSensitivity: {},
+		minZoom: {},
+		maxZoom: {},
+		nudgeStep: {},
+		nudgeStepShift: {},
+		nudgeStepCtrl: {},
+		fixedCropArea: { type: Boolean },
+		asChild: { type: Boolean }
+	},
+	emits: [
+		"zoomChange",
+		"update:zoom",
+		"rotationChange",
+		"update:rotation",
+		"flipChange",
+		"update:flip",
+		"cropChange",
+		"update:crop"
+	],
+	setup(__props, { emit: __emit }) {
+		const imageCropper = useImageCropper({}, __emit);
+		ImageCropperProvider(imageCropper);
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(wire).div, mergeProps(unref(imageCropper).getRootProps(), { "as-child": __props.asChild }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as-child"]);
+		};
+	}
+});
+//#endregion
+//#region src/components/image-cropper/root-provider.vue
+const _sfc_main$5 = /*@__PURE__*/ defineComponent({
+	__name: "root-provider",
+	props: {
+		value: {},
+		asChild: { type: Boolean }
+	},
+	setup(__props) {
+		const props = __props;
+		const imageCropper = computed(() => props.value);
+		ImageCropperProvider(imageCropper);
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(wire).div, mergeProps(imageCropper.value.getRootProps(), { "as-child": __props.asChild }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as-child"]);
+		};
+	}
+});
+//#endregion
+//#region src/components/image-cropper/selection.vue
+const _sfc_main$6 = /*@__PURE__*/ defineComponent({
+	__name: "selection",
+	props: { asChild: { type: Boolean } },
+	setup(__props) {
+		const imageCropper = useImageCropperContext();
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(wire).div, mergeProps(unref(imageCropper).getSelectionProps(), { "as-child": __props.asChild }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as-child"]);
+		};
+	}
+});
+//#endregion
+//#region src/components/image-cropper/viewport.vue
+const _sfc_main$7 = /*@__PURE__*/ defineComponent({
+	__name: "viewport",
+	props: { asChild: { type: Boolean } },
+	setup(__props) {
+		const imageCropper = useImageCropperContext();
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(wire).div, mergeProps(unref(imageCropper).getViewportProps(), { "as-child": __props.asChild }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as-child"]);
+		};
+	}
+});
+//#endregion
+//#region src/components/image-cropper/anatomy.ts
+const imageCropperAnatomy = anatomy;
+//#endregion
+//#region src/components/image-cropper/image-cropper.ts
+var image_cropper_exports = /* @__PURE__ */ __exportAll({
+	Context: () => _sfc_main,
+	Grid: () => _sfc_main$1,
+	Handle: () => _sfc_main$2,
+	Image: () => _sfc_main$3,
+	Root: () => _sfc_main$4,
+	RootProvider: () => _sfc_main$5,
+	Selection: () => _sfc_main$6,
+	Viewport: () => _sfc_main$7,
+	handles: () => handles
+});
+//#endregion
+export { image_cropper_exports as ImageCropper, _sfc_main as ImageCropperContext, _sfc_main$1 as ImageCropperGrid, _sfc_main$2 as ImageCropperHandle, _sfc_main$3 as ImageCropperImage, _sfc_main$4 as ImageCropperRoot, _sfc_main$5 as ImageCropperRootProvider, _sfc_main$6 as ImageCropperSelection, _sfc_main$7 as ImageCropperViewport, imageCropperAnatomy, useImageCropper, useImageCropperContext };

package/dist/index-B-o8jLyV.d.cts

@@ -0,0 +1,31 @@
+import * as Vue from "vue";
+import { ComputedRef, Ref, ShallowRef } from "vue";
+import { Machine, MachineSchema, Service, mergeProps } from "@wirekyt/dom";
+//#region src/core/normalize-props.d.ts
+type ReservedProps = {
+  key?: string | number | symbol | undefined;
+  ref?: Vue.VNodeRef | undefined;
+};
+type Attrs<T> = T & ReservedProps;
+type PropTypes = Vue.NativeElements & {
+  element: Attrs<Vue.HTMLAttributes>;
+  style: Vue.CSSProperties;
+};
+declare const normalizeProps: import("@wirekyt/dom/types").NormalizeProps<PropTypes>;
+//#endregion
+//#region src/core/machine.d.ts
+type MaybeRef$1<T> = T | Ref<T> | ComputedRef<T>;
+declare function useMachine<T extends MachineSchema>(machine: Machine<T>, userProps?: MaybeRef$1<Partial<T["props"]>>): Service<T>;
+//#endregion
+//#region src/core/use-sync-external-store.d.ts
+declare function useSyncExternalStore<T>(subscribe: (listener: () => void) => () => void, getSnapshot: () => T, _getServerSnapshot?: () => T): Readonly<ShallowRef<T>>;
+//#endregion
+//#region src/core/types.d.ts
+type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+type Assign<T, U> = Omit<T, keyof U> & U;
+type EmitFn$1<T> = <K extends keyof T>(event: K, ...args: T[K] extends any[] ? T[K] : never) => void;
+type BooleanKey<T> = { [K in keyof T]: boolean extends NonNullable<T[K]> ? K : never; }[keyof T];
+type BooleanDefaults<T> = { [K in BooleanKey<T>]: undefined; };
+type MaybePromise<T> = T | Promise<T>;
+//#endregion
+export { MaybePromise as a, useMachine as c, EmitFn$1 as i, PropTypes as l, Assign as n, Optional as o, BooleanDefaults as r, useSyncExternalStore as s, mergeProps as t, normalizeProps as u };

package/dist/index-BSoF1D-v.d.ts

@@ -0,0 +1,31 @@
+import * as Vue from "vue";
+import { ComputedRef, Ref, ShallowRef } from "vue";
+import { Machine, MachineSchema, Service, mergeProps as mergeProps$1 } from "@wirekyt/dom";
+//#region src/core/normalize-props.d.ts
+type ReservedProps = {
+  key?: string | number | symbol | undefined;
+  ref?: Vue.VNodeRef | undefined;
+};
+type Attrs<T> = T & ReservedProps;
+type PropTypes = Vue.NativeElements & {
+  element: Attrs<Vue.HTMLAttributes>;
+  style: Vue.CSSProperties;
+};
+declare const normalizeProps$1: import("@wirekyt/dom/types").NormalizeProps<PropTypes>;
+//#endregion
+//#region src/core/machine.d.ts
+type MaybeRef$1<T> = T | Ref<T> | ComputedRef<T>;
+declare function useMachine<T extends MachineSchema>(machine: Machine<T>, userProps?: MaybeRef$1<Partial<T["props"]>>): Service<T>;
+//#endregion
+//#region src/core/use-sync-external-store.d.ts
+declare function useSyncExternalStore<T>(subscribe: (listener: () => void) => () => void, getSnapshot: () => T, _getServerSnapshot?: () => T): Readonly<ShallowRef<T>>;
+//#endregion
+//#region src/core/types.d.ts
+type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+type Assign<T, U> = Omit<T, keyof U> & U;
+type EmitFn$1<T> = <K extends keyof T>(event: K, ...args: T[K] extends any[] ? T[K] : never) => void;
+type BooleanKey<T> = { [K in keyof T]: boolean extends NonNullable<T[K]> ? K : never; }[keyof T];
+type BooleanDefaults<T> = { [K in BooleanKey<T>]: undefined; };
+type MaybePromise<T> = T | Promise<T>;
+//#endregion
+export { MaybePromise as a, useMachine as c, EmitFn$1 as i, PropTypes as l, Assign as n, Optional as o, BooleanDefaults as r, useSyncExternalStore as s, mergeProps$1 as t, normalizeProps$1 as u };

package/dist/index-BTNfeIXf.d.ts

@@ -0,0 +1,104 @@
+import "./factory-BNwuanv4.js";
+import "./index-BSoF1D-v.js";
+import "./index-Cc4qS0rQ.js";
+import { ComputedRef, DeepReadonly, MaybeRef, ShallowRef } from "vue";
+import { Modality } from "@wirekyt/dom/focus-visible";
+import { FilterOptions, FilterReturn, Locale } from "@wirekyt/dom/i18n-utils";
+import { DateFormatter } from "@internationalized/date";
+//#region src/utils/create-context.d.ts
+type CreateContextReturn<T> = [(opts: T) => void, (fallback?: T) => T, symbol];
+declare const createContext: <T>(id: string) => CreateContextReturn<T>;
+//#endregion
+//#region src/utils/use-emits-as-props.d.ts
+declare function useEmitAsProps<Name extends string>(emit: (name: Name, ...args: any[]) => void): Record<string, any>;
+//#endregion
+//#region src/utils/run-if-fn.d.ts
+declare const runIfFn: <MaybeReturnValue, FunctionArgs>(valueOrFn: MaybeReturnValue | ((...fnArgs: FunctionArgs[]) => MaybeReturnValue), ...args: FunctionArgs[]) => MaybeReturnValue;
+//#endregion
+//#region src/utils/clean-props.d.ts
+declare const cleanProps: <T extends object>(obj: T) => { [K in keyof T]: T[K]; };
+//#endregion
+//#region src/utils/boolean.d.ts
+type Booleanish = boolean | "true" | "false";
+declare const toBooleanValue: (value: Booleanish | undefined) => boolean;
+//#endregion
+//#region src/utils/create-split-props.d.ts
+type EnsureKeys<ExpectedKeys extends (keyof Target)[], Target> = keyof Target extends ExpectedKeys[number] ? unknown : `Missing required keys: ${Exclude<keyof Target, ExpectedKeys[number]> & string}`;
+declare const createSplitProps: <Target>() => <Keys extends (keyof Target)[], Props extends Target = Target>(props: Props, keys: Keys & EnsureKeys<Keys, Target>) => [Target, Omit<Props, Extract<(Keys & EnsureKeys<Keys, Target>)[number], string>>];
+//#endregion
+//#region src/providers/environment/use-context.d.ts
+type RootNode = ShadowRoot | Document | Node;
+interface UseEnvironmentContext {
+  getRootNode(): RootNode;
+  getDocument(): Document;
+  getWindow(): Window & typeof globalThis;
+}
+declare const EnvironmentContextProvider: (opts: ComputedRef<UseEnvironmentContext>) => void, useEnvironmentContext: (fallback?: ComputedRef<UseEnvironmentContext> | undefined) => ComputedRef<UseEnvironmentContext>;
+declare const DEFAULT_ENVIRONMENT: ComputedRef<UseEnvironmentContext>;
+//#endregion
+//#region src/providers/environment/provider.vue.d.ts
+interface EnvironmentProviderProps {
+  value?: RootNode | (() => RootNode);
+}
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+  default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<EnvironmentProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<EnvironmentProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base, __VLS_Slots>;
+declare const _default$1: typeof __VLS_export$1;
+type __VLS_WithSlots$1<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/providers/interaction/use-focus-visible.d.ts
+interface UseFocusVisibleProps {
+  isTextInput?: boolean;
+  autoFocus?: boolean;
+}
+declare function useFocusVisible(props?: UseFocusVisibleProps): Readonly<ShallowRef<boolean>>;
+//#endregion
+//#region src/providers/interaction/use-modality.d.ts
+declare function useInteractionModality(): DeepReadonly<ShallowRef<Modality | null>>;
+//#endregion
+//#region src/providers/locale/provider.vue.d.ts
+interface LocaleProviderProps {
+  locale: string;
+}
+declare const _default: typeof __VLS_export;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LocaleProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LocaleProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/providers/locale/use-collator.d.ts
+interface UseCollatorProps extends Intl.CollatorOptions {
+  locale?: string;
+}
+interface UseCollatorReturn extends ComputedRef<Intl.Collator> {}
+declare function useCollator(propsOrFn?: MaybeRef<UseCollatorProps>): UseCollatorReturn;
+//#endregion
+//#region src/providers/locale/use-date-formatter.d.ts
+interface UseDateFormatterProps extends Intl.DateTimeFormatOptions {
+  locale?: string;
+}
+interface UseDateFormatterReturn extends ComputedRef<DateFormatter> {}
+declare function useDateFormatter(propsOrFn?: MaybeRef<UseDateFormatterProps>): UseDateFormatterReturn;
+//#endregion
+//#region src/providers/locale/use-filter.d.ts
+interface UseFilterProps extends FilterOptions {}
+declare function useFilter(props: UseFilterProps): UseFilterReturn;
+interface UseFilterReturn extends ComputedRef<FilterReturn> {}
+//#endregion
+//#region src/providers/locale/use-context.d.ts
+interface LocaleContext extends Locale {}
+declare const DEFAULT_LOCALE: ComputedRef<LocaleContext>;
+declare const LocaleContextProvider: (opts: ComputedRef<LocaleContext>) => void, useLocaleContext: (fallback?: ComputedRef<LocaleContext> | undefined) => ComputedRef<LocaleContext>;
+//#endregion
+export { createContext as A, UseEnvironmentContext as C, cleanProps as D, toBooleanValue as E, runIfFn as O, RootNode as S, createSplitProps as T, UseFocusVisibleProps as _, UseFilterReturn as a, _default$1 as b, UseDateFormatterReturn as c, UseCollatorReturn as d, useCollator as f, useInteractionModality as g, Modality as h, UseFilterProps as i, useEmitAsProps as k, useDateFormatter as l, _default as m, LocaleContext as n, useFilter as o, LocaleProviderProps as p, useLocaleContext as r, UseDateFormatterProps as s, DEFAULT_LOCALE as t, UseCollatorProps as u, useFocusVisible as v, useEnvironmentContext as w, DEFAULT_ENVIRONMENT as x, EnvironmentProviderProps as y };