ropav 0.2.0 → 0.3.0

package/dist/utils/create-context.d.ts

@@ -0,0 +1,39 @@
+interface CreateContextBaseOptions {
+    /** Human readable name, used for the injection key and in the error message. */
+    name: string;
+    /** Overrides the message thrown when a consumer has no provider above it. */
+    errorMessage?: string;
+}
+export interface CreateStrictContextOptions extends CreateContextBaseOptions {
+    /**
+     * Whether consuming the context without a provider throws.
+     * @default true
+     */
+    strict?: true;
+}
+export interface CreateLooseContextOptions<T> extends CreateContextBaseOptions {
+    strict: false;
+    /** Returned when no provider is found. Required, so the return type stays honest. */
+    defaultValue: T;
+}
+export type CreateContextOptions<T> = CreateStrictContextOptions | CreateLooseContextOptions<T>;
+export type CreateContextReturn<T> = [useContext: () => T, provideContext: (value: T) => T];
+/**
+ * Create a typed `provide`/`inject` pair, the Vue counterpart of React's
+ * `createContext` + `use()`. Used to share slot functions and state between the
+ * parts of a compound component.
+ *
+ * Both returned functions must be called during `setup()`.
+ *
+ * @example
+ * ```ts
+ * // accordion.context.ts
+ * export const [useAccordionContext, provideAccordionContext] =
+ *   createContext<AccordionContext>({name: "AccordionContext"});
+ *
+ * // accordion-root.vue — provideAccordionContext({slots, hideSeparator})
+ * // accordion-item.vue — const {slots} = useAccordionContext()
+ * ```
+ */
+export declare const createContext: <T>(options: CreateContextOptions<T>) => CreateContextReturn<T>;
+export {};

package/dist/utils/create-context.js

@@ -0,0 +1,35 @@
+import { inject, provide } from "vue";
+//#region src/utils/create-context.ts
+/**
+* Create a typed `provide`/`inject` pair, the Vue counterpart of React's
+* `createContext` + `use()`. Used to share slot functions and state between the
+* parts of a compound component.
+*
+* Both returned functions must be called during `setup()`.
+*
+* @example
+* ```ts
+* // accordion.context.ts
+* export const [useAccordionContext, provideAccordionContext] =
+*   createContext<AccordionContext>({name: "AccordionContext"});
+*
+* // accordion-root.vue — provideAccordionContext({slots, hideSeparator})
+* // accordion-item.vue — const {slots} = useAccordionContext()
+* ```
+*/
+var createContext = (options) => {
+	const { errorMessage, name } = options;
+	const key = Symbol(name);
+	const provideContext = (value) => {
+		provide(key, value);
+		return value;
+	};
+	const useContext = () => {
+		const context = inject(key, options.strict === false ? options.defaultValue : void 0);
+		if (context === void 0) throw new Error(errorMessage ?? `\`${name}\` was consumed outside of its provider component.`);
+		return context;
+	};
+	return [useContext, provideContext];
+};
+//#endregion
+export { createContext };

package/dist/utils/css.d.ts

@@ -1,3 +1,14 @@
-export type CssLength = number | string | null | undefined;
-export declare function toCssLength(value: CssLength): string | undefined;
-export declare function toPositiveCssLength(value: CssLength): string | undefined;
+/**
+ * Read a CSS time value as a number of milliseconds.
+ *
+ * A bare number is taken as milliseconds, which is what a custom property holding `0` rather than
+ * `0ms` means in practice.
+ *
+ * @example
+ * ```ts
+ * parseCssTime("1500ms"); // 1500
+ * parseCssTime("1.5s"); // 1500
+ * parseCssTime(undefined); // undefined
+ * ```
+ */
+export declare const parseCssTime: (value: string | undefined) => number | undefined;

package/dist/utils/css.js

@@ -0,0 +1,25 @@
+//#region src/utils/css.ts
+/**
+* Read a CSS time value as a number of milliseconds.
+*
+* A bare number is taken as milliseconds, which is what a custom property holding `0` rather than
+* `0ms` means in practice.
+*
+* @example
+* ```ts
+* parseCssTime("1500ms"); // 1500
+* parseCssTime("1.5s"); // 1500
+* parseCssTime(undefined); // undefined
+* ```
+*/
+var parseCssTime = (value) => {
+	if (!value) return void 0;
+	const trimmed = value.trim();
+	const parsed = Number.parseFloat(trimmed);
+	if (Number.isNaN(parsed)) return void 0;
+	if (trimmed.endsWith("ms")) return parsed;
+	if (trimmed.endsWith("s")) return parsed * 1e3;
+	return parsed;
+};
+//#endregion
+export { parseCssTime };

