@jcoder-stack/abp-react 0.1.0

package/dist/react.js

@@ -0,0 +1,236 @@
+import {
+  createTranslator
+} from "./chunk-XXJLSSG3.js";
+import {
+  isAbpTrue
+} from "./chunk-HWT6PBBS.js";
+import {
+  createPermissionChecker,
+  isGranted
+} from "./chunk-OK6PUP2E.js";
+
+// src/react/app-config.tsx
+import { createContext, useContext, useMemo, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+var AppConfigContext = createContext(null);
+function AppConfigProvider(props) {
+  const { config, messages, fallbackCulture, children } = props;
+  const callbacksRef = useRef(props);
+  callbacksRef.current = props;
+  const value = useMemo(() => {
+    const makeTranslator = callbacksRef.current.createTranslator ?? createTranslator;
+    return {
+      config,
+      translator: makeTranslator({
+        culture: config.localization.currentCulture.name,
+        backend: config.localization.values,
+        frontend: messages,
+        fallbackCulture,
+        defaultResourceName: config.localization.defaultResourceName ?? void 0,
+        onMissing: (key) => callbacksRef.current.onMissingKey?.(key)
+      })
+    };
+  }, [config, messages, fallbackCulture]);
+  return /* @__PURE__ */ jsx(AppConfigContext.Provider, { value, children });
+}
+function useAppConfigContext() {
+  const ctx = useContext(AppConfigContext);
+  if (ctx === null) throw new Error("useAppConfig* hooks must be used within <AppConfigProvider>");
+  return ctx;
+}
+function useAppConfig() {
+  return useAppConfigContext().config;
+}
+function useLocalization() {
+  const { translator } = useAppConfigContext();
+  return useMemo(() => {
+    const L = ((key, ...args) => translator.t(key, ...args));
+    L.plural = (key, count, ...args) => translator.plural(key, count, ...args);
+    L.has = (key) => translator.has(key);
+    return L;
+  }, [translator]);
+}
+function useCulture() {
+  return useAppConfigContext().config.localization.currentCulture.name;
+}
+function useSetting(name) {
+  return useAppConfigContext().config.setting.values[name];
+}
+function useSettingBoolean(name) {
+  return isAbpTrue(useSetting(name));
+}
+function useFeature(name) {
+  return useAppConfigContext().config.features.values[name];
+}
+function useFeatureEnabled(name) {
+  return isAbpTrue(useFeature(name));
+}
+function FeatureGuard(props) {
+  const { feature, fallback = null, children } = props;
+  return useFeatureEnabled(feature) ? children : fallback;
+}
+
+// src/react/menu.ts
+import { useMemo as useMemo3 } from "react";
+
+// src/react/session.tsx
+import {
+  createContext as createContext2,
+  useCallback,
+  useContext as useContext2,
+  useMemo as useMemo2,
+  useRef as useRef2,
+  useState
+} from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var SessionContext = createContext2(null);
+function SessionProvider(props) {
+  const { identity: hydrated, fetchIdentity, children } = props;
+  const [identity, setIdentity] = useState(hydrated);
+  const [prevHydrated, setPrevHydrated] = useState(hydrated);
+  const generation = useRef2(0);
+  if (hydrated !== prevHydrated) {
+    setPrevHydrated(hydrated);
+    setIdentity(hydrated);
+    generation.current += 1;
+  }
+  const reload = useCallback(async () => {
+    if (fetchIdentity === void 0) return;
+    const started = ++generation.current;
+    const next = await fetchIdentity();
+    if (started === generation.current) setIdentity(next);
+  }, [fetchIdentity]);
+  const value = useMemo2(
+    () => ({
+      identity,
+      status: identity.isAuthenticated ? "authenticated" : "anonymous",
+      can: createPermissionChecker(identity.grantedPolicies),
+      reload
+    }),
+    [identity, reload]
+  );
+  return /* @__PURE__ */ jsx2(SessionContext.Provider, { value, children });
+}
+function useSession() {
+  const ctx = useContext2(SessionContext);
+  if (ctx === null) throw new Error("useSession must be used within <SessionProvider>");
+  return ctx;
+}
+function useCurrentUser() {
+  return useSession().identity.user;
+}
+function useGrantedPolicies() {
+  return useSession().identity.grantedPolicies;
+}
+function usePermissionChecker() {
+  return useSession().can;
+}
+function usePermission(policy) {
+  return useSession().can(policy);
+}
+function PermissionGuard(props) {
+  const { policy, all, any, requireAuth, fallback = null, children } = props;
+  const { identity, can } = useSession();
+  let granted = true;
+  if (policy !== void 0) granted = can(policy);
+  else if (all !== void 0) granted = can.all(all);
+  else if (any !== void 0) granted = can.any(any);
+  if (granted && requireAuth === true) granted = identity.isAuthenticated;
+  return granted ? children : fallback;
+}
+
+// src/react/menu.ts
+function itemAllowed(item, ctx) {
+  if (item.requireAuth === true && ctx.isAuthenticated !== true) {
+    return false;
+  }
+  if (item.requiredPolicy !== void 0 && !isGranted(ctx.grantedPolicies, item.requiredPolicy)) {
+    return false;
+  }
+  if (item.requiredFeature !== void 0 && !isAbpTrue(ctx.features?.[item.requiredFeature])) {
+    return false;
+  }
+  return true;
+}
+function buildMenu(items, ctx) {
+  const result = [];
+  for (const item of items) {
+    if (!itemAllowed(item, ctx)) {
+      continue;
+    }
+    const children = item.children ? buildMenu(item.children, ctx) : void 0;
+    if (item.children !== void 0 && item.to === void 0 && (children === void 0 || children.length === 0)) {
+      continue;
+    }
+    if (children === void 0) {
+      result.push(item);
+    } else if (children.length === 0) {
+      const { children: emptied, ...withoutChildren } = item;
+      result.push(withoutChildren);
+    } else {
+      result.push({ ...item, children });
+    }
+  }
+  return result.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+}
+function mergeMenu(...lists) {
+  return lists.flat();
+}
+function findBreadcrumbs(items, pathname) {
+  let best = [];
+  let bestLength = -1;
+  const walk = (nodes, trail) => {
+    for (const node of nodes) {
+      const chain = [...trail, node];
+      if (node.to === pathname) return chain;
+      if (node.to !== void 0 && node.to.length > bestLength && (node.to === "/" ? pathname === "/" : pathname === node.to || pathname.startsWith(`${node.to}/`))) {
+        best = chain;
+        bestLength = node.to.length;
+      }
+      if (node.children) {
+        const found = walk(node.children, chain);
+        if (found) return found;
+      }
+    }
+    return null;
+  };
+  return walk(items, []) ?? best;
+}
+function useBreadcrumbs(items, pathname) {
+  return useMemo3(() => findBreadcrumbs(items, pathname), [items, pathname]);
+}
+function useMenu(items) {
+  const { identity } = useSession();
+  const config = useAppConfig();
+  return useMemo3(
+    () => buildMenu(items, {
+      grantedPolicies: identity.grantedPolicies,
+      features: config.features.values,
+      isAuthenticated: identity.isAuthenticated
+    }),
+    [items, identity, config]
+  );
+}
+export {
+  AppConfigProvider,
+  FeatureGuard,
+  PermissionGuard,
+  SessionProvider,
+  buildMenu,
+  findBreadcrumbs,
+  mergeMenu,
+  useAppConfig,
+  useBreadcrumbs,
+  useCulture,
+  useCurrentUser,
+  useFeature,
+  useFeatureEnabled,
+  useGrantedPolicies,
+  useLocalization,
+  useMenu,
+  usePermission,
+  usePermissionChecker,
+  useSession,
+  useSetting,
+  useSettingBoolean
+};

package/dist/router.d.ts

@@ -0,0 +1,39 @@
+import { I as Identity } from './types-Bj0MpXtI.js';
+import { P as PermissionStrategy } from './is-granted-C0-1wvoW.js';
+import 'zod';
+
+/** guard 期望的路由上下文：祖先路由（__root beforeLoad）已放入 identity。 */
+interface GuardContext {
+    identity: Identity;
+}
+interface RequirePermissionOptions {
+    /** 缺权限时跳转目标（默认 "/forbidden"）。 */
+    redirectTo?: string;
+    /** 多策略组合方式（默认 "all"）。 */
+    strategy?: PermissionStrategy;
+    /** 给出时，未认证访客先被送去登录（带 returnUrl）而非 403；不给则匿名一律 403。 */
+    loginPath?: string;
+}
+/**
+ * beforeLoad 守卫工厂：缺权限时 redirect（默认 /forbidden）。纯 UX，安全判定在 ABP。
+ * 匿名访客的 grantedPolicies 恒为空，默认因此得到 403；推荐把整个受保护子树挂在
+ * `requireAuth()` 父路由下，或给本守卫传 `loginPath` 让匿名先去登录。
+ * context 缺 identity 时抛 Error。
+ */
+declare function requirePermission(policy: string | string[], opts?: RequirePermissionOptions): ({ context, location }: {
+    context: GuardContext;
+    location?: {
+        href: string;
+    };
+}) => void;
+/** beforeLoad 守卫工厂：未认证时 redirect 到 OIDC 登录（带 returnUrl）。loginPath 自带 query 时用 & 续接。context 缺 identity 时抛 Error。 */
+declare function requireAuth(opts?: {
+    loginPath?: string;
+}): ({ context, location }: {
+    context: GuardContext;
+    location: {
+        href: string;
+    };
+}) => void;
+
+export { type GuardContext, type RequirePermissionOptions, requireAuth, requirePermission };

package/dist/router.js

@@ -0,0 +1,41 @@
+import {
+  isGranted
+} from "./chunk-OK6PUP2E.js";
+
+// src/router/guards.ts
+import { redirect } from "@tanstack/react-router";
+function requireIdentity(context, guardName) {
+  const identity = context.identity;
+  if (identity === void 0) {
+    throw new Error(
+      `${guardName}: context.identity missing \u2014 inject identity in an ancestor route's beforeLoad (see __root)`
+    );
+  }
+  return identity;
+}
+function requirePermission(policy, opts = {}) {
+  return ({ context, location }) => {
+    const identity = requireIdentity(context, "requirePermission");
+    if (isGranted(identity.grantedPolicies, policy, { strategy: opts.strategy })) return;
+    if (opts.loginPath !== void 0 && !identity.isAuthenticated) {
+      throw redirect({ href: withReturnUrl(opts.loginPath, location?.href ?? "/") });
+    }
+    throw redirect({ to: opts.redirectTo ?? "/forbidden" });
+  };
+}
+function withReturnUrl(loginPath, href) {
+  const separator = loginPath.includes("?") ? "&" : "?";
+  return `${loginPath}${separator}returnUrl=${encodeURIComponent(href)}`;
+}
+function requireAuth(opts = {}) {
+  return ({ context, location }) => {
+    const identity = requireIdentity(context, "requireAuth");
+    if (!identity.isAuthenticated) {
+      throw redirect({ href: withReturnUrl(opts.loginPath ?? "/api/auth/login", location.href) });
+    }
+  };
+}
+export {
+  requireAuth,
+  requirePermission
+};

package/dist/translator-B3hyoZmK.d.ts

@@ -0,0 +1,40 @@
+/** Plural form mapping: category name to localized string. */
+type PluralForms = Record<string, string>;
+/** Picks the CLDR plural category via Intl.PluralRules for locale and count; invalid locale tags fall back to 'other', then ''. */
+declare function selectPluralForm(count: number, forms: PluralForms, locale: string): string;
+
+/** Backend ABP resources: resource name to key-value map for the current culture. */
+type BackendResources = Record<string, Record<string, string>>;
+/** Frontend i18n catalog: culture to resource to key to string or plural-forms map. */
+type FrontendCatalog = Record<string, Record<string, Record<string, unknown>>>;
+/** Options for translator creation: culture, backend/frontend resources, fallback culture, the resource a key without an explicit `Resource::` prefix belongs to, missing-key callback, and optional interpolation/plural overrides (e.g. to swap in an ICU MessageFormat engine). */
+interface TranslatorOptions {
+    culture: string;
+    backend?: BackendResources;
+    frontend?: FrontendCatalog;
+    fallbackCulture?: string;
+    /** ABP's `localization.defaultResourceName`; keys written as `::Key` resolve against it. Callers pass it in so this module stays free of any dependency on the configuration package. */
+    defaultResourceName?: string;
+    onMissing?: (key: string) => void;
+    interpolate?: (template: string, args: unknown[]) => string;
+    selectPluralForm?: (count: number, forms: PluralForms, culture: string) => string;
+}
+/** Translator interface: t (string interpolation), plural (plural form selection), and has (resolvability check). */
+interface Translator {
+    /** Translates `key`, falling back to a plural entry's `other` form; returns the key itself when unresolved. */
+    t(key: string, ...args: unknown[]): string;
+    /** Picks the plural form for `count`; a single plain-object arg interpolates by name with `count` merged in, otherwise args are positional with the count at `{0}`. */
+    plural(key: string, count: number, ...args: unknown[]): string;
+    /** True exactly when `t(key)` would return a translation rather than the key.
+     *  A plural entry counts only if it carries an `other` form. */
+    has(key: string): boolean;
+}
+/** Creates a translator. Resolution order: backend (current culture, overrides) → frontend
+ *  (current culture) → frontend (culture's primary subtag) → frontend (fallback culture).
+ *  An unresolved key calls `onMissing` and comes back as-is.
+ *
+ *  `::Key` resolves against `defaultResourceName`. A key with no `::` at all stays on the empty
+ *  resource, which is where frontend catalogs live. */
+declare function createTranslator(opts: TranslatorOptions): Translator;
+
+export { type BackendResources as B, type FrontendCatalog as F, type PluralForms as P, type Translator as T, type TranslatorOptions as a, createTranslator as c, selectPluralForm as s };

package/dist/types-Bj0MpXtI.d.ts

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+
+declare const authTokensSchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    refreshToken: z.ZodOptional<z.ZodString>;
+    idToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** 认证会话：token 集 + 绝对过期（ms）+ 租户/文化上下文。绝密，server-only。 */
+declare const authSessionSchema: z.ZodObject<{
+    tokens: z.ZodObject<{
+        accessToken: z.ZodString;
+        refreshToken: z.ZodOptional<z.ZodString>;
+        idToken: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    expiresAt: z.ZodOptional<z.ZodNumber>;
+    tenant: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    culture: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type AuthSession = z.infer<typeof authSessionSchema>;
+/** 身份视图：可注水到客户端；结构上不含 token。授权判定仍在后端，这里只是能力转述。 */
+interface Identity {
+    isAuthenticated: boolean;
+    user: {
+        id: string;
+        userName: string;
+        email?: string;
+        roles: string[];
+    } | null;
+    grantedPolicies: Record<string, boolean>;
+    tenant: {
+        id: string;
+        name: string | null;
+    } | null;
+}
+/** 策略统一产出：SessionManager.establish 的输入。expiresAt 缺省表示 IdP 未返回 expires_in。 */
+interface TokenResult {
+    tokens: {
+        accessToken: string;
+        refreshToken?: string;
+        idToken?: string;
+    };
+    expiresAt?: number;
+}
+interface BeginInput {
+    returnUrl: string;
+    tenant?: string | null;
+}
+/**
+ * 重定向式握手暂存态：适配层密封进短命 cookie，callback 时开出交还策略。
+ * `issuedAt`（ms）让策略在服务端判寿命。只靠 cookie 的 maxAge 是浏览器侧约束，密文本身不会因此失效。
+ */
+declare const handshakeSchema: z.ZodObject<{
+    state: z.ZodString;
+    nonce: z.ZodString;
+    codeVerifier: z.ZodString;
+    returnUrl: z.ZodString;
+    issuedAt: z.ZodNumber;
+}, z.core.$strip>;
+type Handshake = z.infer<typeof handshakeSchema>;
+type CompleteInput = {
+    kind: "callback";
+    params: URLSearchParams;
+    handshake: Handshake;
+} | {
+    kind: "credentials";
+    userName: string;
+    password: string;
+    tenant?: string | null;
+};
+/** 一个登录策略：证明你是谁 → 产出 TokenResult。协议细节内化在实现里。 */
+interface AuthStrategy {
+    readonly name: string;
+    begin?(input: BeginInput): Promise<{
+        redirectUrl: string;
+        handshake: Handshake;
+    }>;
+    complete(input: CompleteInput): Promise<TokenResult>;
+}
+/** 存储 seam：默认实现是加密分块 cookie（自包含）；有状态 store 只需换实现。save/clear 需要请求 Cookie 头才能清掉当前存在的所有旧分块（save 不传则只多清一个尾块）。 */
+interface SessionStore {
+    load(cookieHeader: string | null): Promise<AuthSession | null>;
+    save(session: AuthSession, cookieHeader?: string | null): Promise<string[]>;
+    clear(cookieHeader: string | null): Promise<string[]>;
+}
+/** 身份解析的请求上下文；`cookieHeader` 携带匿名访客的租户/文化选择，无请求上下文时传 null。 */
+interface IdentityContext {
+    cookieHeader: string | null;
+}
+/**
+ * 后端无关的身份解析 seam；ABP 实现在 proxy 域经代理拉 application-configuration。
+ * 权限与本地化随租户变化，故解析必须能看到请求上下文，只认 session 的实现会把匿名访客
+ * 一律按 host 租户解析。
+ */
+type IdentityResolver = (session: AuthSession | null, ctx: IdentityContext) => Promise<Identity>;
+type FetchFn = typeof fetch;
+
+export { type AuthSession as A, type BeginInput as B, type CompleteInput as C, type FetchFn as F, type Handshake as H, type Identity as I, type SessionStore as S, type TokenResult as T, type IdentityResolver as a, type AuthStrategy as b, type IdentityContext as c, authSessionSchema as d, authTokensSchema as e, handshakeSchema as h };

package/package.json

@@ -0,0 +1,116 @@
+{
+  "name": "@jcoder-stack/abp-react",
+  "description": "纯 React ABP 前端框架运行时：日志、ABP 类型与 zod 解析、fetch client、认证会话、ABP 代理网关、权限、i18n、React Provider/hooks、TanStack Router 守卫；按子路径分域导出",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jcoder-stack/abp-react-start.git",
+    "directory": "packages/abp-react"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "exports": {
+    "./core": {
+      "types": "./dist/core.d.ts",
+      "default": "./dist/core.js"
+    },
+    "./permissions": {
+      "types": "./dist/permissions.d.ts",
+      "default": "./dist/permissions.js"
+    },
+    "./i18n": {
+      "types": "./dist/i18n.d.ts",
+      "default": "./dist/i18n.js"
+    },
+    "./logger": {
+      "types": "./dist/logger.d.ts",
+      "default": "./dist/logger.js"
+    },
+    "./auth": {
+      "types": "./dist/auth.d.ts",
+      "default": "./dist/auth.js"
+    },
+    "./proxy": {
+      "types": "./dist/proxy.d.ts",
+      "default": "./dist/proxy.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "default": "./dist/react.js"
+    },
+    "./router": {
+      "types": "./dist/router.d.ts",
+      "default": "./dist/router.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "peerDependencies": {
+    "@tanstack/react-router": "^1.170.18",
+    "react": "^18 || ^19",
+    "zod": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@tanstack/react-router": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@tanstack/react-router": "^1.0.0",
+    "react": "^19.0.0",
+    "zod": "^4.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      "./core": {
+        "types": "./dist/core.d.ts",
+        "default": "./dist/core.js"
+      },
+      "./permissions": {
+        "types": "./dist/permissions.d.ts",
+        "default": "./dist/permissions.js"
+      },
+      "./i18n": {
+        "types": "./dist/i18n.d.ts",
+        "default": "./dist/i18n.js"
+      },
+      "./logger": {
+        "types": "./dist/logger.d.ts",
+        "default": "./dist/logger.js"
+      },
+      "./auth": {
+        "types": "./dist/auth.d.ts",
+        "default": "./dist/auth.js"
+      },
+      "./proxy": {
+        "types": "./dist/proxy.d.ts",
+        "default": "./dist/proxy.js"
+      },
+      "./react": {
+        "types": "./dist/react.d.ts",
+        "default": "./dist/react.js"
+      },
+      "./router": {
+        "types": "./dist/router.d.ts",
+        "default": "./dist/router.js"
+      },
+      "./package.json": "./package.json"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "npm exec --no -- tsup",
+    "prepack": "node ../../scripts/apply-publish-config.mjs",
+    "postpack": "node ../../scripts/restore-publish-config.mjs"
+  }
+}