@pisell/private-materials 6.6.2 → 6.7.2

package/lib/pro/Login2.0/components/phoneValidation.js

@@ -0,0 +1,153 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/pro/Login2.0/components/phoneValidation.ts
+var phoneValidation_exports = {};
+__export(phoneValidation_exports, {
+  createPhoneValidationRules: () => createPhoneValidationRules,
+  validatePhoneNumber: () => validatePhoneNumber
+});
+module.exports = __toCommonJS(phoneValidation_exports);
+var validatePhoneNumber = async (value, getText) => {
+  if (!value) {
+    throw new Error(getText("pisell-phone-validation-required"));
+  }
+  let phone;
+  let countryCode;
+  if (typeof value === "string") {
+    if (!value.startsWith("+")) {
+      throw new Error(getText("pisell-phone-validation-invalid"));
+    }
+    const match = value.match(/^\+(\d{1,4})(\d+)$/);
+    if (!match) {
+      throw new Error(getText("pisell-phone-validation-invalid"));
+    }
+    countryCode = match[1];
+    phone = match[2];
+  } else {
+    phone = value.phone;
+    countryCode = value.country_calling_code;
+  }
+  if (!phone || !countryCode) {
+    throw new Error(getText("pisell-phone-validation-required"));
+  }
+  switch (countryCode) {
+    case "86":
+      if (!/^1[3-9]\d{9}$/.test(phone)) {
+        throw new Error(getText("pisell-phone-validation-china"));
+      }
+      break;
+    case "852":
+      if (!/^[5-9]\d{7}$/.test(phone)) {
+        throw new Error(getText("pisell-phone-validation-hongkong"));
+      }
+      break;
+    case "853":
+      if (!/^6\d{7}$/.test(phone)) {
+        throw new Error(getText("pisell-phone-validation-macau"));
+      }
+      break;
+    case "886":
+      if (!/^9\d{8}$/.test(phone)) {
+        throw new Error(getText("pisell-phone-validation-taiwan"));
+      }
+      break;
+    case "1":
+      if (!/^\d{10}$/.test(phone)) {
+        throw new Error(getText("pisell-phone-validation-us-canada"));
+      }
+      break;
+    case "44":
+      if (!/^7\d{9}$/.test(phone)) {
+        throw new Error(getText("pisell-phone-validation-uk"));
+      }
+      break;
+    case "61":
+      if (!/^(\+?0)?4\d{8}$/.test(phone)) {
+        throw new Error(getText("pisell-phone-validation-australia"));
+      }
+      break;
+    case "81":
+      if (!/^[789]0\d{8}$/.test(phone)) {
+        throw new Error(getText("pisell-phone-validation-japan"));
+      }
+      break;
+    case "82":
+      if (!/^1[0-9]\d{7,8}$/.test(phone)) {
+        throw new Error(getText("pisell-phone-validation-korea"));
+      }
+      break;
+    case "65":
+      if (!/^[89]\d{7}$/.test(phone)) {
+        throw new Error(getText("pisell-phone-validation-singapore"));
+      }
+      break;
+    case "60":
+      if (!/^1[0-9]\d{7,8}$/.test(phone)) {
+        throw new Error(getText("pisell-phone-validation-malaysia"));
+      }
+      break;
+    case "66":
+      if (!/^[689]\d{8}$/.test(phone)) {
+        throw new Error(getText("pisell-phone-validation-thailand"));
+      }
+      break;
+    case "84":
+      if (!/^[3579]\d{8}$/.test(phone)) {
+        throw new Error(getText("pisell-phone-validation-vietnam"));
+      }
+      break;
+    case "63":
+      if (!/^9\d{9}$/.test(phone)) {
+        throw new Error(getText("pisell-phone-validation-philippines"));
+      }
+      break;
+    case "62":
+      if (!/^8\d{8,11}$/.test(phone)) {
+        throw new Error(getText("pisell-phone-validation-indonesia"));
+      }
+      break;
+    case "91":
+      if (!/^[6-9]\d{9}$/.test(phone)) {
+        throw new Error(getText("pisell-phone-validation-india"));
+      }
+      break;
+    default:
+      if (!/^\d{6,15}$/.test(phone)) {
+        throw new Error(getText("pisell-phone-validation-invalid"));
+      }
+      break;
+  }
+};
+var createPhoneValidationRules = (getText, required = true) => {
+  const rules = [];
+  rules.push({
+    validator: (_, value) => {
+      if (!value && !required) {
+        return Promise.resolve();
+      }
+      return validatePhoneNumber(value, getText);
+    }
+  });
+  return rules;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPhoneValidationRules,
+  validatePhoneNumber
+});