package/dist/utils/date-format.d.ts

@@ -0,0 +1,45 @@
+import type { Calendar, CalendarDateTime, DateValue, ZonedDateTime } from "@internationalized/date";
+import { Time } from "@internationalized/date";
+/**
+ * Anything carrying a time of day.
+ *
+ * Declared here because `@internationalized/date` exports the classes but not this union —
+ * upstream it comes from `@react-types/shared`, which is React-only.
+ */
+export type TimeValue = Time | CalendarDateTime | ZonedDateTime;
+/** How precise a date value is, which is also the last segment a field shows. */
+export type Granularity = "day" | "hour" | "minute" | "second";
+/** The coarsest segment a field shows, which is also where its list of segments starts. */
+export type MaxGranularity = "year" | "month" | Granularity;
+/** The subset of `Intl.DateTimeFormat` options that name a segment. */
+export type FieldOptions = Pick<Intl.DateTimeFormatOptions, "day" | "hour" | "minute" | "month" | "second" | "year">;
+export interface FormatterOptions {
+    timeZone?: string | undefined;
+    hideTimeZone?: boolean | undefined;
+    granularity?: Granularity | undefined;
+    maxGranularity?: MaxGranularity | undefined;
+    hourCycle?: 12 | 24 | undefined;
+    showEra?: boolean | undefined;
+    shouldForceLeadingZeros?: boolean | undefined;
+}
+/**
+ * Turn a granularity range into the `Intl.DateTimeFormat` options that produce exactly those
+ * segments, ported from react-stately's `packages/react-stately/src/datepicker/utils.ts`
+ * (react-stately 3.49.0).
+ *
+ * This is what decides which segments a date field has at all: the options are the slice of the
+ * field list between `maxGranularity` and `granularity`, so a field asking for year-to-day gets
+ * three segments and one asking for year-to-minute gets five.
+ */
+export declare const getFormatOptions: (fieldOptions: FieldOptions, options: FormatterOptions) => Intl.DateTimeFormatOptions;
+/** The time a field falls back to when it has a date but no time to go with it. */
+export declare const getPlaceholderTime: (placeholderValue: DateValue | null | undefined) => TimeValue | Time;
+/** Re-express a value in another calendar system, preserving the null/undefined distinction. */
+export declare const convertValue: (value: DateValue | null | undefined, calendar: Calendar) => DateValue | null | undefined;
+/**
+ * The date an empty field stands on while its segments are still blank.
+ *
+ * Midnight today, in the right calendar system, trimmed to the shape the granularity needs — a
+ * field has to have *some* date to step from before anything has been typed into it.
+ */
+export declare const createPlaceholderDate: (placeholderValue: DateValue | null | undefined, granularity: string, calendar: Calendar, timeZone: string | undefined) => DateValue;

package/dist/utils/date-format.js

