@pisell/private-materials 6.3.29 → 6.3.31

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/Login2.0/index.js

@@ -0,0 +1,45 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// 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
+});