package/lib/pro/Login2.0/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { useRegisterFlow } from './useRegisterFlow';
+export type { UseRegisterFlowOptions, UseRegisterFlowReturn } from './useRegisterFlow';

package/lib/{plus/selectHolder/utils.js → pro/Login2.0/hooks/index.js}

@@ -16,19 +16,14 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/plus/selectHolder/utils.ts
-var utils_exports = {};
-__export(utils_exports, {
-  getAvatarText: () => getAvatarText
+// src/pro/Login2.0/hooks/index.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  useRegisterFlow: () => import_useRegisterFlow.useRegisterFlow
 });
-module.exports = __toCommonJS(utils_exports);
-var getAvatarText = (label) => {
-  if (!label) return "";
-  const words = label.trim().split(/\s+/);
-  const initials = words.slice(0, 2).map((word) => word.charAt(0).toUpperCase()).join("");
-  return initials;
-};
+module.exports = __toCommonJS(hooks_exports);
+var import_useRegisterFlow = require("./useRegisterFlow");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getAvatarText
+  useRegisterFlow
 });

package/lib/pro/Login2.0/hooks/usePasswordValidationRules.d.ts

@@ -0,0 +1,24 @@
+import type { Rule } from 'antd/es/form';
+export interface PasswordRuleConfig {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumber?: boolean;
+    requireSpecialCharacters?: boolean;
+}
+interface PasswordRuleMessages {
+    required?: string;
+    minLength?: string;
+    requireUppercase?: string;
+    requireLowercase?: string;
+    requireNumber?: string;
+    requireSpecialCharacters?: string;
+    summary?: string;
+}
+interface UsePasswordValidationRulesOptions {
+    translate?: (key: string) => string;
+    fallbackMinLength?: number;
+    messageKeys?: PasswordRuleMessages;
+}
+export declare const usePasswordValidationRules: (passwordRules?: PasswordRuleConfig, options?: UsePasswordValidationRulesOptions) => Rule[];
+export default usePasswordValidationRules;

package/lib/pro/Login2.0/hooks/usePasswordValidationRules.js