@@ -0,0 +1,78 @@
+import { Time, getLocalTimeZone, now, toCalendar, toCalendarDate, toCalendarDateTime } from "@internationalized/date";
+//#region src/utils/date-format.ts
+var DEFAULT_FIELD_OPTIONS = {
+	year: "numeric",
+	month: "numeric",
+	day: "numeric",
+	hour: "numeric",
+	minute: "2-digit",
+	second: "2-digit"
+};
+var TWO_DIGIT_FIELD_OPTIONS = {
+	year: "numeric",
+	month: "2-digit",
+	day: "2-digit",
+	hour: "2-digit",
+	minute: "2-digit",
+	second: "2-digit"
+};
+/**
+* Turn a granularity range into the `Intl.DateTimeFormat` options that produce exactly those
+* segments, ported from react-stately's `packages/react-stately/src/datepicker/utils.ts`
+* (react-stately 3.49.0).
+*
+* This is what decides which segments a date field has at all: the options are the slice of the
+* field list between `maxGranularity` and `granularity`, so a field asking for year-to-day gets
+* three segments and one asking for year-to-minute gets five.
+*/
+var getFormatOptions = (fieldOptions, options) => {
+	const resolved = {
+		...options.shouldForceLeadingZeros ? TWO_DIGIT_FIELD_OPTIONS : DEFAULT_FIELD_OPTIONS,
+		...fieldOptions
+	};
+	const granularity = options.granularity ?? "minute";
+	const keys = Object.keys(resolved);
+	let startIdx = keys.indexOf(options.maxGranularity ?? "year");
+	if (startIdx < 0) startIdx = 0;
+	let endIdx = keys.indexOf(granularity);
+	if (endIdx < 0) endIdx = 2;
+	if (startIdx > endIdx) throw new Error("maxGranularity must be greater than granularity");
+	const opts = {};
+	for (const key of keys.slice(startIdx, endIdx + 1)) opts[key] = resolved[key];
+	if (options.hourCycle != null) opts.hour12 = options.hourCycle === 12;
+	opts.timeZone = options.timeZone || "UTC";
+	if ((granularity === "hour" || granularity === "minute" || granularity === "second") && options.timeZone && !options.hideTimeZone) opts.timeZoneName = "short";
+	if (options.showEra && startIdx === 0) opts.era = "short";
+	return opts;
+};
+/** The time a field falls back to when it has a date but no time to go with it. */
+var getPlaceholderTime = (placeholderValue) => {
+	if (placeholderValue && "hour" in placeholderValue) return placeholderValue;
+	return new Time();
+};
+/** Re-express a value in another calendar system, preserving the null/undefined distinction. */
+var convertValue = (value, calendar) => {
+	if (value === null) return null;
+	if (!value) return void 0;
+	return toCalendar(value, calendar);
+};
+/**
+* The date an empty field stands on while its segments are still blank.
+*
+* Midnight today, in the right calendar system, trimmed to the shape the granularity needs — a
+* field has to have *some* date to step from before anything has been typed into it.
+*/
+var createPlaceholderDate = (placeholderValue, granularity, calendar, timeZone) => {
+	if (placeholderValue) return convertValue(placeholderValue, calendar);
+	const date = toCalendar(now(timeZone ?? getLocalTimeZone()).set({
+		hour: 0,
+		millisecond: 0,
+		minute: 0,
+		second: 0
+	}), calendar);
+	if (granularity === "year" || granularity === "month" || granularity === "day") return toCalendarDate(date);
+	if (!timeZone) return toCalendarDateTime(date);
+	return date;
+};
+//#endregion
+export { convertValue, createPlaceholderDate, getFormatOptions, getPlaceholderTime };

package/dist/utils/date-placeholder.d.ts

@@ -0,0 +1,9 @@
+/**
+ * What an empty segment shows before anything is typed into it, ported from react-stately's
+ * `packages/react-stately/src/datepicker/placeholders.ts` (react-stately 3.49.0).
+ *
+ * Only year, month and day get a spelled-out word. An era or day period shows the real value it
+ * would take, because there is no useful abbreviation for "AD" or "AM"; every time field falls
+ * back to two dashes.
+ */
+export declare const getDatePlaceholder: (field: string, value: string, locale: string) => string;

package/dist/utils/date-placeholder.js

@@ -0,0 +1,20 @@
+import { datePlaceholders } from "../i18n/date-placeholders.js";
+import { LocalizedStringDictionary } from "@internationalized/string";
+//#region src/utils/date-placeholder.ts
+/** Built once: the table is fixed and the dictionary is read-only after construction. */
+var dictionary = new LocalizedStringDictionary(datePlaceholders, "en");
+/**
+* What an empty segment shows before anything is typed into it, ported from react-stately's
+* `packages/react-stately/src/datepicker/placeholders.ts` (react-stately 3.49.0).
+*
+* Only year, month and day get a spelled-out word. An era or day period shows the real value it
+* would take, because there is no useful abbreviation for "AD" or "AM"; every time field falls
+* back to two dashes.
+*/
+var getDatePlaceholder = (field, value, locale) => {
+	if (field === "era" || field === "dayPeriod") return value;
+	if (field === "year" || field === "month" || field === "day") return dictionary.getStringForLocale(field, locale);
+	return "––";
+};
+//#endregion
+export { getDatePlaceholder };

package/dist/utils/date-validation.d.ts

