create-secra 0.1.4 → 0.1.7

package/antd-adapter-template/packages/sdk/src/i18n/index.ts

@@ -0,0 +1,150 @@
+import { $t, setLang, setupI18n } from "@vlian/framework/library";
+
+export type SdkLang = "en-US" | "zh-CN";
+
+export const sdkLocales: Record<SdkLang, Record<string, unknown>> = {
+  "en-US": {
+    secraAdmin: {
+      login: {
+        subtitle: "Unified identity authentication and admin portal",
+        otherLoginMethods: "Other login methods",
+        accountTab: "Account Login",
+        phoneTab: "Phone Login",
+        autoLogin: "Remember me",
+        forgotPassword: "Forgot password",
+        usernamePlaceholder: "Username: admin or user",
+        usernameRequired: "Please enter your username!",
+        passwordPlaceholder: "Password: ant.design",
+        passwordRequired: "Please enter your password!",
+        passwordStrengthText:
+          "Password should contain numbers, letters and special characters, at least 8 characters long.",
+        passwordStrengthWeak: "Strength: Weak",
+        passwordStrengthMedium: "Strength: Medium",
+        passwordStrengthStrong: "Strength: Strong",
+        mobilePlaceholder: "Phone number",
+        mobileRequired: "Please enter your phone number!",
+        mobileInvalid: "Invalid phone number format!",
+        captchaPlaceholder: "Please enter verification code",
+        captchaRequired: "Please enter verification code!",
+        captchaButton: "Get code",
+        captchaButtonTiming: "{{count}} Get code",
+        captchaSuccess: "Code sent successfully! Verification code: 1234",
+        phoneLoginNotReady: "Phone login is not connected to backend yet",
+        loginSuccessTitle: "Login successful",
+        loginWelcomeUser: "Welcome, {{username}}",
+        loginFailedCheckCredentials: "Login failed, please check your username and password",
+      },
+      home: {
+        title: "Theme sync between antd and @vlian/framework",
+        currentMode: "Current mode",
+        resolvedMode: "Resolved",
+        modeSwitchTitle: "Mode switch",
+        unifiedThemeTitle: "Unified theme (single primary color)",
+        previewTitle: "Sync preview",
+        currentUnifiedThemeTitle: "Current unified theme state",
+        themePreset: "Theme preset",
+        mode: {
+          light: "Light",
+          dark: "Dark",
+          system: "System",
+        },
+      },
+    },
+  },
+  "zh-CN": {
+    secraAdmin: {
+      login: {
+        subtitle: "统一身份认证与后台管理入口",
+        otherLoginMethods: "其他登录方式",
+        accountTab: "账号密码登录",
+        phoneTab: "手机号登录",
+        autoLogin: "自动登录",
+        forgotPassword: "忘记密码",
+        usernamePlaceholder: "用户名: admin or user",
+        usernameRequired: "请输入用户名!",
+        passwordPlaceholder: "密码: ant.design",
+        passwordRequired: "请输入密码！",
+        passwordStrengthText:
+          "Password should contain numbers, letters and special characters, at least 8 characters long.",
+        passwordStrengthWeak: "强度：弱",
+        passwordStrengthMedium: "强度：中",
+        passwordStrengthStrong: "强度：强",
+        mobilePlaceholder: "手机号",
+        mobileRequired: "请输入手机号！",
+        mobileInvalid: "手机号格式错误！",
+        captchaPlaceholder: "请输入验证码",
+        captchaRequired: "请输入验证码！",
+        captchaButton: "获取验证码",
+        captchaButtonTiming: "{{count}} 获取验证码",
+        captchaSuccess: "获取验证码成功！验证码为：1234",
+        phoneLoginNotReady: "手机号登录暂未接入后端",
+        loginSuccessTitle: "登录成功",
+        loginWelcomeUser: "欢迎，{{username}}",
+        loginFailedCheckCredentials: "登录失败，请检查账号密码",
+      },
+      home: {
+        title: "antd + @vlian/framework 主题联动",
+        currentMode: "当前模式",
+        resolvedMode: "解析后",
+        modeSwitchTitle: "模式切换",
+        unifiedThemeTitle: "统一主题（单一主色驱动）",
+        previewTitle: "同步结果预览",
+        currentUnifiedThemeTitle: "当前统一主题状态",
+        themePreset: "主题预设",
+        mode: {
+          light: "浅色",
+          dark: "深色",
+          system: "跟随系统",
+        },
+      },
+    },
+  },
+};
+
+type SetupSdkI18nOptions = {
+  lang?: SdkLang;
+  locales?: Partial<Record<SdkLang, Record<string, unknown>>>;
+};
+
+const isPlainRecord = (value: unknown): value is Record<string, unknown> => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  return Object.prototype.toString.call(value) === "[object Object]";
+};
+
+const deepMergeLocale = (
+  base: Record<string, unknown>,
+  override: Record<string, unknown>,
+): Record<string, unknown> => {
+  const merged: Record<string, unknown> = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    const previous = merged[key];
+    if (isPlainRecord(previous) && isPlainRecord(value)) {
+      merged[key] = deepMergeLocale(previous, value);
+      continue;
+    }
+    merged[key] = value;
+  }
+  return merged;
+};
+
+export function getSdkI18nLocales(locales: SetupSdkI18nOptions["locales"] = {}) {
+  const enOverride = locales["en-US"] ?? {};
+  const zhOverride = locales["zh-CN"] ?? {};
+
+  return {
+    "en-US": deepMergeLocale(sdkLocales["en-US"], enOverride),
+    "zh-CN": deepMergeLocale(sdkLocales["zh-CN"], zhOverride),
+  } as Record<SdkLang, Record<string, unknown>>;
+}
+
+export function setupSdkI18n(options: SetupSdkI18nOptions = {}) {
+  const { lang = "zh-CN", locales = {} } = options;
+
+  setupI18n(getSdkI18nLocales(locales));
+
+  setLang(lang);
+}
+
+export { setLang as setSdkLang, $t as t };

