@vizejs/ui 0.386.0 → 0.388.0

package/dist/form-runtime-CcMDY0Iq.mjs

@@ -0,0 +1,166 @@
+import { computed, toValue } from "vue";
+//#region src/families/form/form/form-runtime.ts
+const formOptionDiagnostic = "VIZE_UI_FORM_OPTION";
+const formResultDiagnostic = "VIZE_UI_FORM_SCHEMA_RESULT";
+const formSchemaDiagnostic = "VIZE_UI_FORM_SCHEMA";
+const identifierSegmentPattern = /^[A-Za-z_$][\w$]*$/;
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isPropertyKey(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "symbol";
+}
+function assertCallback(value, name) {
+	if (value !== void 0 && typeof value !== "function") throw new TypeError(`${formOptionDiagnostic}: ${name} must be a function`);
+}
+function assertOptions(value, name) {
+	if (!isRecord(value)) throw new TypeError(`${formOptionDiagnostic}: ${name} must be an object`);
+}
+function readName(value) {
+	if (typeof value !== "string" || value.length === 0) throw new TypeError(`${formOptionDiagnostic}: name must resolve to a non-empty string`);
+	return value;
+}
+function readRootId(value) {
+	if (value === void 0) return "form";
+	if (typeof value !== "string" || value.length === 0) throw new TypeError(`${formOptionDiagnostic}: rootId must resolve to a non-empty string`);
+	return value;
+}
+function readFieldErrors(value) {
+	const resolved = toValue(value);
+	if (resolved === void 0) return [];
+	if (!Array.isArray(resolved)) throw new TypeError(`${formOptionDiagnostic}: errors must resolve to an array`);
+	for (const error of resolved) {
+		if (!isRecord(error)) throw new TypeError(`${formOptionDiagnostic}: every error must be an object`);
+		if (typeof error.name !== "string") throw new TypeError(`${formOptionDiagnostic}: every error needs a name string`);
+		if (typeof error.message !== "string") throw new TypeError(`${formOptionDiagnostic}: every error needs a message string`);
+		if (!Array.isArray(error.path)) throw new TypeError(`${formOptionDiagnostic}: every error needs a path array`);
+	}
+	return resolved;
+}
+function readIssuePath(issue) {
+	const path = issue.path;
+	if (path === void 0) return Object.freeze([]);
+	if (!Array.isArray(path)) throw new TypeError(`${formResultDiagnostic}: issue path must be an array`);
+	return Object.freeze(path.map((segment) => {
+		if (isPropertyKey(segment)) return segment;
+		if (isRecord(segment) && isPropertyKey(segment.key)) return segment.key;
+		throw new TypeError(`${formResultDiagnostic}: issue path segments must contain property keys`);
+	}));
+}
+function formatSegment(key, index) {
+	const segment = String(key);
+	if (typeof key === "number") return `[${segment}]`;
+	if (identifierSegmentPattern.test(segment)) return index === 0 ? segment : `.${segment}`;
+	return `[${JSON.stringify(segment)}]`;
+}
+/** Convert a Standard Schema issue path into a conventional HTML field name. */
+function formatFormFieldName(path) {
+	if (!Array.isArray(path)) throw new TypeError(`${formOptionDiagnostic}: path must be an array`);
+	return path.map(formatSegment).join("");
+}
+/** Convert Standard Schema issues into normalized field errors. */
+function normalizeStandardSchemaIssues(issues, options = {}) {
+	assertOptions(options, "options");
+	assertCallback(options.nameForPath, "nameForPath");
+	return Object.freeze(issues.map((issue) => {
+		if (!isRecord(issue)) throw new TypeError(`${formResultDiagnostic}: every issue must be an object`);
+		if (typeof issue.message !== "string") throw new TypeError(`${formResultDiagnostic}: every issue needs a message string`);
+		const path = readIssuePath(issue);
+		const name = options.nameForPath?.(path, issue) ?? formatFormFieldName(path);
+		if (typeof name !== "string") throw new TypeError(`${formOptionDiagnostic}: nameForPath must return a string`);
+		return Object.freeze({
+			message: issue.message,
+			name,
+			path
+		});
+	}));
+}
+/** Convert normalized field errors into unique fields for the error summary. */
+function createFormErrorSummaryFields(errors, options = {}) {
+	assertOptions(options, "options");
+	assertCallback(options.idForName, "idForName");
+	assertCallback(options.labelForName, "labelForName");
+	const rootId = readRootId(options.rootId);
+	const fields = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const error of readFieldErrors(errors)) {
+		const fallbackId = error.name.length === 0 ? rootId : error.name;
+		const id = options.idForName?.(error.name, error) ?? fallbackId;
+		if (id === null) continue;
+		if (id === void 0) continue;
+		if (typeof id !== "string" || id.length === 0) throw new TypeError(`${formOptionDiagnostic}: idForName must return a non-empty string`);
+		if (seen.has(id)) continue;
+		seen.add(id);
+		const label = error.name.length === 0 ? options.rootLabel : options.labelForName?.(error.name, error);
+		fields.push(Object.freeze(label === void 0 ? {
+			id,
+			message: error.message
+		} : {
+			id,
+			label,
+			message: error.message
+		}));
+	}
+	return Object.freeze(fields);
+}
+/** Normalize a Standard Schema validation result for form fields and summaries. */
+function normalizeStandardSchemaResult(result, options = {}) {
+	assertOptions(options, "options");
+	if (!isRecord(result)) throw new TypeError(`${formResultDiagnostic}: result must be an object`);
+	if (Array.isArray(result.issues)) {
+		const errors = normalizeStandardSchemaIssues(result.issues, options);
+		return Object.freeze({
+			errors,
+			summaryFields: createFormErrorSummaryFields(errors, options),
+			valid: false
+		});
+	}
+	if (result.issues === void 0 && "value" in result) return Object.freeze({
+		errors: Object.freeze([]),
+		summaryFields: Object.freeze([]),
+		valid: true,
+		value: result.value
+	});
+	throw new TypeError(`${formResultDiagnostic}: result must contain value or issues`);
+}
+/** Validate a Standard Schema and normalize the result for form consumers. */
+async function validateStandardSchema(schema, value, options = {}) {
+	assertOptions(options, "options");
+	const standard = schema?.["~standard"];
+	if (!isRecord(standard) || standard.version !== 1 || typeof standard.validate !== "function") throw new TypeError(`${formSchemaDiagnostic}: schema must implement Standard Schema V1`);
+	const validationOptions = options.libraryOptions === void 0 ? void 0 : { libraryOptions: options.libraryOptions };
+	return normalizeStandardSchemaResult(await standard.validate(value, validationOptions), options);
+}
+/** Create normalized field state whose invalid flag can feed existing field wiring. */
+function useFormField(options) {
+	assertOptions(options, "options");
+	const name = computed(() => readName(toValue(options.name)));
+	const errors = computed(() => readFieldErrors(options.errors).filter((error) => error.name === name.value));
+	const firstError = computed(() => errors.value[0]);
+	const errorMessage = computed(() => firstError.value?.message);
+	const isInvalid = computed(() => errors.value.length > 0);
+	return Object.freeze({
+		errorMessage,
+		errors,
+		firstError,
+		isInvalid,
+		name
+	});
+}
+/** Create error-summary fields from normalized form errors. */
+function useFormErrorSummary(options = {}) {
+	assertOptions(options, "options");
+	const fields = computed(() => createFormErrorSummaryFields(readFieldErrors(options.errors), {
+		...options.idForName === void 0 ? {} : { idForName: options.idForName },
+		...options.labelForName === void 0 ? {} : { labelForName: options.labelForName },
+		rootId: readRootId(toValue(options.rootId)),
+		...options.rootLabel === void 0 ? {} : { rootLabel: options.rootLabel }
+	}));
+	const hasErrors = computed(() => fields.value.length > 0);
+	return Object.freeze({
+		fields,
+		hasErrors
+	});
+}
+//#endregion
+export { useFormErrorSummary as a, normalizeStandardSchemaResult as i, formatFormFieldName as n, useFormField as o, normalizeStandardSchemaIssues as r, validateStandardSchema as s, createFormErrorSummaryFields as t };