@@ -0,0 +1,140 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/pro/Login2.0/hooks/usePasswordValidationRules.ts
+var usePasswordValidationRules_exports = {};
+__export(usePasswordValidationRules_exports, {
+  default: () => usePasswordValidationRules_default,
+  usePasswordValidationRules: () => usePasswordValidationRules
+});
+module.exports = __toCommonJS(usePasswordValidationRules_exports);
+var import_react = require("react");
+var DEFAULT_MESSAGES = {
+  required: "Password is required",
+  minLength: "Password must be at least {length} characters long",
+  requireUppercase: "at least one uppercase letter",
+  requireLowercase: "at least one lowercase letter",
+  requireNumber: "at least one number",
+  requireSpecialCharacters: "at least one special character",
+  summary: "Password must contain: {requirements}"
+};
+var formatMessage = (template, variables) => Object.keys(variables).reduce(
+  (message, key) => message.replace(
+    new RegExp(`{${key}}`, "g"),
+    String(variables[key] ?? "")
+  ),
+  template
+);
+var resolveMessage = (key, translate, messageKeys) => {
+  const messageKey = messageKeys == null ? void 0 : messageKeys[key];
+  if (messageKey && translate) {
+    const translated = translate(messageKey);
+    if (translated) {
+      return translated;
+    }
+  }
+  return DEFAULT_MESSAGES[key];
+};
+var usePasswordValidationRules = (passwordRules, options) => {
+  const translate = options == null ? void 0 : options.translate;
+  const messageKeys = options == null ? void 0 : options.messageKeys;
+  const fallbackMinLength = options == null ? void 0 : options.fallbackMinLength;
+  return (0, import_react.useMemo)(() => {
+    const rules = [
+      {
+        required: true,
+        message: resolveMessage("required", translate, messageKeys)
+      }
+    ];
+    const effectiveRules = {
+      ...passwordRules
+    };
+    if (effectiveRules.minLength == null && fallbackMinLength) {
+      effectiveRules.minLength = fallbackMinLength;
+    }
+    if (effectiveRules.minLength) {
+      const rawMessage = resolveMessage("minLength", translate, messageKeys);
+      rules.push({
+        min: effectiveRules.minLength,
+        message: formatMessage(rawMessage, { length: effectiveRules.minLength })
+      });
+    }
+    if (effectiveRules.requireUppercase || effectiveRules.requireLowercase || effectiveRules.requireNumber || effectiveRules.requireSpecialCharacters) {
+      rules.push({
+        validator: (_rule, value) => {
+          if (!value) {
+            return Promise.resolve();
+          }
+          const requirements = [];
+          if (effectiveRules.requireUppercase && !/[A-Z]/.test(value)) {
+            requirements.push(
+              resolveMessage("requireUppercase", translate, messageKeys)
+            );
+          }
+          if (effectiveRules.requireLowercase && !/[a-z]/.test(value)) {
+            requirements.push(
+              resolveMessage("requireLowercase", translate, messageKeys)
+            );
+          }
+          if (effectiveRules.requireNumber && !/\d/.test(value)) {
+            requirements.push(
+              resolveMessage("requireNumber", translate, messageKeys)
+            );
+          }
+          if (effectiveRules.requireSpecialCharacters && !/[!@#$%^&*]/.test(value)) {
+            requirements.push(
+              resolveMessage("requireSpecialCharacters", translate, messageKeys)
+            );
+          }
+          if (requirements.length > 0) {
+            const template = resolveMessage("summary", translate, messageKeys);
+            return Promise.reject(
+              new Error(
+                formatMessage(template, {
+                  requirements: requirements.join(", ")
+                })
+              )
+            );
+          }
+          return Promise.resolve();
+        }
+      });
+    }
+    return rules;
+  }, [
+    fallbackMinLength,
+    messageKeys == null ? void 0 : messageKeys.requireLowercase,
+    messageKeys == null ? void 0 : messageKeys.requireNumber,
+    messageKeys == null ? void 0 : messageKeys.requireSpecialCharacters,
+    messageKeys == null ? void 0 : messageKeys.requireUppercase,
+    messageKeys == null ? void 0 : messageKeys.minLength,
+    messageKeys == null ? void 0 : messageKeys.required,
+    messageKeys == null ? void 0 : messageKeys.summary,
+    passwordRules == null ? void 0 : passwordRules.minLength,
+    passwordRules == null ? void 0 : passwordRules.requireLowercase,
+    passwordRules == null ? void 0 : passwordRules.requireNumber,
+    passwordRules == null ? void 0 : passwordRules.requireSpecialCharacters,
+    passwordRules == null ? void 0 : passwordRules.requireUppercase,
+    translate
+  ]);
+};
+var usePasswordValidationRules_default = usePasswordValidationRules;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  usePasswordValidationRules
+});

package/lib/pro/Login2.0/hooks/useRegisterFlow.d.ts

@@ -0,0 +1,39 @@
+import { RegisterStep, RegisterFlowData, RegisterFlowConfig, getStepDefinition } from '../shared/registerFlow';
+import type { AuthMethodType } from '../shared/types';
+export interface UseRegisterFlowOptions {
+    /** 账号类型 */
+    accountType: AuthMethodType;
+    /** 邮箱配置 */
+    emailConfig?: {
+        enable_email?: boolean;
+        require_email_verification?: boolean;
+    };
+    /** 手机配置 */
+    phoneConfig?: {
+        enable_phone_number?: boolean;
+        require_phone_verification?: boolean;
+    };
+    /** 初始账号 */
+    initialAccount?: string;
+    /** 步骤变化回调 */
+    onStepChange?: (step: RegisterStep, data: RegisterFlowData) => void;
+    /** 完成回调 */
+    onComplete?: (data: RegisterFlowData) => void;
+}
+export interface UseRegisterFlowReturn {
+    /** 当前流程数据 */
+    flowData: RegisterFlowData;
+    /** 当前步骤定义 */
+    currentStepDef: ReturnType<typeof getStepDefinition>;
+    /** 流程配置 */
+    flowConfig: RegisterFlowConfig;
+    /** 跳转到指定步骤 */
+    goToStep: (step: RegisterStep, updates?: Partial<RegisterFlowData>) => void;
+    /** 更新流程数据 */
+    updateFlowData: (updates: Partial<RegisterFlowData>) => void;
+    /** 重置流程 */
+    resetFlow: () => void;
+    /** 处理错误 */
+    handleError: (code: string, message: string, targetStep?: RegisterStep) => void;
+}
+export declare function useRegisterFlow(options: UseRegisterFlowOptions): UseRegisterFlowReturn;

