@cerberus-design/react 0.25.0-rc.7 → 0.25.1-rc.1

package/dist/node_modules/.pnpm/@ark-ui_react@5.30.0_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/@ark-ui/react/dist/components/file-upload/use-file-upload-item-props-context.cjs

@@ -0,0 +1,15 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const createContext = require('../../utils/create-context.cjs');
+
+const [FileUploadItemPropsProvider, useFileUploadItemPropsContext] = createContext.createContext({
+  name: "FileUploadItemPropsContext",
+  hookName: "useFileUploadItemPropsContext",
+  providerName: "<FileUploadItemPropsProvider />"
+});
+
+exports.FileUploadItemPropsProvider = FileUploadItemPropsProvider;
+exports.useFileUploadItemPropsContext = useFileUploadItemPropsContext;

package/dist/node_modules/.pnpm/@ark-ui_react@5.30.0_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/@ark-ui/react/dist/components/file-upload/use-file-upload-item-props-context.js

@@ -0,0 +1,10 @@
+'use client';
+import { createContext } from '../../utils/create-context.js';
+
+const [FileUploadItemPropsProvider, useFileUploadItemPropsContext] = createContext({
+  name: "FileUploadItemPropsContext",
+  hookName: "useFileUploadItemPropsContext",
+  providerName: "<FileUploadItemPropsProvider />"
+});
+
+export { FileUploadItemPropsProvider, useFileUploadItemPropsContext };

package/dist/node_modules/.pnpm/@ark-ui_react@5.30.0_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/@ark-ui/react/dist/components/file-upload/use-file-upload.cjs

@@ -0,0 +1,36 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const index$1 = require('../../../../../../../@zag-js_file-upload@1.31.1/node_modules/@zag-js/file-upload/dist/index.cjs');
+const index = require('../../../../../../../@zag-js_react@1.31.1_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/@zag-js/react/dist/index.cjs');
+const React = require('react');
+const useEnvironmentContext = require('../../providers/environment/use-environment-context.cjs');
+const useLocaleContext = require('../../providers/locale/use-locale-context.cjs');
+const useFieldContext = require('../field/use-field-context.cjs');
+
+const useFileUpload = (props) => {
+  const id = React.useId();
+  const { getRootNode } = useEnvironmentContext.useEnvironmentContext();
+  const { dir, locale } = useLocaleContext.useLocaleContext();
+  const field = useFieldContext.useFieldContext();
+  const machineProps = {
+    id,
+    ids: {
+      label: field?.ids.label,
+      hiddenInput: field?.ids.control
+    },
+    dir,
+    disabled: field?.disabled,
+    locale,
+    required: field?.required,
+    invalid: field?.invalid,
+    getRootNode,
+    ...props
+  };
+  const service = index.useMachine(index$1.machine, machineProps);
+  return index$1.connect(service, index.normalizeProps);
+};
+
+exports.useFileUpload = useFileUpload;

package/dist/node_modules/.pnpm/@ark-ui_react@5.30.0_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/@ark-ui/react/dist/components/file-upload/use-file-upload.js

@@ -0,0 +1,32 @@
+'use client';
+import { machine, connect } from '../../../../../../../@zag-js_file-upload@1.31.1/node_modules/@zag-js/file-upload/dist/index.js';
+import { useMachine, normalizeProps } from '../../../../../../../@zag-js_react@1.31.1_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/@zag-js/react/dist/index.js';
+import { useId } from 'react';
+import { useEnvironmentContext } from '../../providers/environment/use-environment-context.js';
+import { useLocaleContext } from '../../providers/locale/use-locale-context.js';
+import { useFieldContext } from '../field/use-field-context.js';
+
+const useFileUpload = (props) => {
+  const id = useId();
+  const { getRootNode } = useEnvironmentContext();
+  const { dir, locale } = useLocaleContext();
+  const field = useFieldContext();
+  const machineProps = {
+    id,
+    ids: {
+      label: field?.ids.label,
+      hiddenInput: field?.ids.control
+    },
+    dir,
+    disabled: field?.disabled,
+    locale,
+    required: field?.required,
+    invalid: field?.invalid,
+    getRootNode,
+    ...props
+  };
+  const service = useMachine(machine, machineProps);
+  return connect(service, normalizeProps);
+};
+
+export { useFileUpload };

package/dist/node_modules/.pnpm/@internationalized_date@3.10.0/node_modules/@internationalized/date/src/CalendarDate.js

@@ -1,9 +1,9 @@
 'use client';
