@zimyo/ui 1.0.1 → 1.1.0

package/dist/node_modules/@date-fns/tz/date/mini.js

@@ -1,207 +0,0 @@
-import { tzOffset } from '../tzOffset/index.js';
-
-class TZDateMini extends Date {
-  //#region static
-
-  constructor(...args) {
-    super();
-    if (args.length > 1 && typeof args[args.length - 1] === "string") {
-      this.timeZone = args.pop();
-    }
-    this.internal = new Date();
-    if (isNaN(tzOffset(this.timeZone, this))) {
-      this.setTime(NaN);
-    } else {
-      if (!args.length) {
-        this.setTime(Date.now());
-      } else if (typeof args[0] === "number" && (args.length === 1 || args.length === 2 && typeof args[1] !== "number")) {
-        this.setTime(args[0]);
-      } else if (typeof args[0] === "string") {
-        this.setTime(+new Date(args[0]));
-      } else if (args[0] instanceof Date) {
-        this.setTime(+args[0]);
-      } else {
-        this.setTime(+new Date(...args));
-        adjustToSystemTZ(this);
-        syncToInternal(this);
-      }
-    }
-  }
-  static tz(tz, ...args) {
-    return args.length ? new TZDateMini(...args, tz) : new TZDateMini(Date.now(), tz);
-  }
-
-  //#endregion
-
-  //#region time zone
-
-  withTimeZone(timeZone) {
-    return new TZDateMini(+this, timeZone);
-  }
-  getTimezoneOffset() {
-    return -tzOffset(this.timeZone, this);
-  }
-
-  //#endregion
-
-  //#region time
-
-  setTime(time) {
-    Date.prototype.setTime.apply(this, arguments);
-    syncToInternal(this);
-    return +this;
-  }
-
-  //#endregion
-
-  //#region date-fns integration
-
-  [Symbol.for("constructDateFrom")](date) {
-    return new TZDateMini(+new Date(date), this.timeZone);
-  }
-
-  //#endregion
-}
-
-// Assign getters and setters
-const re = /^(get|set)(?!UTC)/;
-Object.getOwnPropertyNames(Date.prototype).forEach(method => {
-  if (!re.test(method)) return;
-  const utcMethod = method.replace(re, "$1UTC");
-  // Filter out methods without UTC counterparts
-  if (!TZDateMini.prototype[utcMethod]) return;
-  if (method.startsWith("get")) {
-    // Delegate to internal date's UTC method
-    TZDateMini.prototype[method] = function () {
-      return this.internal[utcMethod]();
-    };
-  } else {
-    // Assign regular setter
-    TZDateMini.prototype[method] = function () {
-      Date.prototype[utcMethod].apply(this.internal, arguments);
-      syncFromInternal(this);
-      return +this;
-    };
-
-    // Assign UTC setter
-    TZDateMini.prototype[utcMethod] = function () {
-      Date.prototype[utcMethod].apply(this, arguments);
-      syncToInternal(this);
-      return +this;
-    };
-  }
-});
-
-/**
- * Function syncs time to internal date, applying the time zone offset.
- *
- * @param {Date} date - Date to sync
- */
-function syncToInternal(date) {
-  date.internal.setTime(+date);
-  date.internal.setUTCMinutes(date.internal.getUTCMinutes() - date.getTimezoneOffset());
-}
-
-/**
- * Function syncs the internal date UTC values to the date. It allows to get
- * accurate timestamp value.
- *
- * @param {Date} date - The date to sync
- */
-function syncFromInternal(date) {
-  // First we transpose the internal values
-  Date.prototype.setFullYear.call(date, date.internal.getUTCFullYear(), date.internal.getUTCMonth(), date.internal.getUTCDate());
-  Date.prototype.setHours.call(date, date.internal.getUTCHours(), date.internal.getUTCMinutes(), date.internal.getUTCSeconds(), date.internal.getUTCMilliseconds());
-
-  // Now we have to adjust the date to the system time zone
-  adjustToSystemTZ(date);
-}
-
-/**
- * Function adjusts the date to the system time zone. It uses the time zone
- * differences to calculate the offset and adjust the date.
- *
- * @param {Date} date - Date to adjust
- */
-function adjustToSystemTZ(date) {
-  // Save the time zone offset before all the adjustments
-  const offset = tzOffset(date.timeZone, date);
-
-  //#region System DST adjustment
-
-  // The biggest problem with using the system time zone is that when we create
-  // a date from internal values stored in UTC, the system time zone might end
-  // up on the DST hour:
-  //
-  //   $ TZ=America/New_York node
-  //   > new Date(2020, 2, 8, 1).toString()
-  //   'Sun Mar 08 2020 01:00:00 GMT-0500 (Eastern Standard Time)'
-  //   > new Date(2020, 2, 8, 2).toString()
-  //   'Sun Mar 08 2020 03:00:00 GMT-0400 (Eastern Daylight Time)'
-  //   > new Date(2020, 2, 8, 3).toString()
-  //   'Sun Mar 08 2020 03:00:00 GMT-0400 (Eastern Daylight Time)'
-  //   > new Date(2020, 2, 8, 4).toString()
-  //   'Sun Mar 08 2020 04:00:00 GMT-0400 (Eastern Daylight Time)'
-  //
-  // Here we get the same hour for both 2 and 3, because the system time zone
-  // has DST beginning at 8 March 2020, 2 a.m. and jumps to 3 a.m. So we have
-  // to adjust the internal date to reflect that.
-  //
-  // However we want to adjust only if that's the DST hour the change happenes,
-  // not the hour where DST moves to.
-
-  // We calculate the previous hour to see if the time zone offset has changed
-  // and we have landed on the DST hour.
-  const prevHour = new Date(+date);
-  // We use UTC methods here as we don't want to land on the same hour again
-  // in case of DST.
-  prevHour.setUTCHours(prevHour.getUTCHours() - 1);
-
-  // Calculate if we are on the system DST hour.
-  const systemOffset = -new Date(+date).getTimezoneOffset();
-  const prevHourSystemOffset = -new Date(+prevHour).getTimezoneOffset();
-  const systemDSTChange = systemOffset - prevHourSystemOffset;
-  // Detect the DST shift. System DST change will occur both on
-  const dstShift = Date.prototype.getHours.apply(date) !== date.internal.getUTCHours();
-
-  // Move the internal date when we are on the system DST hour.
-  if (systemDSTChange && dstShift) date.internal.setUTCMinutes(date.internal.getUTCMinutes() + systemDSTChange);
-
-  //#endregion
-
-  //#region System diff adjustment
-
-  // Now we need to adjust the date, since we just applied internal values.
-  // We need to calculate the difference between the system and date time zones
-  // and apply it to the date.
-
-  const offsetDiff = systemOffset - offset;
-  if (offsetDiff) Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + offsetDiff);
-
-  //#endregion
-
-  //#region Post-adjustment DST fix
-
-  const postOffset = tzOffset(date.timeZone, date);
-  const postSystemOffset = -new Date(+date).getTimezoneOffset();
-  const postOffsetDiff = postSystemOffset - postOffset;
-  const offsetChanged = postOffset !== offset;
-  const postDiff = postOffsetDiff - offsetDiff;
-  if (offsetChanged && postDiff) {
-    Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + postDiff);
-
-    // Now we need to check if got offset change during the post-adjustment.
-    // If so, we also need both dates to reflect that.
-
-    const newOffset = tzOffset(date.timeZone, date);
-    const offsetChange = postOffset - newOffset;
-    if (offsetChange) {
-      date.internal.setUTCMinutes(date.internal.getUTCMinutes() + offsetChange);
-      Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + offsetChange);
-    }
-  }
-
-  //#endregion
-}
-
-export { TZDateMini };