package/lib/pro/Login2.0/hooks/useRegisterFlow.js

@@ -0,0 +1,149 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/pro/Login2.0/hooks/useRegisterFlow.ts
+var useRegisterFlow_exports = {};
+__export(useRegisterFlow_exports, {
+  useRegisterFlow: () => useRegisterFlow
+});
+module.exports = __toCommonJS(useRegisterFlow_exports);
+var import_react = require("react");
+var import_registerFlow = require("../shared/registerFlow");
+function useRegisterFlow(options) {
+  const {
+    accountType,
+    emailConfig,
+    phoneConfig,
+    initialAccount = "",
+    onStepChange,
+    onComplete
+  } = options;
+  const onStepChangeRef = (0, import_react.useRef)(onStepChange);
+  const onCompleteRef = (0, import_react.useRef)(onComplete);
+  (0, import_react.useEffect)(() => {
+    onStepChangeRef.current = onStepChange;
+    onCompleteRef.current = onComplete;
+  }, [onStepChange, onComplete]);
+  const verificationMethod = (0, import_react.useMemo)(
+    () => (0, import_registerFlow.determineVerificationMethod)(accountType, emailConfig, phoneConfig),
+    [accountType, emailConfig, phoneConfig]
+  );
+  const flowConfig = (0, import_react.useMemo)(
+    () => (0, import_registerFlow.getFlowConfig)(verificationMethod),
+    [verificationMethod]
+  );
+  const autoTransitionTimer = (0, import_react.useRef)();
+  const [flowData, setFlowData] = (0, import_react.useState)({
+    currentStep: import_registerFlow.RegisterStep.INITIAL_FORM,
+    account: initialAccount,
+    accountType,
+    verificationMethod
+  });
+  const currentStepDef = (0, import_registerFlow.getStepDefinition)(flowData.currentStep);
+  const clearAutoTransition = (0, import_react.useCallback)(() => {
+    if (autoTransitionTimer.current) {
+      clearTimeout(autoTransitionTimer.current);
+      autoTransitionTimer.current = void 0;
+    }
+  }, []);
+  const goToStep = (0, import_react.useCallback)(
+    (step, updates) => {
+      setFlowData((prevFlowData) => {
+        var _a, _b, _c;
+        const targetVerificationMethod = (updates == null ? void 0 : updates.verificationMethod) ?? prevFlowData.verificationMethod;
+        if (!(0, import_registerFlow.isValidTransition)(targetVerificationMethod, prevFlowData.currentStep, step)) {
+          console.warn(
+            `Invalid transition from ${prevFlowData.currentStep} to ${step} for ${targetVerificationMethod}`,
+            "(current verificationMethod:",
+            prevFlowData.verificationMethod,
+            ", target:",
+            targetVerificationMethod,
+            ")"
+          );
+          return prevFlowData;
+        }
+        clearAutoTransition();
+        const newFlowData = {
+          ...prevFlowData,
+          ...updates,
+          currentStep: step
+        };
+        (_a = onStepChangeRef.current) == null ? void 0 : _a.call(onStepChangeRef, step, newFlowData);
+        if (step === import_registerFlow.RegisterStep.COMPLETE) {
+          (_b = onCompleteRef.current) == null ? void 0 : _b.call(onCompleteRef, newFlowData);
+        }
+        const autoTransition = (_c = flowConfig.autoTransition) == null ? void 0 : _c[step];
+        if (autoTransition) {
+          autoTransitionTimer.current = setTimeout(() => {
+            goToStep(autoTransition.nextStep);
+          }, autoTransition.delay);
+        }
+        return newFlowData;
+      });
+    },
+    [
+      verificationMethod,
+      flowConfig,
+      clearAutoTransition
+    ]
+  );
+  const updateFlowData = (0, import_react.useCallback)((updates) => {
+    setFlowData((prev) => ({ ...prev, ...updates }));
+  }, []);
+  const resetFlow = (0, import_react.useCallback)(() => {
+    clearAutoTransition();
+    setFlowData({
+      currentStep: import_registerFlow.RegisterStep.INITIAL_FORM,
+      account: initialAccount,
+      accountType,
+      verificationMethod
+    });
+  }, [clearAutoTransition, initialAccount, accountType, verificationMethod]);
+  const handleError = (0, import_react.useCallback)(
+    (code, message, targetStep) => {
+      const errorData = {
+        ...flowData,
+        error: { code, message }
+      };
+      if (targetStep) {
+        errorData.currentStep = targetStep;
+      }
+      setFlowData(errorData);
+      onStepChange == null ? void 0 : onStepChange(errorData.currentStep, errorData);
+    },
+    [flowData, onStepChange]
+  );
+  (0, import_react.useEffect)(() => {
+    return () => {
+      clearAutoTransition();
+    };
+  }, [clearAutoTransition]);
+  return {
+    flowData,
+    currentStepDef,
+    flowConfig,
+    goToStep,
+    updateFlowData,
+    resetFlow,
+    handleError
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useRegisterFlow
+});

