@jcoder-stack/abp-react 0.1.0

package/dist/chunk-UDMHSDXZ.js

@@ -0,0 +1,161 @@
+// src/logger/levels.ts
+var LEVEL_ORDER = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  silent: 100
+};
+function isLevelEnabled(messageLevel, threshold) {
+  return LEVEL_ORDER[messageLevel] >= LEVEL_ORDER[threshold];
+}
+
+// src/logger/browser.ts
+var VALID_LEVELS = new Set(Object.keys(LEVEL_ORDER));
+function parseBrowserOverride(raw) {
+  if (!raw) return null;
+  const sepIndex = raw.indexOf(":");
+  const levelPart = sepIndex === -1 ? raw : raw.slice(0, sepIndex);
+  const hasLevel = VALID_LEVELS.has(levelPart);
+  const scopePart = hasLevel ? raw.slice(levelPart.length + 1) : raw;
+  const result = {};
+  if (hasLevel) {
+    result.level = levelPart;
+  }
+  const scopes = scopePart.split(",").map((s) => s.trim()).filter(Boolean);
+  result.scopes = scopes.length ? scopes : null;
+  return result;
+}
+
+// src/logger/redact.ts
+var REDACT_MASK = "***REDACTED***";
+var DEFAULT_REDACT_KEYS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "access_token",
+  "refresh_token",
+  "id_token",
+  "client_secret",
+  "code_verifier",
+  "password"
+];
+function isPlainObject(val) {
+  const proto = Object.getPrototypeOf(val);
+  return proto === Object.prototype || proto === null;
+}
+function redact(value, keys = DEFAULT_REDACT_KEYS, mask = REDACT_MASK) {
+  const keySet = new Set(keys.map((k) => k.toLowerCase()));
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (val) => {
+    if (val === null || typeof val !== "object") return val;
+    if (val instanceof Error) {
+      return { name: val.name, message: val.message, stack: val.stack };
+    }
+    if (val instanceof Date) return val.toISOString();
+    const isWalkable = Array.isArray(val) || val instanceof Map || val instanceof Set || isPlainObject(val);
+    if (!isWalkable) return String(val);
+    if (seen.has(val)) return "[Circular]";
+    seen.add(val);
+    try {
+      if (Array.isArray(val)) return val.map((v) => walk(v));
+      if (val instanceof Set) return [...val].map((v) => walk(v));
+      const entries = val instanceof Map ? [...val].map(([k, v]) => [String(k), v]) : Object.entries(val);
+      const out = {};
+      for (const [k, v] of entries) {
+        out[k] = keySet.has(k.toLowerCase()) ? mask : walk(v);
+      }
+      return out;
+    } finally {
+      seen.delete(val);
+    }
+  };
+  return walk(value);
+}
+
+// src/logger/config.ts
+var VALID_LEVELS2 = new Set(Object.keys(LEVEL_ORDER));
+function parseLevel(raw) {
+  if (raw && VALID_LEVELS2.has(raw)) return raw;
+  return "info";
+}
+function parseScopes(raw) {
+  if (!raw) return null;
+  const list = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  return list.length ? list : null;
+}
+function resolveConfig(env) {
+  return {
+    enabled: env.LOG_ENABLED !== "false",
+    level: parseLevel(env.LOG_LEVEL),
+    scopes: parseScopes(env.LOG_SCOPES),
+    redactKeys: [...DEFAULT_REDACT_KEYS]
+  };
+}
+function scopeEnabled(scope, scopes) {
+  if (scopes === null) return true;
+  return scopes.some((s) => scope === s || scope.startsWith(`${s}:`));
+}
+
+// src/logger/sink.ts
+var consoleSink = {
+  write(record) {
+    const line = `[${record.time}] ${record.level.toUpperCase()} [${record.scope}] ${record.message}`;
+    const method = record.level === "error" ? "error" : record.level === "warn" ? "warn" : "log";
+    if (record.fields) console[method](line, record.fields);
+    else console[method](line);
+  }
+};
+
+// src/logger/logger.ts
+function createMemorySink() {
+  const records = [];
+  return { sink: { write: (r) => records.push(r) }, records };
+}
+function createLogger(opts) {
+  const config = opts.config ?? resolveConfig(typeof process !== "undefined" ? process.env : {});
+  const sink = opts.sink ?? consoleSink;
+  const scope = opts.scope;
+  const boundFields = opts.fields;
+  const emit = (level, message, fields) => {
+    if (!config.enabled) return;
+    if (!isLevelEnabled(level, config.level)) return;
+    if (!scopeEnabled(scope, config.scopes)) return;
+    const merged = boundFields || fields ? { ...boundFields, ...fields } : void 0;
+    sink.write({
+      level,
+      scope,
+      message,
+      fields: merged ? redact(merged, config.redactKeys) : void 0,
+      time: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  };
+  return {
+    trace: (m, f) => emit("trace", m, f),
+    debug: (m, f) => emit("debug", m, f),
+    info: (m, f) => emit("info", m, f),
+    warn: (m, f) => emit("warn", m, f),
+    error: (m, f) => emit("error", m, f),
+    child: (childOpts) => createLogger({
+      scope: childOpts.scope ? `${scope}:${childOpts.scope}` : scope,
+      config,
+      sink,
+      fields: childOpts.fields ? { ...boundFields, ...childOpts.fields } : boundFields
+    })
+  };
+}
+
+export {
+  LEVEL_ORDER,
+  isLevelEnabled,
+  parseBrowserOverride,
+  REDACT_MASK,
+  DEFAULT_REDACT_KEYS,
+  redact,
+  resolveConfig,
+  scopeEnabled,
+  consoleSink,
+  createMemorySink,
+  createLogger
+};

package/dist/chunk-XXJLSSG3.js

@@ -0,0 +1,116 @@
+// src/i18n/interpolate.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function interpolate(template, args) {
+  if (args.length === 1 && isPlainObject(args[0])) {
+    const named = args[0];
+    return template.replace(/\{(\w+)\}/g, (match, key) => {
+      const value = named[key];
+      return value === void 0 ? match : String(value);
+    });
+  }
+  return template.replace(/\{(\d+)\}/g, (match, digits) => {
+    const value = args[Number(digits)];
+    return value === void 0 ? match : String(value);
+  });
+}
+
+// src/i18n/person-name.ts
+var SURNAME_FIRST_PREFIXES = ["zh", "ja", "ko"];
+function formatPersonName(opts) {
+  const name = opts.name ?? "";
+  const surname = opts.surname ?? "";
+  if (!name || !surname) return name || surname;
+  const lang = opts.culture.split("-")[0]?.toLowerCase() ?? "";
+  return SURNAME_FIRST_PREFIXES.includes(lang) ? `${surname}${name}` : `${name} ${surname}`;
+}
+
+// src/i18n/plural.ts
+var rulesCache = /* @__PURE__ */ new Map();
+function rulesFor(locale) {
+  let rules = rulesCache.get(locale);
+  if (rules === void 0) {
+    try {
+      rules = new Intl.PluralRules(locale);
+    } catch {
+      rules = null;
+    }
+    rulesCache.set(locale, rules);
+  }
+  return rules;
+}
+function selectPluralForm(count, forms, locale) {
+  const category = rulesFor(locale)?.select(count);
+  return (category !== void 0 ? forms[category] : void 0) ?? forms.other ?? "";
+}
+
+// src/i18n/translator.ts
+function splitKey(key) {
+  const index = key.indexOf("::");
+  if (index === -1) return { resource: null, name: key };
+  return { resource: key.slice(0, index), name: key.slice(index + 2) };
+}
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asPluralForms(value) {
+  return isPlainObject2(value) ? value : void 0;
+}
+function pluralArgs(count, args) {
+  if (args.length === 1 && isPlainObject2(args[0])) return [{ ...args[0], count }];
+  return [count, ...args];
+}
+function toTemplate(value) {
+  if (typeof value === "string") return value;
+  const other = asPluralForms(value)?.other;
+  return typeof other === "string" ? other : void 0;
+}
+function createTranslator(opts) {
+  const interp = opts.interpolate ?? interpolate;
+  const selectPlural = opts.selectPluralForm ?? selectPluralForm;
+  const primarySubtag = opts.culture.split("-")[0];
+  const frontendCultures = primarySubtag && primarySubtag !== opts.culture ? [opts.culture, primarySubtag] : [opts.culture];
+  const resolve = (key) => {
+    const { resource: prefix, name } = splitKey(key);
+    const resource = prefix === null ? "" : prefix === "" ? opts.defaultResourceName ?? "" : prefix;
+    const backendValue = opts.backend?.[resource]?.[name];
+    if (backendValue !== void 0) return backendValue;
+    for (const culture of frontendCultures) {
+      const frontendValue = opts.frontend?.[culture]?.[resource]?.[name];
+      if (frontendValue !== void 0) return frontendValue;
+    }
+    if (opts.fallbackCulture) {
+      const frontendFallback = opts.frontend?.[opts.fallbackCulture]?.[resource]?.[name];
+      if (frontendFallback !== void 0) return frontendFallback;
+    }
+    return void 0;
+  };
+  return {
+    t(key, ...args) {
+      const template = toTemplate(resolve(key));
+      if (template !== void 0) return interp(template, args);
+      opts.onMissing?.(key);
+      return key;
+    },
+    plural(key, count, ...args) {
+      const value = resolve(key);
+      const interpArgs = pluralArgs(count, args);
+      if (typeof value === "string") return interp(value, interpArgs);
+      const forms = asPluralForms(value);
+      if (forms) return interp(selectPlural(count, forms, opts.culture), interpArgs);
+      opts.onMissing?.(key);
+      return key;
+    },
+    has(key) {
+      return toTemplate(resolve(key)) !== void 0;
+    }
+  };
+}
+
+export {
+  interpolate,
+  formatPersonName,
+  selectPluralForm,
+  createTranslator
+};

package/dist/core.d.ts

@@ -0,0 +1,65 @@
+export { A as ApplicationConfiguration, C as CurrentTenant, a as CurrentUser, L as Localization, b as applicationConfigurationSchema, c as currentTenantSchema, d as currentUserSchema, l as localizationSchema, p as parseApplicationConfiguration } from './application-configuration-DhOZRqtz.js';
+import 'zod';
+
+/**
+ * Whether an ABP setting/feature string value means `true`.
+ *
+ * The comparison must stay case-insensitive: ABP reads these values with `bool.Parse` and never
+ * normalizes them, so a provider default ships as `"true"` while anything saved through the
+ * settings/features UI comes back as C# `bool.ToString()` output, i.e. `"True"`. A strict `=== "true"`
+ * silently turns whole features off the first time an admin hits Save.
+ */
+declare function isAbpTrue(value: string | undefined | null): boolean;
+
+interface AbpValidationError {
+    message: string;
+    members?: string[];
+}
+declare class HttpError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    readonly validationErrors?: AbpValidationError[];
+    readonly body?: unknown;
+    constructor(status: number, message: string, options?: {
+        code?: string;
+        validationErrors?: AbpValidationError[];
+        body?: unknown;
+    });
+}
+/** 把上游响应体归一为 HttpError；ABP 错误信封的 message/code 会被提取，畸形 validationErrors 一律丢弃。 */
+declare function toHttpError(status: number, body: unknown): HttpError;
+
+/** A list page normalized for consumption: a concrete array plus the server-side total. */
+interface PagedResult<T> {
+    items: T[];
+    totalCount: number;
+}
+/** Normalize an ABP paged DTO into a `PagedResult<T>` with a concrete array and count, so list
+ *  views can share one generic shape. orval generates items/totalCount as optional or nullable. */
+declare function toPagedResult<T>(dto: {
+    items?: T[] | null;
+    totalCount?: number;
+} | null | undefined): PagedResult<T>;
+/** Generic list state (pagination, sorting, filtering). */
+interface ListState {
+    pageIndex: number;
+    pageSize: number;
+    sorting?: {
+        id: string;
+        desc: boolean;
+    }[];
+    filter?: string;
+}
+/** ABP list protocol parameters for request payloads. */
+interface AbpListParams {
+    SkipCount: number;
+    MaxResultCount: number;
+    Sorting?: string;
+    Filter?: string;
+}
+/** Convert generic list state to ABP list protocol parameters. Request-side counterpart to
+ *  `toPagedResult`. Out-of-range paging is clamped (SkipCount >= 0, MaxResultCount >= 1):
+ *  ABP answers a negative skip or a non-positive page size with a 400. */
+declare function toAbpListParams(state: ListState): AbpListParams;
+
+export { type AbpListParams, type AbpValidationError, HttpError, type ListState, type PagedResult, isAbpTrue, toAbpListParams, toHttpError, toPagedResult };