@@ -0,0 +1,24 @@
+import type { ValidationResult } from "../composables/use-form-validation-state";
+import type { FormatterOptions } from "./date-format";
+import type { DateValue } from "@internationalized/date";
+/**
+ * Whether a date is inside its allowed range, and the messages to show when it is not, ported from
+ * react-stately's `packages/react-stately/src/datepicker/utils.ts` (react-stately 3.49.0).
+ *
+ * The messages are read in the **browser's** locale rather than the one a provider chose, and that
+ * is deliberate upstream: they sit alongside the browser's own validation messages, which ignore
+ * any provider. Mixing the two languages in one form would be worse than following the browser.
+ */
+export declare const getDateValidationResult: (value: DateValue | null, minValue: DateValue | null | undefined, maxValue: DateValue | null | undefined, isDateUnavailable: ((date: DateValue) => boolean) | undefined, options: FormatterOptions) => ValidationResult;
+/**
+ * Whether both ends of a range are inside their allowed bounds, and in the right order.
+ *
+ * Only the two ends are checked against `isDateUnavailable`, never the days between them: a range
+ * spanning an unavailable date is a question for the calendar, which decides whether a range may
+ * cross one at all. A reversed range is reported as both an overflow and an underflow, because
+ * neither end alone is the one at fault.
+ */
+export declare const getRangeValidationResult: (value: {
+    start: DateValue | null;
+    end: DateValue | null;
+} | null, minValue: DateValue | null | undefined, maxValue: DateValue | null | undefined, isDateUnavailable: ((date: DateValue) => boolean) | undefined, options: FormatterOptions) => ValidationResult;

package/dist/utils/date-validation.js

@@ -0,0 +1,76 @@
+import { VALID_VALIDITY_STATE, mergeValidation } from "../composables/use-form-validation-state.js";
+import { getDefaultLocale } from "./locale.js";
+import { dateValidationStrings } from "../i18n/date-validation.js";
+import { getFormatOptions } from "./date-format.js";
+import { LocalizedStringDictionary, LocalizedStringFormatter } from "@internationalized/string";
+import { DateFormatter } from "@internationalized/date";
+//#region src/utils/date-validation.ts
+/** Built once: the table is fixed and the dictionary is read-only after construction. */
+var dictionary = new LocalizedStringDictionary(dateValidationStrings);
+/**
+* Whether a date is inside its allowed range, and the messages to show when it is not, ported from
+* react-stately's `packages/react-stately/src/datepicker/utils.ts` (react-stately 3.49.0).
+*
+* The messages are read in the **browser's** locale rather than the one a provider chose, and that
+* is deliberate upstream: they sit alongside the browser's own validation messages, which ignore
+* any provider. Mixing the two languages in one form would be worse than following the browser.
+*/
+var getDateValidationResult = (value, minValue, maxValue, isDateUnavailable, options) => {
+	const rangeOverflow = value != null && maxValue != null && value.compare(maxValue) > 0;
+	const rangeUnderflow = value != null && minValue != null && value.compare(minValue) < 0;
+	const isUnavailable = value != null && isDateUnavailable?.(value) || false;
+	const isInvalid = rangeOverflow || rangeUnderflow || isUnavailable;
+	const errors = [];
+	if (isInvalid) {
+		const { locale } = getDefaultLocale();
+		const formatter = new LocalizedStringFormatter(locale, dictionary);
+		const dateFormatter = new DateFormatter(locale, getFormatOptions({}, options));
+		const { timeZone } = dateFormatter.resolvedOptions();
+		if (rangeUnderflow && minValue != null) errors.push(formatter.format("rangeUnderflow", { minValue: dateFormatter.format(minValue.toDate(timeZone)) }));
+		if (rangeOverflow && maxValue != null) errors.push(formatter.format("rangeOverflow", { maxValue: dateFormatter.format(maxValue.toDate(timeZone)) }));
+		if (isUnavailable) errors.push(formatter.format("unavailableDate"));
+	}
+	return {
+		isInvalid,
+		validationDetails: {
+			badInput: isUnavailable,
+			customError: false,
+			patternMismatch: false,
+			rangeOverflow,
+			rangeUnderflow,
+			stepMismatch: false,
+			tooLong: false,
+			tooShort: false,
+			typeMismatch: false,
+			valid: !isInvalid,
+			valueMissing: false
+		},
+		validationErrors: errors
+	};
+};
+/**
+* Whether both ends of a range are inside their allowed bounds, and in the right order.
+*
+* Only the two ends are checked against `isDateUnavailable`, never the days between them: a range
+* spanning an unavailable date is a question for the calendar, which decides whether a range may
+* cross one at all. A reversed range is reported as both an overflow and an underflow, because
+* neither end alone is the one at fault.
+*/
+var getRangeValidationResult = (value, minValue, maxValue, isDateUnavailable, options) => {
+	const merged = mergeValidation(getDateValidationResult(value?.start ?? null, minValue, maxValue, isDateUnavailable, options), getDateValidationResult(value?.end ?? null, minValue, maxValue, isDateUnavailable, options));
+	if (value?.start == null || value.end == null || value.end.compare(value.start) >= 0) return merged;
+	const { locale } = getDefaultLocale();
+	const formatter = new LocalizedStringFormatter(locale, dictionary);
+	return mergeValidation(merged, {
+		isInvalid: true,
+		validationDetails: {
+			...VALID_VALIDITY_STATE,
+			rangeOverflow: true,
+			rangeUnderflow: true,
+			valid: false
+		},
+		validationErrors: [formatter.format("rangeReversed")]
+	});
+};
+//#endregion
+export { getDateValidationResult, getRangeValidationResult };