package/dist/node_modules/@date-fns/tz/tzOffset/index.js

@@ -1,43 +0,0 @@
-const offsetFormatCache = {};
-const offsetCache = {};
-
-/**
- * The function extracts UTC offset in minutes from the given date in specified
- * time zone.
- *
- * Unlike `Date.prototype.getTimezoneOffset`, this function returns the value
- * mirrored to the sign of the offset in the time zone. For Asia/Singapore
- * (UTC+8), `tzOffset` returns 480, while `getTimezoneOffset` returns -480.
- *
- * @param timeZone - Time zone name (IANA or UTC offset)
- * @param date - Date to check the offset for
- *
- * @returns UTC offset in minutes
- */
-function tzOffset(timeZone, date) {
-  try {
-    const format = offsetFormatCache[timeZone] ||= new Intl.DateTimeFormat("en-GB", {
-      timeZone,
-      hour: "numeric",
-      timeZoneName: "longOffset"
-    }).format;
-    const offsetStr = format(date).split('GMT')[1] || '';
-    if (offsetStr in offsetCache) return offsetCache[offsetStr];
-    return calcOffset(offsetStr, offsetStr.split(":"));
-  } catch {
-    // Fallback to manual parsing if the runtime doesn't support ±HH:MM/±HHMM/±HH
-    // See: https://github.com/nodejs/node/issues/53419
-    if (timeZone in offsetCache) return offsetCache[timeZone];
-    const captures = timeZone?.match(offsetRe);
-    if (captures) return calcOffset(timeZone, captures.slice(1));
-    return NaN;
-  }
-}
-const offsetRe = /([+-]\d\d):?(\d\d)?/;
-function calcOffset(cacheStr, values) {
-  const hours = +values[0];
-  const minutes = +(values[1] || 0);
-  return offsetCache[cacheStr] = hours > 0 ? hours * 60 + minutes : hours * 60 - minutes;
-}
-
-export { tzOffset };