package/dist/core.js

@@ -0,0 +1,24 @@
+import {
+  HttpError,
+  applicationConfigurationSchema,
+  currentTenantSchema,
+  currentUserSchema,
+  isAbpTrue,
+  localizationSchema,
+  parseApplicationConfiguration,
+  toAbpListParams,
+  toHttpError,
+  toPagedResult
+} from "./chunk-HWT6PBBS.js";
+export {
+  HttpError,
+  applicationConfigurationSchema,
+  currentTenantSchema,
+  currentUserSchema,
+  isAbpTrue,
+  localizationSchema,
+  parseApplicationConfiguration,
+  toAbpListParams,
+  toHttpError,
+  toPagedResult
+};

package/dist/i18n.d.ts

@@ -0,0 +1,18 @@
+export { B as BackendResources, F as FrontendCatalog, P as PluralForms, T as Translator, a as TranslatorOptions, c as createTranslator, s as selectPluralForm } from './translator-B3hyoZmK.js';
+
+/**
+ * 使用命名 `{name}` 或位置 `{0}` 参数插值；单个普通对象用命名参数，否则用位置参数。
+ *
+ * 未命中或取值为 `undefined` 的占位符原样保留。「没给值」与「给了 undefined」对读者是同一件事，
+ * 渲染成字面 `undefined` 只会让缺参数的 bug 更难认。不支持转义：模板里的字面 `{0}` 无法保留。
+ */
+declare function interpolate(template: string, args: unknown[]): string;
+
+/** 按文化拼装人名：CJK 姓前名后连写，其余名前姓后空格分隔；缺一取一。 */
+declare function formatPersonName(opts: {
+    name?: string | null;
+    surname?: string | null;
+    culture: string;
+}): string;
+
+export { formatPersonName, interpolate };