package/dist/form-types-DXwZRLcs.d.mts

@@ -0,0 +1,183 @@
+import { n as ErrorSummaryField } from "./error-summary-types-5ePaC9O3.mjs";
+import { ComputedRef, MaybeRefOrGetter } from "vue";
+
+//#region src/families/form/form/form-types.d.ts
+/** Structural Standard Schema V1 contract accepted by the form utilities. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** Standard Schema metadata and validation entry point. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** Standard Schema metadata and validation entry point. */
+  interface Props<Input = unknown, Output = Input> {
+    /** Version number of the Standard Schema contract. */
+    readonly version: 1;
+    /** Schema-library vendor name. */
+    readonly vendor: string;
+    /** Validate unknown input and return either a value or issues. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options) => Result<Output> | Promise<Result<Output>>;
+    /** Optional phantom input and output types advertised by the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** Standard Schema validation result. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** Successful Standard Schema validation result. */
+  interface SuccessResult<Output> {
+    /** Typed output value. */
+    readonly value: Output;
+    /** Success is represented by no issues. */
+    readonly issues?: undefined;
+  }
+  /** Standard Schema validation options. */
+  interface Options {
+    /** Vendor-specific options passed through to the schema library. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** Failed Standard Schema validation result. */
+  interface FailureResult {
+    /** Failed-validation issues. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** One Standard Schema validation issue. */
+  interface Issue {
+    /** Human-readable validation message. */
+    readonly message: string;
+    /** Path of the invalid value, if known. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** Object path segment used by some schema libraries. */
+  interface PathSegment {
+    /** Key represented by this segment. */
+    readonly key: PropertyKey;
+  }
+  /** Phantom input and output types advertised by the schema. */
+  interface Types<Input = unknown, Output = Input> {
+    /** Input type accepted by the schema. */
+    readonly input: Input;
+    /** Output type returned by the schema. */
+    readonly output: Output;
+  }
+  /** Infer the input type advertised by a Standard Schema. */
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infer the output type advertised by a Standard Schema. */
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** Property key after a Standard Schema path segment has been unwrapped. */
+type FormPathKey = PropertyKey;
+/** One normalized field validation error. */
+interface FormFieldError {
+  /** HTML form field name derived from the issue path. */
+  readonly name: string;
+  /** Human-readable validation message. */
+  readonly message: string;
+  /** Unwrapped Standard Schema path keys. */
+  readonly path: readonly FormPathKey[];
+}
+/** Options for converting Standard Schema issues into field errors. */
+interface FormFieldErrorOptions {
+  /**
+   * Convert an unwrapped Standard Schema issue path into a form field name.
+   *
+   * @default dot/bracket path formatting
+   */
+  readonly nameForPath?: (path: readonly FormPathKey[], issue: StandardSchemaV1.Issue) => string;
+}
+/** Options for converting normalized field errors into error-summary fields. */
+interface FormErrorSummaryFieldOptions {
+  /**
+   * Resolve the document id for a field error.
+   *
+   * @default the normalized field name, or `rootId` for form-level errors
+   */
+  readonly idForName?: (name: string, error: FormFieldError) => string | null | undefined;
+  /**
+   * Resolve the accessible field label displayed before the summary message.
+   *
+   * @default undefined
+   */
+  readonly labelForName?: (name: string, error: FormFieldError) => string | undefined;
+  /**
+   * Document id used for form-level errors with no field path.
+   *
+   * @default "form"
+   */
+  readonly rootId?: string;
+  /**
+   * Label used for form-level errors with no field path.
+   *
+   * @default undefined
+   */
+  readonly rootLabel?: string;
+}
+/** Normalized successful form validation state. */
+interface FormValidationSuccess<Output> {
+  /** Whether validation succeeded. */
+  readonly valid: true;
+  /** Typed output value from the schema. */
+  readonly value: Output;
+  /** Normalized field errors. Empty on success. */
+  readonly errors: readonly FormFieldError[];
+  /** Error-summary fields. Empty on success. */
+  readonly summaryFields: readonly [];
+}
+/** Normalized failed form validation state. */
+interface FormValidationFailure {
+  /** Whether validation succeeded. */
+  readonly valid: false;
+  /** Normalized field errors. */
+  readonly errors: readonly FormFieldError[];
+  /** Error-summary fields, one per document id. */
+  readonly summaryFields: readonly ErrorSummaryField[];
+}
+/** Normalized form validation state. */
+type FormValidationResult<Output> = FormValidationSuccess<Output> | FormValidationFailure;
+/** Options for validating and normalizing a Standard Schema form result. */
+interface StandardSchemaValidationOptions extends FormFieldErrorOptions, FormErrorSummaryFieldOptions, StandardSchemaV1.Options {}
+/** Options accepted by {@link useFormField}. */
+interface FormFieldOptions {
+  /** Normalized HTML form field name. */
+  readonly name: MaybeRefOrGetter<string>;
+  /**
+   * Full normalized form error list.
+   *
+   * @default []
+   */
+  readonly errors?: MaybeRefOrGetter<readonly FormFieldError[] | undefined>;
+}
+/** Reactive normalized errors and invalid state for one form field. */
+interface FormFieldController {
+  /** Normalized HTML form field name. */
+  readonly name: ComputedRef<string>;
+  /** Whether this field currently has at least one normalized error. */
+  readonly isInvalid: ComputedRef<boolean>;
+  /** Current errors for this field only. */
+  readonly errors: ComputedRef<readonly FormFieldError[]>;
+  /** First current error for this field. */
+  readonly firstError: ComputedRef<FormFieldError | undefined>;
+  /** First current error message for this field. */
+  readonly errorMessage: ComputedRef<string | undefined>;
+}
+/** Options accepted by {@link useFormErrorSummary}. */
+interface FormErrorSummaryOptions extends Omit<FormErrorSummaryFieldOptions, "rootId"> {
+  /**
+   * Full normalized form error list.
+   *
+   * @default []
+   */
+  readonly errors?: MaybeRefOrGetter<readonly FormFieldError[] | undefined>;
+  /**
+   * Document id used for form-level errors with no field path.
+   *
+   * @default "form"
+   */
+  readonly rootId?: MaybeRefOrGetter<string | undefined>;
+}
+/** Reactive error-summary fields derived from normalized form errors. */
+interface FormErrorSummaryController {
+  /** Fields ready to pass into the error-summary component or controller. */
+  readonly fields: ComputedRef<readonly ErrorSummaryField[]>;
+  /** Whether at least one summary field is currently available. */
+  readonly hasErrors: ComputedRef<boolean>;
+}
+//#endregion
+export { FormFieldError as a, FormPathKey as c, FormValidationSuccess as d, StandardSchemaV1 as f, FormFieldController as i, FormValidationFailure as l, FormErrorSummaryFieldOptions as n, FormFieldErrorOptions as o, StandardSchemaValidationOptions as p, FormErrorSummaryOptions as r, FormFieldOptions as s, FormErrorSummaryController as t, FormValidationResult as u };

package/dist/form.d.mts

@@ -0,0 +1,3 @@
+import { a as FormFieldError, c as FormPathKey, d as FormValidationSuccess, f as StandardSchemaV1, i as FormFieldController, l as FormValidationFailure, n as FormErrorSummaryFieldOptions, o as FormFieldErrorOptions, p as StandardSchemaValidationOptions, r as FormErrorSummaryOptions, s as FormFieldOptions, t as FormErrorSummaryController, u as FormValidationResult } from "./form-types-DXwZRLcs.mjs";
+import { a as useFormErrorSummary, i as normalizeStandardSchemaResult, n as formatFormFieldName, o as useFormField, r as normalizeStandardSchemaIssues, s as validateStandardSchema, t as createFormErrorSummaryFields } from "./form-1V2V30Sv.mjs";
+export { type FormErrorSummaryController, type FormErrorSummaryFieldOptions, type FormErrorSummaryOptions, type FormFieldController, type FormFieldError, type FormFieldErrorOptions, type FormFieldOptions, type FormPathKey, type FormValidationFailure, type FormValidationResult, type FormValidationSuccess, type StandardSchemaV1, type StandardSchemaValidationOptions, createFormErrorSummaryFields, formatFormFieldName, normalizeStandardSchemaIssues, normalizeStandardSchemaResult, useFormErrorSummary, useFormField, validateStandardSchema };

package/dist/form.mjs

@@ -0,0 +1,2 @@
+import { a as useFormErrorSummary, i as normalizeStandardSchemaResult, n as formatFormFieldName, o as useFormField, r as normalizeStandardSchemaIssues, s as validateStandardSchema, t as createFormErrorSummaryFields } from "./form-runtime-CcMDY0Iq.mjs";
+export { createFormErrorSummaryFields, formatFormFieldName, normalizeStandardSchemaIssues, normalizeStandardSchemaResult, useFormErrorSummary, useFormField, validateStandardSchema };

package/dist/fullscreen-button-NTbC4R0W.mjs

@@ -0,0 +1,276 @@
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { computed, createBlock, createElementVNode, defineComponent, guardReactiveProps, normalizeProps, openBlock, renderSlot, resolveDynamicComponent, shallowRef, toDisplayString, toRaw, useTemplateRef, withCtx } from "vue";
+//#region src/families/actions/fullscreen-button/fullscreen-button.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = {
+	"data-vize-ui": "fullscreen-button-label",
+	part: "label"
+};
+const FULLSCREEN_BUTTON_ACTION_UNAVAILABLE = "VIZE_UI_FULLSCREEN_BUTTON_ACTION_UNAVAILABLE";
+//#endregion
+//#region src/families/actions/fullscreen-button/fullscreen-button.vue
+var fullscreen_button_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "fullscreen-button",
+	props: {
+		as: {
+			type: null,
+			required: false,
+			default: "button"
+		},
+		native: {
+			type: Boolean,
+			required: false,
+			default: () => void 0
+		},
+		type: {
+			type: String,
+			required: false,
+			default: "button"
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		enterLabel: {
+			type: String,
+			required: false,
+			default: "Enter fullscreen"
+		},
+		exitLabel: {
+			type: String,
+			required: false,
+			default: "Exit fullscreen"
+		},
+		busyLabel: {
+			type: String,
+			required: false,
+			default: "Changing fullscreen"
+		},
+		errorLabel: {
+			type: String,
+			required: false,
+			default: "Fullscreen failed"
+		},
+		ariaLabel: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		ariaLabelledby: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		ariaDescribedby: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		target: {
+			type: [null, Function],
+			required: false,
+			skipCheck: true,
+			default: void 0
+		},
+		controller: {
+			type: Object,
+			required: false,
+			default: () => void 0
+		}
+	},
+	emits: ["fullscreen", "error"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const emit = __emit;
+		const element = useTemplateRef("element");
+		const stateValue = shallowRef("idle");
+		const activeValue = shallowRef(false);
+		const operationValue = shallowRef(null);
+		const isNativeButton = computed(() => __props.native ?? __props.as === "button");
+		const buttonType = computed(() => __props.type);
+		const disabledValue = computed(() => __props.disabled);
+		const pendingValue = computed(() => stateValue.value === "entering" || stateValue.value === "exiting");
+		const pendingOperation = computed(() => operationValue.value?.type ?? null);
+		const unavailable = computed(() => disabledValue.value || pendingValue.value);
+		const controllerValue = computed(() => toRaw(__props.controller ?? platformFullscreenController));
+		const label = computed(() => pendingValue.value ? __props.busyLabel : stateValue.value === "error" ? __props.errorLabel : activeValue.value ? __props.exitLabel : __props.enterLabel);
+		const tabIndex = computed(() => {
+			if (isNativeButton.value) return void 0;
+			return disabledValue.value ? -1 : 0;
+		});
+		const ariaLabelValue = computed(() => hasText(__props.ariaLabel) ? __props.ariaLabel : void 0);
+		const ariaLabelledbyValue = computed(() => hasText(__props.ariaLabelledby) ? __props.ariaLabelledby : void 0);
+		const slotState = computed(() => ({
+			active: activeValue.value,
+			disabled: disabledValue.value,
+			label: label.value,
+			operation: pendingOperation.value,
+			pending: pendingValue.value,
+			state: stateValue.value,
+			unavailable: unavailable.value
+		}));
+		function onClick(event) {
+			if (unavailable.value) {
+				event.preventDefault();
+				event.stopImmediatePropagation();
+				return;
+			}
+			runFullscreenOperation(createFullscreenOperation(controllerValue.value, __props.target, event), event);
+		}
+		async function runFullscreenOperation(submittedOperation, event) {
+			operationValue.value = submittedOperation;
+			stateValue.value = submittedOperation.type === "enter" ? "entering" : "exiting";
+			if (submittedOperation.type === "exit") activeValue.value = true;
+			try {
+				if (submittedOperation.type === "enter") {
+					if (submittedOperation.target === null) throw new Error(FULLSCREEN_BUTTON_ACTION_UNAVAILABLE);
+					await submittedOperation.controller.requestFullscreen(submittedOperation.target, event);
+					activeValue.value = true;
+					stateValue.value = "active";
+				} else {
+					await submittedOperation.controller.exitFullscreen(event);
+					activeValue.value = false;
+					stateValue.value = "idle";
+				}
+				emit("fullscreen", submittedOperation, event);
+			} catch (error) {
+				activeValue.value = submittedOperation.type === "exit";
+				stateValue.value = "error";
+				emit("error", error, submittedOperation, event);
+			} finally {
+				if (operationValue.value === submittedOperation) operationValue.value = null;
+			}
+		}
+		function createFullscreenOperation(submittedController, submittedTarget, event) {
+			const activeTarget = getFullscreenElement(submittedController);
+			if (activeTarget !== null || activeValue.value) return {
+				controller: submittedController,
+				target: activeTarget,
+				type: "exit"
+			};
+			return {
+				controller: submittedController,
+				target: resolveFullscreenTarget(submittedTarget, event),
+				type: "enter"
+			};
+		}
+		function resolveFullscreenTarget(submittedTarget, event) {
+			if (typeof submittedTarget === "function") return normalizeElement(submittedTarget(event));
+			if (submittedTarget !== void 0) return normalizeElement(submittedTarget);
+			return getPlatformDocument()?.documentElement ?? null;
+		}
+		function getFullscreenElement(submittedController) {
+			return normalizeElement(submittedController.getFullscreenElement?.());
+		}
+		function normalizeElement(value) {
+			if (value == null) return null;
+			if (typeof Element === "undefined") return null;
+			return value instanceof Element ? value : null;
+		}
+		function onKeyboard(event, phase) {
+			if (isNativeButton.value) return;
+			const keyboardAction = getFullscreenButtonKeyboardAction(event.key, phase);
+			if (keyboardAction === "ignore") return;
+			event.preventDefault();
+			if (unavailable.value) {
+				event.stopImmediatePropagation();
+				return;
+			}
+			if (keyboardAction === "activate" && event.currentTarget instanceof HTMLElement) event.currentTarget.click();
+		}
+		function onKeydown(event) {
+			onKeyboard(event, "keydown");
+		}
+		function onKeyup(event) {
+			onKeyboard(event, "keyup");
+		}
+		function getFullscreenButtonKeyboardAction(key, phase) {
+			if (key === "Enter") return phase === "keydown" ? "activate" : "ignore";
+			if (key === " ") return phase === "keydown" ? "prevent" : "activate";
+			return "ignore";
+		}
+		function focus(options) {
+			focusTarget(element.value, options);
+		}
+		function focusTarget(targetElement, options) {
+			if (typeof targetElement === "object" && targetElement !== null && "focus" in targetElement && typeof targetElement.focus === "function") targetElement.focus(options);
+		}
+		function getPlatformDocument() {
+			return typeof globalThis.document === "undefined" ? null : globalThis.document;
+		}
+		const platformFullscreenController = {
+			getFullscreenElement() {
+				return getPlatformDocument()?.fullscreenElement ?? null;
+			},
+			requestFullscreen(targetElement) {
+				const requestFullscreen = targetElement.requestFullscreen;
+				if (typeof requestFullscreen !== "function") throw new Error(FULLSCREEN_BUTTON_ACTION_UNAVAILABLE);
+				return requestFullscreen.call(targetElement);
+			},
+			exitFullscreen() {
+				const platformDocument = getPlatformDocument();
+				const exitFullscreen = platformDocument?.exitFullscreen;
+				if (typeof exitFullscreen !== "function") throw new Error(FULLSCREEN_BUTTON_ACTION_UNAVAILABLE);
+				return exitFullscreen.call(platformDocument);
+			}
+		};
+		function hasText(nextValue) {
+			return nextValue != null && nextValue.trim().length > 0;
+		}
+		__expose({
+			active: activeValue,
+			disabled: disabledValue,
+			element,
+			focus,
+			label,
+			operation: pendingOperation,
+			pending: pendingValue,
+			state: stateValue,
+			unavailable
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent(__props.as), {
+				ref_key: "element",
+				ref: element,
+				type: isNativeButton.value ? buttonType.value : void 0,
+				disabled: isNativeButton.value ? disabledValue.value : void 0,
+				role: isNativeButton.value ? void 0 : "button",
+				tabindex: tabIndex.value,
+				"aria-label": ariaLabelledbyValue.value === void 0 ? ariaLabelValue.value : void 0,
+				"aria-labelledby": ariaLabelledbyValue.value,
+				"aria-describedby": __props.ariaDescribedby,
+				"aria-pressed": activeValue.value ? "true" : "false",
+				"aria-disabled": unavailable.value && (!isNativeButton.value || pendingValue.value) ? "true" : void 0,
+				"aria-busy": pendingValue.value ? "true" : void 0,
+				"data-vize-ui": "fullscreen-button",
+				part: "root",
+				"data-state": stateValue.value,
+				"data-disabled": disabledValue.value ? "true" : void 0,
+				"data-active": activeValue.value ? "true" : void 0,
+				"data-pending": pendingValue.value ? "true" : void 0,
+				onClick,
+				onKeydown,
+				onKeyup
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotState.value)), () => [createElementVNode("span", _hoisted_1, toDisplayString(label.value), 1)], true)]),
+				_: 3
+			}, 40, [
+				"type",
+				"disabled",
+				"role",
+				"tabindex",
+				"aria-label",
+				"aria-labelledby",
+				"aria-describedby",
+				"aria-pressed",
+				"aria-disabled",
+				"aria-busy",
+				"data-state",
+				"data-disabled",
+				"data-active",
+				"data-pending"
+			]);
+		};
+	}
+}), [["__scopeId", "data-v-b9f58744"]]);
+//#endregion
+export { fullscreen_button_default as t };