package/lib/pro/Login2.0/hooks/useRegistrationMethods.d.ts

@@ -0,0 +1,9 @@
+import { AuthMethodType } from '../shared/types';
+/**
+ * 注册方式相关的逻辑hook
+ */
+export declare function useRegistrationMethods(isRegistrationMethodEnabled: (type: AuthMethodType) => boolean): {
+    enabledMethods: AuthMethodType[];
+    shouldShowDivider: boolean;
+    hasEmailAndPhone: boolean;
+};

package/lib/pro/Login2.0/hooks/useRegistrationMethods.js

@@ -0,0 +1,51 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/pro/Login2.0/hooks/useRegistrationMethods.ts
+var useRegistrationMethods_exports = {};
+__export(useRegistrationMethods_exports, {
+  useRegistrationMethods: () => useRegistrationMethods
+});
+module.exports = __toCommonJS(useRegistrationMethods_exports);
+var import_react = require("react");
+function useRegistrationMethods(isRegistrationMethodEnabled) {
+  const enabledMethods = (0, import_react.useMemo)(() => {
+    const methods = [];
+    if (isRegistrationMethodEnabled("email")) methods.push("email");
+    if (isRegistrationMethodEnabled("phone")) methods.push("phone");
+    if (isRegistrationMethodEnabled("google")) methods.push("google");
+    if (isRegistrationMethodEnabled("facebook")) methods.push("facebook");
+    if (isRegistrationMethodEnabled("apple")) methods.push("apple");
+    return methods;
+  }, [isRegistrationMethodEnabled]);
+  const shouldShowDivider = (0, import_react.useMemo)(() => {
+    return enabledMethods.length > 1;
+  }, [enabledMethods.length]);
+  const hasEmailAndPhone = (0, import_react.useMemo)(() => {
+    return isRegistrationMethodEnabled("email") && isRegistrationMethodEnabled("phone");
+  }, [isRegistrationMethodEnabled]);
+  return {
+    enabledMethods,
+    shouldShowDivider,
+    hasEmailAndPhone
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useRegistrationMethods
+});

package/lib/pro/{multiDayTimeSelect → Login2.0}/index.js

@@ -26,10 +26,20 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/pro/multiDayTimeSelect/index.tsx
-var multiDayTimeSelect_exports = {};
-__export(multiDayTimeSelect_exports, {
-  default: () => import_MultiDayTimeSelect.default
+// src/pro/Login2.0/index.tsx
+var Login2_exports = {};
+__export(Login2_exports, {
+  AuthModal: () => import_AuthModal.default,
+  Login2: () => import_Login2.default,
+  Register2: () => import_Register2.default
+});
+module.exports = __toCommonJS(Login2_exports);
+var import_Login2 = __toESM(require("./Login2"));
+var import_Register2 = __toESM(require("./Register2"));
+var import_AuthModal = __toESM(require("./AuthModal"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthModal,
+  Login2,
+  Register2
 });
-module.exports = __toCommonJS(multiDayTimeSelect_exports);
-var import_MultiDayTimeSelect = __toESM(require("./MultiDayTimeSelect"));