package/dist/i18n.js

@@ -0,0 +1,12 @@
+import {
+  createTranslator,
+  formatPersonName,
+  interpolate,
+  selectPluralForm
+} from "./chunk-XXJLSSG3.js";
+export {
+  createTranslator,
+  formatPersonName,
+  interpolate,
+  selectPluralForm
+};

package/dist/is-granted-C0-1wvoW.d.ts

@@ -0,0 +1,10 @@
+/** Map of policy names to their grant status. */
+type GrantedPolicies = Record<string, boolean>;
+/** Strategy for combining multiple policies: 'all' (AND) or 'any' (OR). */
+type PermissionStrategy = "all" | "any";
+/** Check if one or more policies are granted; empty array is vacuously true for 'all', false for 'any'. */
+declare function isGranted(policies: GrantedPolicies, policy: string | string[], opts?: {
+    strategy?: PermissionStrategy;
+}): boolean;
+
+export { type GrantedPolicies as G, type PermissionStrategy as P, isGranted as i };

package/dist/logger-BSnS65IC.d.ts

@@ -0,0 +1,60 @@
+/** Levels a log record can actually carry. */
+type LogLevel = "trace" | "debug" | "info" | "warn" | "error";
+/** Levels accepted as a configured threshold; `silent` only ever suppresses, it is never emitted. */
+type LogThreshold = LogLevel | "silent";
+declare const LEVEL_ORDER: Record<LogThreshold, number>;
+declare function isLevelEnabled(messageLevel: LogLevel, threshold: LogThreshold): boolean;
+
+interface LoggerConfig {
+    enabled: boolean;
+    level: LogThreshold;
+    scopes: string[] | null;
+    redactKeys: string[];
+}
+declare function resolveConfig(env: Record<string, string | undefined>): LoggerConfig;
+declare function scopeEnabled(scope: string, scopes: string[] | null): boolean;
+
+/** One emitted log entry handed to a sink; `level` never carries the `silent` threshold. */
+interface LogRecord {
+    level: LogLevel;
+    scope: string;
+    message: string;
+    fields?: Record<string, unknown>;
+    time: string;
+}
+interface LogSink {
+    write(record: LogRecord): void;
+}
+declare const consoleSink: LogSink;
+
+/**
+ * Scoped, level-filtered logger.
+ *
+ * Only `fields` go through redaction. The `message` string is written verbatim, so anything
+ * sensitive (tokens, cookies, credential-bearing URLs) must be passed as a field rather than
+ * interpolated into the message.
+ */
+interface Logger {
+    trace(message: string, fields?: Record<string, unknown>): void;
+    debug(message: string, fields?: Record<string, unknown>): void;
+    info(message: string, fields?: Record<string, unknown>): void;
+    warn(message: string, fields?: Record<string, unknown>): void;
+    error(message: string, fields?: Record<string, unknown>): void;
+    child(opts: {
+        scope?: string;
+        fields?: Record<string, unknown>;
+    }): Logger;
+}
+declare function createMemorySink(): {
+    sink: LogSink;
+    records: LogRecord[];
+};
+/** Creates a logger for `scope`, writing to `sink` (console by default) every record that passes the config's level and scope filters; `fields` are bound to every record and redacted, while message strings are logged as-is and must not carry secrets. */
+declare function createLogger(opts: {
+    scope: string;
+    config?: LoggerConfig;
+    sink?: LogSink;
+    fields?: Record<string, unknown>;
+}): Logger;
+
+export { type LogThreshold as L, LEVEL_ORDER as a, type LogLevel as b, type LogRecord as c, type LogSink as d, type Logger as e, type LoggerConfig as f, consoleSink as g, createLogger as h, createMemorySink as i, isLevelEnabled as j, resolveConfig as r, scopeEnabled as s };