-import { constrain, add, subtract, set, cycleDate, addZoned, subtractZoned, setZoned, cycleZoned, setTime, cycleTime } from './manipulation.js';
+import { constrain, add, subtract, set, cycleDate, setTime, cycleTime, addZoned, subtractZoned, setZoned, cycleZoned } from './manipulation.js';
 import { compareDate, compareTime } from './queries.js';
-import { dateToString, zonedDateTimeToString, dateTimeToString } from './string.js';
+import { dateToString, dateTimeToString, zonedDateTimeToString } from './string.js';
 import { GregorianCalendar } from './calendars/GregorianCalendar.js';
-import { toDate, zonedToDate, toZoned, toCalendarDateTime } from './conversion.js';
+import { toDate, toCalendarDateTime, zonedToDate, toZoned } from './conversion.js';
 
 function shiftArgs(args) {
   let calendar = typeof args[0] === "object" ? args.shift() : new GregorianCalendar();

package/dist/node_modules/.pnpm/@internationalized_date@3.10.0/node_modules/@internationalized/date/src/conversion.js

@@ -1,5 +1,5 @@
 'use client';
-import { CalendarDate, ZonedDateTime, CalendarDateTime } from './CalendarDate.js';
+import { CalendarDateTime, CalendarDate, ZonedDateTime } from './CalendarDate.js';
 import { constrain } from './manipulation.js';
 import { getExtendedYear, GregorianCalendar } from './calendars/GregorianCalendar.js';
 import { getLocalTimeZone, isEqualCalendar } from './queries.js';

package/dist/node_modules/.pnpm/@internationalized_date@3.10.0/node_modules/@internationalized/date/src/queries.js

@@ -1,5 +1,5 @@
 'use client';
-import { toCalendarDate, fromAbsolute, toCalendar } from './conversion.js';
+import { toCalendarDate, toCalendar, fromAbsolute } from './conversion.js';
 import { weekStartData } from './weekStartData.js';
 
 function isSameDay(a, b) {

package/dist/node_modules/.pnpm/@internationalized_date@3.10.1/node_modules/@internationalized/date/src/CalendarDate.cjs

@@ -0,0 +1,218 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const manipulation = require('./manipulation.cjs');
+const queries = require('./queries.cjs');
+const string = require('./string.cjs');
+const GregorianCalendar = require('./calendars/GregorianCalendar.cjs');
+const conversion = require('./conversion.cjs');
+
+function shiftArgs(args) {
+  let calendar = typeof args[0] === "object" ? args.shift() : new GregorianCalendar.GregorianCalendar();
+  let era;
+  if (typeof args[0] === "string") {
+    era = args.shift();
+  } else {
+    let eras = calendar.getEras();
+    era = eras[eras.length - 1];
+  }
+  let year = args.shift();
+  let month = args.shift();
+  let day = args.shift();
+  return [calendar, era, year, month, day];
+}
+class CalendarDate {
+  // This prevents TypeScript from allowing other types with the same fields to match.
+  // i.e. a ZonedDateTime should not be be passable to a parameter that expects CalendarDate.
+  // If that behavior is desired, use the AnyCalendarDate interface instead.
+  // @ts-ignore
+  #type;
+  constructor(...args) {
+    let [calendar, era, year, month, day] = shiftArgs(args);
+    this.calendar = calendar;
+    this.era = era;
+    this.year = year;
+    this.month = month;
+    this.day = day;
+    manipulation.constrain(this);
+  }
+  /** Returns a copy of this date. */
+  copy() {
+    if (this.era) {
+      return new CalendarDate(this.calendar, this.era, this.year, this.month, this.day);
+    } else {
+      return new CalendarDate(this.calendar, this.year, this.month, this.day);
+    }
+  }
+  /** Returns a new `CalendarDate` with the given duration added to it. */
+  add(duration) {
+    return manipulation.add(this, duration);
+  }
+  /** Returns a new `CalendarDate` with the given duration subtracted from it. */
+  subtract(duration) {
+    return manipulation.subtract(this, duration);
+  }
+  /** Returns a new `CalendarDate` with the given fields set to the provided values. Other fields will be constrained accordingly. */
+  set(fields) {
+    return manipulation.set(this, fields);
+  }
+  /**
+   * Returns a new `CalendarDate` with the given field adjusted by a specified amount.
+   * When the resulting value reaches the limits of the field, it wraps around.
+   */
+  cycle(field, amount, options) {
+    return manipulation.cycleDate(this, field, amount, options);
+  }
+  /** Converts the date to a native JavaScript Date object, with the time set to midnight in the given time zone. */
+  toDate(timeZone) {
+    return conversion.toDate(this, timeZone);
+  }
+  /** Converts the date to an ISO 8601 formatted string. */
+  toString() {
+    return string.dateToString(this);
+  }
+  /** Compares this date with another. A negative result indicates that this date is before the given one, and a positive date indicates that it is after. */
+  compare(b) {
+    return queries.compareDate(this, b);
+  }
+}
+class CalendarDateTime {
+  // This prevents TypeScript from allowing other types with the same fields to match.
+  // @ts-ignore
+  #type;
+  constructor(...args) {
+    let [calendar, era, year, month, day] = shiftArgs(args);
+    this.calendar = calendar;
+    this.era = era;
+    this.year = year;
+    this.month = month;
+    this.day = day;
+    this.hour = args.shift() || 0;
+    this.minute = args.shift() || 0;
+    this.second = args.shift() || 0;
+    this.millisecond = args.shift() || 0;
+    manipulation.constrain(this);
+  }
+  /** Returns a copy of this date. */
+  copy() {
+    if (this.era) {
+      return new CalendarDateTime(this.calendar, this.era, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+    } else {
+      return new CalendarDateTime(this.calendar, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+    }
+  }
+  /** Returns a new `CalendarDateTime` with the given duration added to it. */
+  add(duration) {
+    return manipulation.add(this, duration);
+  }
+  /** Returns a new `CalendarDateTime` with the given duration subtracted from it. */
+  subtract(duration) {
+    return manipulation.subtract(this, duration);
+  }
+  /** Returns a new `CalendarDateTime` with the given fields set to the provided values. Other fields will be constrained accordingly. */
+  set(fields) {
+    return manipulation.set(manipulation.setTime(this, fields), fields);
+  }
+  /**
+   * Returns a new `CalendarDateTime` with the given field adjusted by a specified amount.
+   * When the resulting value reaches the limits of the field, it wraps around.
+   */
+  cycle(field, amount, options) {
+    switch (field) {
+      case "era":
+      case "year":
+      case "month":
+      case "day":
+        return manipulation.cycleDate(this, field, amount, options);
+      default:
+        return manipulation.cycleTime(this, field, amount, options);
+    }
+  }
+  /** Converts the date to a native JavaScript Date object in the given time zone. */
+  toDate(timeZone, disambiguation) {
+    return conversion.toDate(this, timeZone, disambiguation);
+  }
+  /** Converts the date to an ISO 8601 formatted string. */
+  toString() {
+    return string.dateTimeToString(this);
+  }
+  /** Compares this date with another. A negative result indicates that this date is before the given one, and a positive date indicates that it is after. */
+  compare(b) {
+    let res = queries.compareDate(this, b);
+    if (res === 0) {
+      return queries.compareTime(this, conversion.toCalendarDateTime(b));
+    }
+    return res;
+  }
+}
+class ZonedDateTime {
+  // This prevents TypeScript from allowing other types with the same fields to match.
+  // @ts-ignore
+  #type;
+  constructor(...args) {
+    let [calendar, era, year, month, day] = shiftArgs(args);
+    let timeZone = args.shift();
+    let offset = args.shift();
+    this.calendar = calendar;
+    this.era = era;
+    this.year = year;
+    this.month = month;
+    this.day = day;
+    this.timeZone = timeZone;
+    this.offset = offset;
+    this.hour = args.shift() || 0;
+    this.minute = args.shift() || 0;
+    this.second = args.shift() || 0;
+    this.millisecond = args.shift() || 0;
+    manipulation.constrain(this);
+  }
+  /** Returns a copy of this date. */
+  copy() {
+    if (this.era) {
+      return new ZonedDateTime(this.calendar, this.era, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond);
+    } else {
+      return new ZonedDateTime(this.calendar, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond);
+    }
+  }
+  /** Returns a new `ZonedDateTime` with the given duration added to it. */
+  add(duration) {
+    return manipulation.addZoned(this, duration);
+  }
+  /** Returns a new `ZonedDateTime` with the given duration subtracted from it. */
+  subtract(duration) {
+    return manipulation.subtractZoned(this, duration);
+  }
+  /** Returns a new `ZonedDateTime` with the given fields set to the provided values. Other fields will be constrained accordingly. */
+  set(fields, disambiguation) {
+    return manipulation.setZoned(this, fields, disambiguation);
+  }
+  /**
+   * Returns a new `ZonedDateTime` with the given field adjusted by a specified amount.
+   * When the resulting value reaches the limits of the field, it wraps around.
+   */
+  cycle(field, amount, options) {
+    return manipulation.cycleZoned(this, field, amount, options);
+  }
+  /** Converts the date to a native JavaScript Date object. */
+  toDate() {
+    return conversion.zonedToDate(this);
+  }
+  /** Converts the date to an ISO 8601 formatted string, including the UTC offset and time zone identifier. */
+  toString() {
+    return string.zonedDateTimeToString(this);
+  }
+  /** Converts the date to an ISO 8601 formatted string in UTC. */
+  toAbsoluteString() {
+    return this.toDate().toISOString();
+  }
+  /** Compares this date with another. A negative result indicates that this date is before the given one, and a positive date indicates that it is after. */
+  compare(b) {
+    return this.toDate().getTime() - conversion.toZoned(b, this.timeZone).toDate().getTime();
+  }
+}
+
+exports.CalendarDate = CalendarDate;
+exports.CalendarDateTime = CalendarDateTime;
+exports.ZonedDateTime = ZonedDateTime;

package/dist/node_modules/.pnpm/@internationalized_date@3.10.1/node_modules/@internationalized/date/src/CalendarDate.js

@@ -0,0 +1,212 @@
+'use client';
+import { constrain, add, subtract, set, cycleDate, addZoned, subtractZoned, setZoned, cycleZoned, setTime, cycleTime } from './manipulation.js';
+import { compareDate, compareTime } from './queries.js';
+import { dateToString, zonedDateTimeToString, dateTimeToString } from './string.js';
+import { GregorianCalendar } from './calendars/GregorianCalendar.js';
+import { toDate, zonedToDate, toZoned, toCalendarDateTime } from './conversion.js';
+
+function shiftArgs(args) {
+  let calendar = typeof args[0] === "object" ? args.shift() : new GregorianCalendar();
+  let era;
+  if (typeof args[0] === "string") {
+    era = args.shift();
+  } else {
+    let eras = calendar.getEras();
+    era = eras[eras.length - 1];
+  }
+  let year = args.shift();
+  let month = args.shift();
+  let day = args.shift();
+  return [calendar, era, year, month, day];
+}
+class CalendarDate {
+  // This prevents TypeScript from allowing other types with the same fields to match.
+  // i.e. a ZonedDateTime should not be be passable to a parameter that expects CalendarDate.
+  // If that behavior is desired, use the AnyCalendarDate interface instead.
+  // @ts-ignore
+  #type;
+  constructor(...args) {
+    let [calendar, era, year, month, day] = shiftArgs(args);
+    this.calendar = calendar;
+    this.era = era;
+    this.year = year;
+    this.month = month;
+    this.day = day;
+    constrain(this);
+  }
+  /** Returns a copy of this date. */
+  copy() {
+    if (this.era) {
+      return new CalendarDate(this.calendar, this.era, this.year, this.month, this.day);
+    } else {
+      return new CalendarDate(this.calendar, this.year, this.month, this.day);
+    }
+  }
+  /** Returns a new `CalendarDate` with the given duration added to it. */
+  add(duration) {
+    return add(this, duration);
+  }
+  /** Returns a new `CalendarDate` with the given duration subtracted from it. */
+  subtract(duration) {
+    return subtract(this, duration);
+  }
+  /** Returns a new `CalendarDate` with the given fields set to the provided values. Other fields will be constrained accordingly. */
+  set(fields) {
+    return set(this, fields);
+  }
+  /**
+   * Returns a new `CalendarDate` with the given field adjusted by a specified amount.
+   * When the resulting value reaches the limits of the field, it wraps around.
+   */
+  cycle(field, amount, options) {
+    return cycleDate(this, field, amount, options);
+  }
+  /** Converts the date to a native JavaScript Date object, with the time set to midnight in the given time zone. */
+  toDate(timeZone) {
+    return toDate(this, timeZone);
+  }
+  /** Converts the date to an ISO 8601 formatted string. */
+  toString() {
+    return dateToString(this);
+  }
+  /** Compares this date with another. A negative result indicates that this date is before the given one, and a positive date indicates that it is after. */
+  compare(b) {
+    return compareDate(this, b);
+  }
+}
+class CalendarDateTime {
+  // This prevents TypeScript from allowing other types with the same fields to match.
+  // @ts-ignore
+  #type;
+  constructor(...args) {
+    let [calendar, era, year, month, day] = shiftArgs(args);
+    this.calendar = calendar;
+    this.era = era;
+    this.year = year;
+    this.month = month;
+    this.day = day;
+    this.hour = args.shift() || 0;
+    this.minute = args.shift() || 0;
+    this.second = args.shift() || 0;
+    this.millisecond = args.shift() || 0;
+    constrain(this);
+  }
+  /** Returns a copy of this date. */
+  copy() {
+    if (this.era) {
+      return new CalendarDateTime(this.calendar, this.era, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+    } else {
+      return new CalendarDateTime(this.calendar, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+    }
+  }
+  /** Returns a new `CalendarDateTime` with the given duration added to it. */
+  add(duration) {
+    return add(this, duration);
+  }
+  /** Returns a new `CalendarDateTime` with the given duration subtracted from it. */
+  subtract(duration) {
+    return subtract(this, duration);
+  }
+  /** Returns a new `CalendarDateTime` with the given fields set to the provided values. Other fields will be constrained accordingly. */
+  set(fields) {
+    return set(setTime(this, fields), fields);
+  }
+  /**
+   * Returns a new `CalendarDateTime` with the given field adjusted by a specified amount.
+   * When the resulting value reaches the limits of the field, it wraps around.
+   */
+  cycle(field, amount, options) {
+    switch (field) {
+      case "era":
+      case "year":
+      case "month":
+      case "day":
+        return cycleDate(this, field, amount, options);
+      default:
+        return cycleTime(this, field, amount, options);
+    }
+  }
+  /** Converts the date to a native JavaScript Date object in the given time zone. */
+  toDate(timeZone, disambiguation) {
+    return toDate(this, timeZone, disambiguation);
+  }
+  /** Converts the date to an ISO 8601 formatted string. */
+  toString() {
+    return dateTimeToString(this);
+  }
+  /** Compares this date with another. A negative result indicates that this date is before the given one, and a positive date indicates that it is after. */
+  compare(b) {
+    let res = compareDate(this, b);
+    if (res === 0) {
+      return compareTime(this, toCalendarDateTime(b));
+    }
+    return res;
+  }
+}
+class ZonedDateTime {
+  // This prevents TypeScript from allowing other types with the same fields to match.
+  // @ts-ignore
+  #type;
+  constructor(...args) {
+    let [calendar, era, year, month, day] = shiftArgs(args);
+    let timeZone = args.shift();
+    let offset = args.shift();
+    this.calendar = calendar;
+    this.era = era;
+    this.year = year;
+    this.month = month;
+    this.day = day;
+    this.timeZone = timeZone;
+    this.offset = offset;
+    this.hour = args.shift() || 0;
+    this.minute = args.shift() || 0;
+    this.second = args.shift() || 0;
+    this.millisecond = args.shift() || 0;
+    constrain(this);
+  }
+  /** Returns a copy of this date. */
+  copy() {
+    if (this.era) {
+      return new ZonedDateTime(this.calendar, this.era, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond);
+    } else {
+      return new ZonedDateTime(this.calendar, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond);
+    }
+  }
+  /** Returns a new `ZonedDateTime` with the given duration added to it. */
+  add(duration) {
+    return addZoned(this, duration);
+  }
+  /** Returns a new `ZonedDateTime` with the given duration subtracted from it. */
+  subtract(duration) {
+    return subtractZoned(this, duration);
+  }
+  /** Returns a new `ZonedDateTime` with the given fields set to the provided values. Other fields will be constrained accordingly. */
+  set(fields, disambiguation) {
+    return setZoned(this, fields, disambiguation);
+  }
+  /**
+   * Returns a new `ZonedDateTime` with the given field adjusted by a specified amount.
+   * When the resulting value reaches the limits of the field, it wraps around.
+   */
+  cycle(field, amount, options) {
+    return cycleZoned(this, field, amount, options);
+  }
+  /** Converts the date to a native JavaScript Date object. */
+  toDate() {
+    return zonedToDate(this);
+  }
+  /** Converts the date to an ISO 8601 formatted string, including the UTC offset and time zone identifier. */
+  toString() {
+    return zonedDateTimeToString(this);
+  }
+  /** Converts the date to an ISO 8601 formatted string in UTC. */
+  toAbsoluteString() {
+    return this.toDate().toISOString();
+  }
+  /** Compares this date with another. A negative result indicates that this date is before the given one, and a positive date indicates that it is after. */
+  compare(b) {
+    return this.toDate().getTime() - toZoned(b, this.timeZone).toDate().getTime();
+  }
+}
+
+export { CalendarDate, CalendarDateTime, ZonedDateTime };