package/dist/utils/dnd-constants.d.ts

@@ -0,0 +1,92 @@
+import type { DropEffect, DropOperation } from "./dnd-types";
+/**
+ * Constants of the HTML drag and drop API, ported from React Aria's `dnd/constants.ts`.
+ *
+ * Drop operations are a **bitmask** rather than a union, because a drag advertises a *set* of
+ * operations it would accept and the drop side intersects that set with what it can do. React
+ * Aria uses a TypeScript `enum` here; this package has none anywhere, so it is a frozen object
+ * with an accompanying type.
+ */
+export declare const DROP_OPERATION: {
+    readonly all: number;
+    readonly cancel: 0;
+    readonly copy: number;
+    readonly link: number;
+    readonly move: number;
+    readonly none: 0;
+};
+/** A bitmask of `DROP_OPERATION` members. */
+export type DropOperationMask = number;
+/**
+ * `DataTransfer.effectAllowed` spelled as a bitmask.
+ *
+ * The native API names the combinations rather than composing them, so the pairs are spelled
+ * out. `uninitialized` is what the browser reports before anyone sets `effectAllowed`, and it
+ * means "no restriction" rather than "nothing allowed".
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/effectAllowed
+ */
+export declare const DROP_OPERATION_ALLOWED: {
+    readonly cancel: 0;
+    readonly copy: number;
+    readonly link: number;
+    readonly move: number;
+    readonly none: 0;
+    readonly all: number;
+    readonly copyLink: number;
+    readonly copyMove: number;
+    readonly linkMove: number;
+    readonly uninitialized: number;
+};
+/** The `effectAllowed` string for a given bitmask. */
+export type EffectAllowed = "none" | "move" | "copy" | "copyMove" | "link" | "linkMove" | "copyLink" | "all";
+/**
+ * `DROP_OPERATION_ALLOWED` read backwards: bitmask to the string the DOM wants.
+ *
+ * Built by inversion rather than written out so the two can never drift apart. Inversion loses
+ * information wherever two names share a value, so both collisions are reasserted afterwards:
+ * `all` over `uninitialized`, and `none` over `cancel`.
+ *
+ * **Deviation from React Aria**, which reasserts only `all`. Its `EFFECT_ALLOWED[0]` is
+ * therefore `"cancel"` — verified against the shipped `react-aria@3.51.0` build, not inferred.
+ * That is not one of the values `effectAllowed` accepts (`none`, `copy`, `copyLink`, `copyMove`,
+ * `link`, `linkMove`, `move`, `all`, `uninitialized`), and assigning it would leave the transfer
+ * at `uninitialized`, meaning *every* operation is permitted rather than none.
+ *
+ * Upstream is not actually broken by this: `useDrag` patches it back at the point of use, with
+ * `effectAllowed === 'cancel' ? 'none' : effectAllowed`. Fixing the constant instead makes that
+ * guard unnecessary and stops the next consumer inheriting a value the DOM rejects — both
+ * collisions are the same mistake, and this repairs the one upstream works around.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/effectAllowed
+ */
+export declare const EFFECT_ALLOWED: Record<number, EffectAllowed>;
+/** The DOM's `dropEffect` translated to the operation vocabulary. */
+export declare const DROP_EFFECT_TO_DROP_OPERATION: Record<DropEffect, DropOperation>;
+/** The operation vocabulary translated back to the DOM's `dropEffect`. */
+export declare const DROP_OPERATION_TO_DROP_EFFECT: Record<DropOperation, DropEffect>;
+/**
+ * The only types that survive a drag between applications.
+ *
+ * Anything else is app-private: the browser will carry it within the page but a foreign drop
+ * target will never see it, which is why multi-representation items are additionally serialized
+ * under `CUSTOM_DRAG_TYPE`.
+ */
+export declare const NATIVE_DRAG_TYPES: Set<string>;
+/**
+ * Where the full item list is stashed when the native API cannot express it.
+ *
+ * A `DataTransfer` holds at most one entry per type, so several items sharing a type — or one
+ * item with several representations — cannot be written natively. Both cases are JSON-encoded
+ * into this single custom type instead.
+ */
+export declare const CUSTOM_DRAG_TYPE = "application/vnd.react-aria.items+json";
+/** Stand-in mime type for a file the browser could not identify. */
+export declare const GENERIC_TYPE = "application/octet-stream";
+/**
+ * Marker for "this drag contains a directory".
+ *
+ * A symbol rather than a mime type because directories have none — the browser reports a
+ * directory and an unidentified file identically until the drop actually happens.
+ */
+export declare const DIRECTORY_DRAG_TYPE: symbol;