package/dist/logger.d.ts

@@ -0,0 +1,26 @@
+import { L as LogThreshold } from './logger-BSnS65IC.js';
+export { a as LEVEL_ORDER, b as LogLevel, c as LogRecord, d as LogSink, e as Logger, f as LoggerConfig, g as consoleSink, h as createLogger, i as createMemorySink, j as isLevelEnabled, r as resolveConfig, s as scopeEnabled } from './logger-BSnS65IC.js';
+
+/** Parses a browser log override into the pieces that override the resolved config. Accepts
+ *  `"level"`, `"level:scope,scope"` or a bare `"scope,scope"`. Returns null for an empty value;
+ *  `scopes: null` means "no scope filter". */
+declare function parseBrowserOverride(raw: string | null): {
+    level?: LogThreshold;
+    scopes?: string[] | null;
+} | null;
+
+declare const REDACT_MASK = "***REDACTED***";
+/**
+ * Field names masked by `redact` unless the caller passes its own list.
+ *
+ * Deliberately limited to actual credentials. Names that merely *appear* in an auth flow but are
+ * not secret stay off the list. The OAuth `state` nonce is the notable one: it travels in plain
+ * sight in the browser URL, and as the default of a published package, masking a name as common
+ * as `state` costs far more in unreadable logs than it buys in protection. Add domain-specific names through
+ * the `redactKeys` option instead.
+ */
+declare const DEFAULT_REDACT_KEYS: string[];
+/** Returns a deep copy of `value` with any property whose name matches `keys` (case-insensitive) replaced by `mask`; walks arrays, plain objects, Maps and Sets, renders Error/Date readably, and marks cycles as `[Circular]`. Never mutates the input. */
+declare function redact(value: unknown, keys?: string[], mask?: string): unknown;
+
+export { DEFAULT_REDACT_KEYS, LogThreshold, REDACT_MASK, parseBrowserOverride, redact };

package/dist/logger.js

@@ -0,0 +1,26 @@
+import {
+  DEFAULT_REDACT_KEYS,
+  LEVEL_ORDER,
+  REDACT_MASK,
+  consoleSink,
+  createLogger,
+  createMemorySink,
+  isLevelEnabled,
+  parseBrowserOverride,
+  redact,
+  resolveConfig,
+  scopeEnabled
+} from "./chunk-UDMHSDXZ.js";
+export {
+  DEFAULT_REDACT_KEYS,
+  LEVEL_ORDER,
+  REDACT_MASK,
+  consoleSink,
+  createLogger,
+  createMemorySink,
+  isLevelEnabled,
+  parseBrowserOverride,
+  redact,
+  resolveConfig,
+  scopeEnabled
+};