package/antd-adapter-template/packages/sdk/src/index.ts

@@ -0,0 +1,11 @@
+/**
+ * 根入口只导出运行时通用能力（theme/components/storage/i18n/hooks）。
+ * request/build 通过子路径导出，避免将构建时依赖耦合进运行时入口。
+ * - @vlian/sdk/request
+ * - @vlian/sdk/build
+ */
+export * from "./theme/index.js";
+export * from "./components/index.js";
+export * from "./storage/index.js";
+export * from "./i18n/index.js";
+export * from "./hooks/index.js";

package/antd-adapter-template/packages/sdk/src/request/index.ts

@@ -0,0 +1,436 @@
+import {
+  RequestClient,
+  RequestError,
+  RequestErrorCode,
+  RequestErrorType,
+  axiosAdapter,
+  kyAdapter,
+  type RequestBody,
+  type RequestHeaders,
+  type RequestOptions,
+  type RequestQuery,
+  type Response,
+  PluginPriority,
+  type RequestPlugin,
+  type RequestClientConfig,
+} from "@vlian/framework/request";
+
+export interface ApiResponse<T = unknown> {
+  data: T;
+  code: number;
+  message: string;
+}
+
+export interface SdkRequestMeta extends Record<string, unknown> {
+  /** Disable default error message prompt. */
+  silent?: boolean;
+  /** Explicitly control error message prompt. */
+  showErrorMessage?: boolean;
+}
+
+export interface SdkRequestOptions<TResponse = unknown>
+  extends Omit<RequestOptions<TResponse>, "body" | "query" | "_responseType"> {
+  data?: RequestBody;
+  params?: RequestQuery;
+  meta?: SdkRequestMeta;
+  body?: RequestBody;
+  query?: RequestQuery;
+  _responseType?: SdkResponse<TResponse>;
+}
+
+export interface SdkResponse<T = unknown> {
+  data: T | undefined;
+  code: number;
+  message: string;
+  headers: RequestHeaders;
+  raw: unknown;
+  status: number;
+  error: boolean;
+  version: string;
+}
+
+export interface SdkSuccessContext<T = unknown> {
+  status: number;
+  normalized: ApiResponse<T>;
+  response: Response<unknown>;
+}
+
+export type SdkSuccessPredicate<T = unknown> = (context: SdkSuccessContext<T>) => boolean;
+
+const DEFAULT_MESSAGE = "消息提示";
+const RESPONSE_VERSION = "1.0.0";
+export const SDK_REQUEST_VERSION = RESPONSE_VERSION;
+const DEFAULT_SUCCESS_PREDICATE: SdkSuccessPredicate = ({ status, normalized }) =>
+  status === 200 && normalized.code === 0;
+
+const getMessageHandler = (): ((message: string) => void) | null => {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const message = (window as unknown as { $message?: { error?: (msg: string) => void } })
+    .$message;
+  if (message && typeof message.error === "function") {
+    return message.error.bind(message);
+  }
+  return null;
+};
+
+const extractMessage = (payload: unknown): string | undefined => {
+  if (!payload || typeof payload !== "object") {
+    return undefined;
+  }
+  if ("error" in payload) {
+    const errorPayload = (payload as { error?: unknown }).error;
+    const errorMessage = extractMessage(errorPayload);
+    if (errorMessage) {
+      return errorMessage;
+    }
+  }
+  if ("message" in payload && typeof (payload as { message?: unknown }).message === "string") {
+    return (payload as { message: string }).message;
+  }
+  return undefined;
+};
+
+const toSafeErrorMessage = (value: unknown, fallback: string): string => {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed || fallback;
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (typeof value === "symbol") {
+    return value.toString();
+  }
+  if (value && typeof value === "object") {
+    const nestedMessage = extractMessage(value);
+    if (nestedMessage) {
+      return nestedMessage;
+    }
+    try {
+      const serialized = JSON.stringify(value);
+      if (serialized && serialized !== "{}") {
+        return serialized;
+      }
+    } catch {
+      // Ignore serialization failures and continue fallback chain.
+    }
+    try {
+      return Object.prototype.toString.call(value);
+    } catch {
+      return fallback;
+    }
+  }
+  try {
+    const stringValue = String(value);
+    return stringValue && stringValue !== "undefined" && stringValue !== "null"
+      ? stringValue
+      : fallback;
+  } catch {
+    return fallback;
+  }
+};
+
+const extractErrorPayload = (error: RequestError): unknown => {
+  if (error.response?.data) {
+    return error.response.data;
+  }
+  const cause = error.cause as { response?: { data?: unknown } } | undefined;
+  if (cause?.response?.data) {
+    return cause.response.data;
+  }
+  return undefined;
+};
+
+const normalizeResponse = <T>(payload: unknown, status: number): ApiResponse<T> => {
+  const objectPayload = payload && typeof payload === "object" ? (payload as Record<string, unknown>) : undefined;
+  const hasEnvelope =
+    !!objectPayload && ("code" in objectPayload || "message" in objectPayload || "data" in objectPayload);
+  const data =
+    objectPayload && "data" in objectPayload
+      ? (objectPayload.data as T)
+      : (hasEnvelope ? (undefined as T) : (payload as T));
+  const codeValue =
+    objectPayload && "code" in objectPayload ? objectPayload.code : status === 200 ? 0 : status;
+  const code =
+    typeof codeValue === "number"
+      ? (Number.isFinite(codeValue) ? codeValue : 0)
+      : (() => {
+          const parsed = Number(codeValue ?? 0);
+          return Number.isFinite(parsed) ? parsed : 0;
+        })();
+  const message =
+    objectPayload && "message" in objectPayload
+      ? toSafeErrorMessage(objectPayload.message, DEFAULT_MESSAGE)
+      : DEFAULT_MESSAGE;
+  return {
+    data,
+    code,
+    message,
+  };
+};
+
+const createDefaultResponsePlugin = (options?: {
+  successPredicate?: SdkSuccessPredicate;
+}): RequestPlugin => ({
+  name: "sdk-default-response",
+  priority: PluginPriority.HIGH,
+  onAfterRequest(context) {
+    const successPredicate = options?.successPredicate ?? DEFAULT_SUCCESS_PREDICATE;
+    const response = context.response as Response<unknown> | undefined;
+    if (!response) {
+      return;
+    }
+    const normalized = normalizeResponse(response.data, response.status);
+    const isSuccess = successPredicate({
+      status: response.status,
+      normalized,
+      response,
+    });
+    const transformed: SdkResponse<unknown> = {
+      data: normalized.data as unknown,
+      code: normalized.code,
+      message: normalized.message,
+      raw: response.raw,
+      headers: response.headers || {},
+      status: response.status,
+      error: !isSuccess,
+      version: RESPONSE_VERSION,
+    };
+    const mergedResponse = {
+      ...response,
+      data: transformed,
+    } as Response<SdkResponse<unknown>>;
+
+    if (isSuccess) {
+      return mergedResponse;
+    }
+
+    throw new RequestError(
+      normalized.message || `HTTP ${response.status} 错误`,
+      response.status === 200 ? RequestErrorType.UNKNOWN_ERROR : RequestErrorType.HTTP_ERROR,
+      response.status >= 500 ? RequestErrorCode.SERVER_ERROR : RequestErrorCode.CLIENT_ERROR,
+      {
+        status: response.status,
+        response: mergedResponse,
+      },
+    );
+  },
+  onError(context) {
+    const { error, request } = context;
+    if (!error || !request) {
+      return;
+    }
+    const meta = (request.meta || {}) as SdkRequestMeta;
+    if (meta.silent === true || meta.showErrorMessage === false) {
+      return;
+    }
+    if (error.type === RequestErrorType.ABORT_ERROR) {
+      return;
+    }
+    let message = toSafeErrorMessage(error.message, "请求失败");
+    if (error.type === RequestErrorType.NETWORK_ERROR) {
+      message = "网络连接失败，请检查网络";
+    } else if (error.type === RequestErrorType.TIMEOUT_ERROR) {
+      message = "请求超时，请稍后重试";
+    } else {
+      const payload = extractErrorPayload(error);
+      if (payload) {
+        message = extractMessage(payload) || message;
+      }
+    }
+
+    const handler = getMessageHandler();
+    if (handler) {
+      handler(message);
+    } else if (typeof console !== "undefined") {
+      console.error(message);
+    }
+  },
+});
+
+const mapRequestOptions = <T>(options: SdkRequestOptions<T>): RequestOptions<SdkResponse<T>> => ({
+  ...options,
+  body: options.body ?? options.data,
+  query: options.query ?? options.params,
+  meta: options.meta as Record<string, unknown> | undefined,
+});
+
+class SdkRequestClient {
+  private client: RequestClient;
+  private initPromise?: Promise<void>;
+  private successPredicate: SdkSuccessPredicate;
+
+  constructor(config: RequestClientConfig & { successPredicate?: SdkSuccessPredicate }) {
+    const { successPredicate, ...requestClientConfig } = config;
+    this.successPredicate = successPredicate ?? DEFAULT_SUCCESS_PREDICATE;
+    this.client = new RequestClient(requestClientConfig);
+  }
+
+  private async ensureInitialized() {
+    if (!this.initPromise) {
+      this.initPromise = this.client.initialize();
+    }
+    await this.initPromise;
+  }
+
+  async request<TResponse = unknown>(
+    options: SdkRequestOptions<TResponse>,
+  ): Promise<SdkResponse<TResponse>> {
+    await this.ensureInitialized();
+    let response: Response<unknown>;
+    try {
+      response = await this.client.request<unknown>(mapRequestOptions(options));
+    } catch (error) {
+      if (error instanceof RequestError) {
+        throw error;
+      }
+      throw new RequestError(
+        toSafeErrorMessage(error, "请求失败"),
+        RequestErrorType.UNKNOWN_ERROR,
+        RequestErrorCode.CLIENT_ERROR,
+        {
+          cause: error,
+          request: mapRequestOptions(options),
+          context: {
+            source: "sdk-request-client.request",
+          },
+        },
+      );
+    }
+    const payload = response.data as SdkResponse<TResponse> | Record<string, unknown> | null | undefined;
+    if (payload && typeof payload === "object" && "version" in payload) {
+      return payload as SdkResponse<TResponse>;
+    }
+    const normalized = normalizeResponse<TResponse>(response.data, response.status);
+    const isSuccess = this.successPredicate({
+      status: response.status,
+      normalized,
+      response: response as Response<unknown>,
+    });
+    return {
+      data: normalized.data as TResponse,
+      code: normalized.code,
+      message: normalized.message,
+      headers: response.headers || {},
+      raw: response.raw,
+      status: response.status,
+      error: !isSuccess,
+      version: RESPONSE_VERSION,
+    };
+  }
+
+  async get<TResponse = unknown>(
+    urlOrOptions: string | SdkRequestOptions<TResponse>,
+    options?: SdkRequestOptions<TResponse>,
+  ): Promise<SdkResponse<TResponse>> {
+    if (typeof urlOrOptions === "string") {
+      return this.request({
+        ...(options || {}),
+        url: urlOrOptions,
+        method: "GET",
+      });
+    }
+    return this.request({
+      ...urlOrOptions,
+      method: "GET",
+    });
+  }
+
+  async post<TResponse = unknown>(
+    urlOrOptions: string | SdkRequestOptions<TResponse>,
+    data?: RequestBody,
+    options?: SdkRequestOptions<TResponse>,
+  ): Promise<SdkResponse<TResponse>> {
+    if (typeof urlOrOptions === "string") {
+      return this.request({
+        ...(options || {}),
+        url: urlOrOptions,
+        method: "POST",
+        data,
+      });
+    }
+    return this.request({
+      ...urlOrOptions,
+      method: "POST",
+    });
+  }
+
+  async put<TResponse = unknown>(
+    urlOrOptions: string | SdkRequestOptions<TResponse>,
+    data?: RequestBody,
+    options?: SdkRequestOptions<TResponse>,
+  ): Promise<SdkResponse<TResponse>> {
+    if (typeof urlOrOptions === "string") {
+      return this.request({
+        ...(options || {}),
+        url: urlOrOptions,
+        method: "PUT",
+        data,
+      });
+    }
+    return this.request({
+      ...urlOrOptions,
+      method: "PUT",
+    });
+  }
+
+  async patch<TResponse = unknown>(
+    urlOrOptions: string | SdkRequestOptions<TResponse>,
+    data?: RequestBody,
+    options?: SdkRequestOptions<TResponse>,
+  ): Promise<SdkResponse<TResponse>> {
+    if (typeof urlOrOptions === "string") {
+      return this.request({
+        ...(options || {}),
+        url: urlOrOptions,
+        method: "PATCH",
+        data,
+      });
+    }
+    return this.request({
+      ...urlOrOptions,
+      method: "PATCH",
+    });
+  }
+
+  async delete<TResponse = unknown>(
+    urlOrOptions: string | SdkRequestOptions<TResponse>,
+    options?: SdkRequestOptions<TResponse>,
+  ): Promise<SdkResponse<TResponse>> {
+    if (typeof urlOrOptions === "string") {
+      return this.request({
+        ...(options || {}),
+        url: urlOrOptions,
+        method: "DELETE",
+      });
+    }
+    return this.request({
+      ...urlOrOptions,
+      method: "DELETE",
+    });
+  }
+
+  async setAdapter(adapter: string | (() => Promise<unknown>)) {
+    await this.ensureInitialized();
+    // @ts-expect-error - adapter type is ensured by request client
+    await this.client.setAdapter(adapter);
+  }
+}
+
+export const platformRequestClient = new SdkRequestClient({
+  defaultAdapter: kyAdapter,
+  plugins: [createDefaultResponsePlugin()],
+  successPredicate: DEFAULT_SUCCESS_PREDICATE,
+});
+
+// export const uploadRequestClient = new SdkRequestClient({
+//   defaultAdapter: axiosAdapter,
+//   plugins: [createDefaultResponsePlugin()],
+//   successPredicate: DEFAULT_SUCCESS_PREDICATE,
+// });
+
+// export const createSdkRequestPlugin = (options?: {
+//   successPredicate?: SdkSuccessPredicate;
+// }) => createDefaultResponsePlugin(options);