package/dist/fullscreen-button.d.mts

@@ -0,0 +1,2 @@
+import { $a as FullscreenButtonElement, Ja as _default, Qa as FullscreenButtonDataName, Xa as FullscreenButtonCssCustomProperty, Ya as FullscreenButtonController, Za as FullscreenButtonDataAttribute, ao as FullscreenButtonProps, co as FullscreenButtonState, eo as FullscreenButtonEmits, io as FullscreenButtonPart, lo as FullscreenButtonTarget, no as FullscreenButtonOperation, oo as FullscreenButtonSlotState, ro as FullscreenButtonOperationType, so as FullscreenButtonSlots, to as FullscreenButtonExpose, uo as FullscreenButtonType } from "./announcer-DGr2Iz0i.mjs";
+export { _default as FullscreenButton, type FullscreenButtonController, type FullscreenButtonCssCustomProperty, type FullscreenButtonDataAttribute, type FullscreenButtonDataName, type FullscreenButtonElement, type FullscreenButtonEmits, type FullscreenButtonExpose, type FullscreenButtonOperation, type FullscreenButtonOperationType, type FullscreenButtonPart, type FullscreenButtonProps, type FullscreenButtonSlotState, type FullscreenButtonSlots, type FullscreenButtonState, type FullscreenButtonTarget, type FullscreenButtonType };

package/dist/fullscreen-button.mjs

@@ -0,0 +1,2 @@
+import { t as fullscreen_button_default } from "./fullscreen-button-NTbC4R0W.mjs";
+export { fullscreen_button_default as FullscreenButton };