package/dist/utils/dnd-constants.js

@@ -0,0 +1,106 @@
+//#region src/utils/dnd-constants.ts
+/**
+* Constants of the HTML drag and drop API, ported from React Aria's `dnd/constants.ts`.
+*
+* Drop operations are a **bitmask** rather than a union, because a drag advertises a *set* of
+* operations it would accept and the drop side intersects that set with what it can do. React
+* Aria uses a TypeScript `enum` here; this package has none anywhere, so it is a frozen object
+* with an accompanying type.
+*/
+var DROP_OPERATION = {
+	all: 7,
+	cancel: 0,
+	copy: 2,
+	link: 4,
+	move: 1,
+	none: 0
+};
+/**
+* `DataTransfer.effectAllowed` spelled as a bitmask.
+*
+* The native API names the combinations rather than composing them, so the pairs are spelled
+* out. `uninitialized` is what the browser reports before anyone sets `effectAllowed`, and it
+* means "no restriction" rather than "nothing allowed".
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/effectAllowed
+*/
+var DROP_OPERATION_ALLOWED = {
+	...DROP_OPERATION,
+	all: DROP_OPERATION.all,
+	copyLink: DROP_OPERATION.copy | DROP_OPERATION.link,
+	copyMove: DROP_OPERATION.copy | DROP_OPERATION.move,
+	linkMove: DROP_OPERATION.link | DROP_OPERATION.move,
+	uninitialized: DROP_OPERATION.all
+};
+/**
+* `DROP_OPERATION_ALLOWED` read backwards: bitmask to the string the DOM wants.
+*
+* Built by inversion rather than written out so the two can never drift apart. Inversion loses
+* information wherever two names share a value, so both collisions are reasserted afterwards:
+* `all` over `uninitialized`, and `none` over `cancel`.
+*
+* **Deviation from React Aria**, which reasserts only `all`. Its `EFFECT_ALLOWED[0]` is
+* therefore `"cancel"` — verified against the shipped `react-aria@3.51.0` build, not inferred.
+* That is not one of the values `effectAllowed` accepts (`none`, `copy`, `copyLink`, `copyMove`,
+* `link`, `linkMove`, `move`, `all`, `uninitialized`), and assigning it would leave the transfer
+* at `uninitialized`, meaning *every* operation is permitted rather than none.
+*
+* Upstream is not actually broken by this: `useDrag` patches it back at the point of use, with
+* `effectAllowed === 'cancel' ? 'none' : effectAllowed`. Fixing the constant instead makes that
+* guard unnecessary and stops the next consumer inheriting a value the DOM rejects — both
+* collisions are the same mistake, and this repairs the one upstream works around.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/effectAllowed
+*/
+var EFFECT_ALLOWED = (() => {
+	const inverted = {};
+	for (const [name, mask] of Object.entries(DROP_OPERATION_ALLOWED)) inverted[mask] = name;
+	inverted[DROP_OPERATION.all] = "all";
+	inverted[DROP_OPERATION.none] = "none";
+	return inverted;
+})();
+/** The DOM's `dropEffect` translated to the operation vocabulary. */
+var DROP_EFFECT_TO_DROP_OPERATION = {
+	copy: "copy",
+	link: "link",
+	move: "move",
+	none: "cancel"
+};
+/** The operation vocabulary translated back to the DOM's `dropEffect`. */
+var DROP_OPERATION_TO_DROP_EFFECT = {
+	cancel: "none",
+	copy: "copy",
+	link: "link",
+	move: "move"
+};
+/**
+* The only types that survive a drag between applications.
+*
+* Anything else is app-private: the browser will carry it within the page but a foreign drop
+* target will never see it, which is why multi-representation items are additionally serialized
+* under `CUSTOM_DRAG_TYPE`.
+*/
+var NATIVE_DRAG_TYPES = /* @__PURE__ */ new Set([
+	"text/plain",
+	"text/uri-list",
+	"text/html"
+]);
+/**
+* Where the full item list is stashed when the native API cannot express it.
+*
+* A `DataTransfer` holds at most one entry per type, so several items sharing a type — or one
+* item with several representations — cannot be written natively. Both cases are JSON-encoded
+* into this single custom type instead.
+*/
+var CUSTOM_DRAG_TYPE = "application/vnd.react-aria.items+json";
+/** Stand-in mime type for a file the browser could not identify. */
+var GENERIC_TYPE = "application/octet-stream";
+/**
+* Marker for "this drag contains a directory".
+*
+* A symbol rather than a mime type because directories have none — the browser reports a
+* directory and an unidentified file identically until the drop actually happens.
+*/
+var DIRECTORY_DRAG_TYPE = Symbol("directory drag type");
+//#endregion
+export { CUSTOM_DRAG_TYPE, DIRECTORY_DRAG_TYPE, DROP_EFFECT_TO_DROP_OPERATION, DROP_OPERATION, DROP_OPERATION_ALLOWED, DROP_OPERATION_TO_DROP_EFFECT, EFFECT_ALLOWED, GENERIC_TYPE, NATIVE_DRAG_TYPES };