package/antd-adapter-template/packages/sdk/src/storage/README.md

@@ -0,0 +1,30 @@
+# Storage 使用示例
+
+以下示例基于 `cache` 对象，演示 `localStorage`、`sessionStorage`、`indexedDB` 三种缓存方式。
+
+## localStorage
+
+```ts
+import { cache } from "./index.js";
+
+await cache.localstorage.set("user:token", "token-demo-value", 60 * 60 * 1000);
+const token = await cache.localstorage.get<string>("user:token");
+```
+
+## sessionStorage
+
+```ts
+import { cache } from "./index.js";
+
+await cache.sessionStorage.set("page:draft", { title: "草稿标题" });
+const draft = await cache.sessionStorage.get<{ title: string }>("page:draft");
+```
+
+## indexedDB
+
+```ts
+import { cache } from "./index.js";
+
+await cache.indexeddb.set("table:list", [{ id: 1, name: "demo" }]);
+const list = await cache.indexeddb.get<Array<{ id: number; name: string }>>("table:list");
+```

package/antd-adapter-template/packages/sdk/src/storage/index.ts

@@ -0,0 +1,57 @@
+import { storage } from "@vlian/framework/library";
+
+export type StorageStrategy = "localstorage" | "sessionStorage" | "indexeddb";
+
+export interface CacheMethods {
+  get<T>(key: string): Promise<T | null>;
+  set<T>(key: string, value: T, expire?: number): Promise<void>;
+  remove(key: string): Promise<void>;
+  clean(): Promise<void>;
+}
+
+let initialized = false;
+
+const ensureStorageInitialized = () => {
+  if (initialized) {
+    return;
+  }
+
+  storage.initialize({
+    prefix: "secra-admin-sdk",
+    tableName: "secra-admin-sdk",
+    defaultExpire: 24 * 60 * 60 * 1000,
+  });
+  initialized = true;
+};
+
+const createCacheMethods = (
+  getter: () => {
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, options?: { expire?: number }): Promise<void>;
+    remove(key: string): Promise<void>;
+    clean(): Promise<void>;
+  },
+): CacheMethods => ({
+  async get<T>(key: string): Promise<T | null> {
+    ensureStorageInitialized();
+    return getter().get<T>(key);
+  },
+  async set<T>(key: string, value: T, expire?: number): Promise<void> {
+    ensureStorageInitialized();
+    await getter().set(key, value, expire !== undefined ? { expire } : undefined);
+  },
+  async remove(key: string): Promise<void> {
+    ensureStorageInitialized();
+    await getter().remove(key);
+  },
+  async clean(): Promise<void> {
+    ensureStorageInitialized();
+    await getter().clean();
+  },
+});
+
+export const cache: Record<StorageStrategy, CacheMethods> = {
+  localstorage: createCacheMethods(() => storage.local),
+  sessionStorage: createCacheMethods(() => storage.session),
+  indexeddb: createCacheMethods(() => storage.indexedDB),
+};