package/dist/node_modules/@radix-ui/primitive/dist/index.js

@@ -1,11 +0,0 @@
-// packages/core/primitive/src/primitive.tsx
-function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
-  return function handleEvent(event) {
-    originalEventHandler?.(event);
-    if (checkForDefaultPrevented === false || !event.defaultPrevented) {
-      return ourEventHandler?.(event);
-    }
-  };
-}
-
-export { composeEventHandlers };

package/dist/node_modules/@radix-ui/react-compose-refs/dist/index.js

@@ -1,39 +0,0 @@
-import * as React from 'react';
-
-// packages/react/compose-refs/src/compose-refs.tsx
-function setRef(ref, value) {
-  if (typeof ref === "function") {
-    return ref(value);
-  } else if (ref !== null && ref !== void 0) {
-    ref.current = value;
-  }
-}
-function composeRefs(...refs) {
-  return (node) => {
-    let hasCleanup = false;
-    const cleanups = refs.map((ref) => {
-      const cleanup = setRef(ref, node);
-      if (!hasCleanup && typeof cleanup == "function") {
-        hasCleanup = true;
-      }
-      return cleanup;
-    });
-    if (hasCleanup) {
-      return () => {
-        for (let i = 0; i < cleanups.length; i++) {
-          const cleanup = cleanups[i];
-          if (typeof cleanup == "function") {
-            cleanup();
-          } else {
-            setRef(refs[i], null);
-          }
-        }
-      };
-    }
-  };
-}
-function useComposedRefs(...refs) {
-  return React.useCallback(composeRefs(...refs), refs);
-}
-
-export { composeRefs, useComposedRefs };

package/dist/node_modules/@radix-ui/react-context/dist/index.js

@@ -1,79 +0,0 @@
-import * as React from 'react';
-import { jsx } from 'react/jsx-runtime';
-
-// packages/react/context/src/create-context.tsx
-function createContext2(rootComponentName, defaultContext) {
-  const Context = React.createContext(defaultContext);
-  const Provider = (props) => {
-    const { children, ...context } = props;
-    const value = React.useMemo(() => context, Object.values(context));
-    return /* @__PURE__ */ jsx(Context.Provider, { value, children });
-  };
-  Provider.displayName = rootComponentName + "Provider";
-  function useContext2(consumerName) {
-    const context = React.useContext(Context);
-    if (context) return context;
-    if (defaultContext !== void 0) return defaultContext;
-    throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
-  }
-  return [Provider, useContext2];
-}
-function createContextScope(scopeName, createContextScopeDeps = []) {
-  let defaultContexts = [];
-  function createContext3(rootComponentName, defaultContext) {
-    const BaseContext = React.createContext(defaultContext);
-    const index = defaultContexts.length;
-    defaultContexts = [...defaultContexts, defaultContext];
-    const Provider = (props) => {
-      const { scope, children, ...context } = props;
-      const Context = scope?.[scopeName]?.[index] || BaseContext;
-      const value = React.useMemo(() => context, Object.values(context));
-      return /* @__PURE__ */ jsx(Context.Provider, { value, children });
-    };
-    Provider.displayName = rootComponentName + "Provider";
-    function useContext2(consumerName, scope) {
-      const Context = scope?.[scopeName]?.[index] || BaseContext;
-      const context = React.useContext(Context);
-      if (context) return context;
-      if (defaultContext !== void 0) return defaultContext;
-      throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
-    }
-    return [Provider, useContext2];
-  }
-  const createScope = () => {
-    const scopeContexts = defaultContexts.map((defaultContext) => {
-      return React.createContext(defaultContext);
-    });
-    return function useScope(scope) {
-      const contexts = scope?.[scopeName] || scopeContexts;
-      return React.useMemo(
-        () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),
-        [scope, contexts]
-      );
-    };
-  };
-  createScope.scopeName = scopeName;
-  return [createContext3, composeContextScopes(createScope, ...createContextScopeDeps)];
-}
-function composeContextScopes(...scopes) {
-  const baseScope = scopes[0];
-  if (scopes.length === 1) return baseScope;
-  const createScope = () => {
-    const scopeHooks = scopes.map((createScope2) => ({
-      useScope: createScope2(),
-      scopeName: createScope2.scopeName
-    }));
-    return function useComposedScopes(overrideScopes) {
-      const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {
-        const scopeProps = useScope(overrideScopes);
-        const currentScope = scopeProps[`__scope${scopeName}`];
-        return { ...nextScopes2, ...currentScope };
-      }, {});
-      return React.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);
-    };
-  };
-  createScope.scopeName = baseScope.scopeName;
-  return createScope;
-}
-
-export { createContext2 as createContext, createContextScope };