package/dist/utils/dnd-data-transfer.d.ts

@@ -0,0 +1,46 @@
+import type { DragItem, DragType, DragTypes, DropItem } from "./dnd-types";
+/** Every mime type present across a set of drag items. */
+export declare const getTypes: (items: DragItem[]) => Set<string>;
+/**
+ * Write drag items onto a native `DataTransfer`.
+ *
+ * The native API cannot hold two items of one type, nor one item in two representations, so
+ * both cases fall back to a JSON blob under `CUSTOM_DRAG_TYPE`. That blob is written *in
+ * addition to* the native entries rather than instead of them, so a foreign application still
+ * receives something it understands.
+ *
+ * Note that files are never written: `DataTransferItemList.add` accepts a `File`, but no browser
+ * actually carries it out of the page, so dragging binary data to the desktop is not supported.
+ */
+export declare const writeToDataTransfer: (dataTransfer: DataTransfer, items: DragItem[]) => void;
+/**
+ * What a drag carries, as far as a drop target may know while the drag is still moving.
+ *
+ * Ported from React Aria's `DragTypes`. Built once per `dragenter`/`dragover` because a
+ * `DataTransfer` is only readable for types — never values — until the drop actually fires.
+ */
+export declare class DataTransferDragTypes implements DragTypes {
+    private types;
+    private includesUnknownTypes;
+    constructor(dataTransfer: DataTransfer);
+    has(type: DragType | DragType[]): boolean;
+}
+/**
+ * The same question answered from a plain set of type strings.
+ *
+ * The keyboard drag session never touches a `DataTransfer` — it knows the dragged items directly
+ * — so it holds the types as a `Set<string>`. React Aria hands that set straight to
+ * `getDropOperation`, where it duck-types as `DragTypes` because a `Set` also has a `has`
+ * method. That silently loses wildcard and directory matching on the keyboard path: `has("image/*")`
+ * against a set containing `"image/png"` answers `false`. Wrapping restores parity between the
+ * two paths.
+ */
+export declare const dragTypesFromSet: (types: Set<string>) => DragTypes;
+/**
+ * Read drop items back off a native `DataTransfer`.
+ *
+ * Must be called synchronously from the `drop` handler: the browser empties the transfer as
+ * soon as the handler returns, so every value is read here and handed out as a resolved promise
+ * afterwards.
+ */
+export declare const readFromDataTransfer: (dataTransfer: DataTransfer) => DropItem[];