@epxing/utils 0.0.0-stage → 5.3.0-beta.1

package/src/token-storage.js

@@ -0,0 +1,120 @@
+import storage from './storage'
+
+const memoryTokens = Object.create(null)
+const memoryOnlyTokens = Object.create(null)
+let urlTokenConsumed = false
+
+const tokenTimes = token => {
+  try {
+    const encodedPayload = token.split('.')[1]
+    if (!encodedPayload) return null
+    const base64 = encodedPayload.replace(/-/g, '+').replace(/_/g, '/')
+    const padding = '='.repeat((4 - base64.length % 4) % 4)
+    const claims = JSON.parse(window.atob(base64 + padding))
+    return {
+      issuedAt: Number(claims.iat) || 0,
+      expiresAt: Number(claims.exp) || 0
+    }
+  } catch (error) {
+    return null
+  }
+}
+
+const preferCandidateToken = (candidate, current) => {
+  if (!candidate || candidate === current) return false
+  if (!current) return true
+  const candidateTimes = tokenTimes(candidate)
+  const currentTimes = tokenTimes(current)
+  if (!candidateTimes || !currentTimes) return false
+  const now = Math.floor(Date.now() / 1000)
+  const candidateValid = !candidateTimes.expiresAt || candidateTimes.expiresAt > now
+  const currentValid = !currentTimes.expiresAt || currentTimes.expiresAt > now
+  if (candidateValid !== currentValid) return candidateValid
+  if (candidateTimes.issuedAt !== currentTimes.issuedAt) {
+    return candidateTimes.issuedAt > currentTimes.issuedAt
+  }
+  return candidateTimes.expiresAt > currentTimes.expiresAt
+}
+
+const getUrlParam = (name, path) => {
+  const query = (path || '').split('?').slice(1).join('?')
+  if (!query) return ''
+  const item = query.split('&').find(part => part.split('=')[0] === name)
+  if (!item) return ''
+  const value = item.split('=').slice(1).join('=')
+  try {
+    return decodeURIComponent(value)
+  } catch (error) {
+    return value
+  }
+}
+
+const removeTokenParams = path => {
+  const parts = path.split('?')
+  if (parts.length < 2) return path
+  const query = parts.slice(1).join('?').split('&').filter(item => {
+    const name = item.split('=')[0]
+    return name !== 'token' && name !== '_token'
+  })
+  return parts[0] + (query.length ? '?' + query.join('&') : '')
+}
+
+const clearUrlTokenParams = () => {
+  const search = removeTokenParams(window.location.search)
+  const hash = removeTokenParams(window.location.hash)
+  const url = window.location.pathname + search + hash
+  try {
+    window.history.replaceState(window.history.state, document.title, url)
+  } catch (error) {
+    // 受限 iframe 可能禁止改写历史记录；模块级标记仍能保证 URL Token 只消费一次。
+  }
+}
+
+export const getStoredToken = storageKey => {
+  const token = storage.get(storageKey) || ''
+  if (token) {
+    memoryTokens[storageKey] = token
+    delete memoryOnlyTokens[storageKey]
+    return token
+  }
+  if (memoryOnlyTokens[storageKey]) return memoryTokens[storageKey] || ''
+  delete memoryTokens[storageKey]
+  return ''
+}
+
+export const setStoredToken = (storageKey, token) => {
+  if (!token) return
+  memoryTokens[storageKey] = token
+  let persisted = storage.set(storageKey, token)
+  if (persisted === undefined) {
+    persisted = storage.set(storageKey, token, { session: true })
+  }
+  if (persisted === undefined) memoryOnlyTokens[storageKey] = true
+  else delete memoryOnlyTokens[storageKey]
+}
+
+export const removeStoredToken = storageKey => {
+  delete memoryTokens[storageKey]
+  delete memoryOnlyTokens[storageKey]
+  storage.remove(storageKey)
+}
+
+export const consumeUrlToken = storageKey => {
+  const storedToken = getStoredToken(storageKey)
+  if (urlTokenConsumed || !storageKey) return storedToken
+  const urlToken = (
+    getUrlParam('_token', window.location.hash) ||
+    getUrlParam('token', window.location.hash) ||
+    getUrlParam('_token', window.location.search) ||
+    getUrlParam('token', window.location.search)
+  ).replace(/^Bearer\s+/i, '').trim()
+  if (!urlToken) return storedToken
+
+  urlTokenConsumed = true
+  if (preferCandidateToken(urlToken, storedToken)) {
+    setStoredToken(storageKey, urlToken)
+  }
+  clearUrlTokenParams()
+
+  return getStoredToken(storageKey)
+}

package/src/util.js

@@ -0,0 +1,2 @@
+// 兼容旧路径；新代码从 @epxing/core 导入。
+export { default } from '@epxing/core/src/runtime-utils/util'

package/types/Config.d.ts

@@ -0,0 +1,4 @@
+export default Config;
+declare class Config {
+    set(config: any): void;
+}

package/types/collection.d.ts

@@ -0,0 +1,40 @@
+/** @type {<T>(value: T) => T} */
+export const cloneDeep: <T>(value: T) => T;
+/** @type {(value: unknown) => value is null | undefined} */
+export const isNil: (value: unknown) => value is null | undefined;
+/** @type {(value: unknown) => boolean} */
+export const isEmpty: (value: unknown) => boolean;
+/** @type {(value: unknown) => value is object} */
+export const isObject: (value: unknown) => value is object;
+/** @type {(value: unknown, other: unknown) => boolean} */
+export const isEqual: (value: unknown, other: unknown) => boolean;
+/** @type {<T extends object>(object: T, ...sources: any[]) => T} */
+export const assignWith: <T extends object>(object: T, ...sources: any[]) => T;
+/** @type {<T extends (...args: any[]) => any>(func: T, wait?: number, options?: { leading?: boolean, trailing?: boolean, maxWait?: number }) => T & { cancel(): void, flush(): ReturnType<T> | undefined }} */
+export const debounce: <T extends (...args: any[]) => any>(func: T, wait?: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+    maxWait?: number;
+}) => T & {
+    cancel(): void;
+    flush(): ReturnType<T> | undefined;
+};
+/** @type {typeof debounce} */
+export const throttle: typeof debounce;
+/** @type {(object: unknown, path: string | (string | number)[], defaultValue?: any) => any} */
+export const get: (object: unknown, path: string | (string | number)[], defaultValue?: any) => any;
+/** @type {<T extends object>(object: T, path: string | (string | number)[], value: any) => T} */
+export const set: <T extends object>(object: T, path: string | (string | number)[], value: any) => T;
+declare namespace _default {
+    export { cloneDeep };
+    export { isNil };
+    export { isEmpty };
+    export { isObject };
+    export { isEqual };
+    export { assignWith };
+    export { debounce };
+    export { throttle };
+    export { get };
+    export { set };
+}
+export default _default;

package/types/date-helper.d.ts

@@ -0,0 +1,11 @@
+export function isDate(date: any): boolean;
+export function getDayCountOfMonth(year: any, month: any): number;
+export function getDayCountOfYear(year: any): 366 | 365;
+export function nextDate(date: any, amount?: number): Date;
+export function nextMonth(date: any): Date;
+export function prevYear(date: any, amount?: number): Date;
+export function nextYear(date: any, amount?: number): Date;
+export function range(n: any): any;
+export function modifyDate(date: any, y: any, m: any, d: any): Date;
+export function modifyTime(date: any, h: any, m: any, s: any): Date;
+export function modifyWithTimeString(date: any, time: any): any;

package/types/date-time.d.ts

@@ -0,0 +1,2 @@
+export * from './moment-compat'
+export { default } from './moment-compat'

package/types/date.d.ts

@@ -0,0 +1 @@
+export * from './date-helper'

package/types/dom-helper.d.ts

@@ -0,0 +1,3 @@
+export function hasClass(el: any, cls: any): any;
+export function arrayFindIndex(arr: any, pred: any): number;
+export function coerceTruthyValueToArray(val: any): any[];

package/types/dom.d.ts

@@ -0,0 +1 @@
+export * from './dom-helper'

package/types/index.d.ts

@@ -0,0 +1 @@
+export * from './public'

package/types/moment-compat.d.ts

@@ -0,0 +1,91 @@
+import type { Dayjs } from 'dayjs'
+import type { Duration } from 'dayjs/plugin/duration'
+
+/** 对应 moment-compat.js 的 READ_METHODS / WRITE_METHODS，保留可变链式语义。 */
+export interface MomentLike {
+  format(format?: string): string
+  valueOf(): number
+  unix(): number
+  toDate(): Date
+  toISOString(): string | null
+  toJSON(): string | null
+  toString(): string
+  toArray(): number[]
+  toObject(): Record<string, number>
+  isValid(): boolean
+  clone(): MomentLike
+  diff(input?: unknown, unit?: string, precise?: boolean): number
+  isBefore(input?: unknown, unit?: string): boolean
+  isAfter(input?: unknown, unit?: string): boolean
+  isSame(input?: unknown, unit?: string): boolean
+  isSameOrBefore(input?: unknown, unit?: string): boolean
+  isSameOrAfter(input?: unknown, unit?: string): boolean
+  isBetween(start: unknown, end: unknown, unit?: string | null, inclusivity?: string): boolean
+  isLeapYear(): boolean
+  daysInMonth(): number
+  get(unit: string): number
+  from(input: unknown, withoutSuffix?: boolean): string
+  to(input: unknown, withoutSuffix?: boolean): string
+  fromNow(withoutSuffix?: boolean): string
+  toNow(withoutSuffix?: boolean): string
+  calendar(reference?: unknown, formats?: Record<string, string | ((...args: any[]) => string)>): string
+  utcOffset(): number
+  utcOffset(offset: number | string, keepLocalTime?: boolean): MomentLike
+  weekday(): number
+  weekday(value: number): MomentLike
+  isoWeekday(): number
+  isoWeekday(value: number): MomentLike
+  add(amount: number | Duration, unit?: string): this
+  subtract(amount: number | Duration, unit?: string): this
+  startOf(unit: string): this
+  endOf(unit: string): this
+  set(unit: string, value: number): this
+  set(values: Record<string, number>): this
+  local(): this
+  utc(keepLocalTime?: boolean): this
+  locale(): string
+  locale(name: string): this
+  year(): number
+  year(value: number): this
+  month(): number
+  month(value: number): this
+  date(): number
+  date(value: number): this
+  day(): number
+  day(value: number): this
+  hour(): number
+  hour(value: number): this
+  minute(): number
+  minute(value: number): this
+  second(): number
+  second(value: number): this
+  millisecond(): number
+  millisecond(value: number): this
+  quarter(): number
+  quarter(value: number): this
+  week(): number
+  week(value: number): this
+  isoWeek(): number
+  isoWeek(value: number): this
+  dayOfYear(): number
+  dayOfYear(value: number): this
+}
+export interface MomentFactory {
+  (input?: unknown, ...formatAndOptions: any[]): MomentLike
+  duration(input?: unknown, ...unit: any[]): Duration
+  locale(name?: string): string
+  isMoment(value: unknown): value is MomentLike
+  unix(seconds: number): MomentLike
+  utc(input?: unknown, ...formatAndOptions: any[]): MomentLike
+  max(...dates: (MomentLike | Dayjs | (MomentLike | Dayjs)[])[]): MomentLike
+  min(...dates: (MomentLike | Dayjs | (MomentLike | Dayjs)[])[]): MomentLike
+}
+declare const moment: MomentFactory
+export { moment as createMoment }
+export default moment
+export declare function preprocessFormat(format: string, milliseconds?: number, year?: number): string
+export declare const READ_METHODS: string[]
+export declare const WRITE_METHODS: string[]
+export declare const DUAL_METHODS: Set<string>
+export declare const PASSTHROUGH: Set<string>
+export declare const UNSUPPORTED_FORMAT_TOKENS: string[]

package/types/page.d.ts

@@ -0,0 +1,56 @@
+export default Page;
+declare class Page {
+    constructor(props: any);
+    label: any;
+    title: any;
+    linkEntitys: any;
+    relatedEntitys: any;
+    sysId: any;
+    config: any;
+    flag: any;
+    pageId: any;
+    templateId: any;
+    metaId: any;
+    metaCode: any;
+    pagePath: any;
+    pageCode: any;
+    system: any;
+    systemCode: any;
+    help: any;
+    rightControlMode: any;
+    visualConfigPath: any;
+    getPageId(): any;
+    getLabel(): any;
+    getMetaId(): any;
+    getFlag(): any;
+    getPagePath(): any;
+    getConfig(): any;
+    /**
+   * 主键字段
+   * @return {}
+   */
+    getKey(): any;
+    /**
+   * 获取所有属性
+   * @return {}
+   */
+    getAttris(): any;
+    /**
+   * ID对应LAVEL
+   */
+    getIdLabelAttris(): any[];
+    /**
+   * NAME对应LAVEL
+   */
+    getNameLabelAttris(): any[];
+    /**
+   * 根据字段ID获取字段Name
+   * @param {} attriId
+   * @return {}
+   */
+    getAttriNameById(attriId: any): any;
+    /**
+     * 根据字段key获取label
+     */
+    getLabelByField(field: any): any;
+}

package/types/placeholder.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 按属性路径在**一个**来源里取值。
+ * 只按 `.` 和 `[...]` 分段；`|` 当普通字符（字段名可能长这样：`busi|NAME`）。
+ * @returns {{ found: boolean, value: any }} found 区分「没有这个路径」与「值恰好是 undefined」
+ */
+export function lookup(path: any, source: any): {
+    found: boolean;
+    value: any;
+};
+/**
+ * 按给定顺序在多个来源里找第一个**拥有**该路径的。
+ * @param {string} path
+ * @param {Array<object>} sources 有序来源，如 [this, this.$query, this.$tab]
+ * @returns {{ found: boolean, value: any, index: number }} index 为命中的来源下标，未命中为 -1
+ */
+export function resolveKey(path: string, sources?: Array<object>): {
+    found: boolean;
+    value: any;
+    index: number;
+};
+/**
+ * 替换字符串里的全部 `#{path}`。
+ * @param {string} text
+ * @param {Array<object>} sources 有序来源
+ * @param {object} [options]
+ * @param {'empty'|'keep'} [options.onMissing='empty']
+ *        'empty' —— 取不到就换成空串（与存量 `… || ''` 的收尾一致，是默认）
+ *        'keep'  —— 原样保留 `#{path}`。⚠️ 保留下来的是**非空字符串**，
+ *                   也就是真值，`a || b` 形式的兜底会失效——选它之前先确认调用方判得了。
+ * @returns {string}
+ */
+export function resolvePlaceholders(text: string, sources?: Array<object>, options?: {
+    onMissing?: "empty" | "keep";
+}): string;
+export const PLACEHOLDER_RE: RegExp;
+declare namespace _default {
+    export { PLACEHOLDER_RE };
+    export { lookup };
+    export { resolveKey };
+    export { resolvePlaceholders };
+}
+export default _default;

package/types/public.d.ts

@@ -0,0 +1,10 @@
+export { default as Config } from "./Config";
+export { default as Page } from "./page";
+export { default as placeholder } from "./placeholder";
+export * from "./placeholder";
+export * from "./date-helper";
+export * from "./dom-helper";
+export * from "./collection";
+export { default as lodash } from "./collection";
+export { default as storage, getXsrfToken, setXsrfToken, default as cookie } from "./storage";
+export { default as moment, default as dateTime, createMoment } from "./moment-compat";

package/types/storage.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 防 CSRF 令牌：由后端通过响应头 `xsrf_token`（或 `X-XSRF-TOKEN`）下发，
+ * axios 响应拦截器写入 sessionStorage（随标签页关闭失效），请求拦截器再回填到
+ * `xsrf_token` 请求头 / 下载类 URL 的 `xsrf_token` 查询参数。
+ */
+export const XSRF_TOKEN_KEY: "xsrf_token";
+export function getXsrfToken(): string;
+export function setXsrfToken(token: any): void;
+export function clearXsrfToken(): void;
+export default storage;
+declare namespace storage {
+    /**
+     * @param {string} key
+     * @returns {string | undefined} 不存在或已过期返回 undefined（与 js-cookie 一致）
+     */
+    function get(key: string): string | undefined;
+    /**
+     * @param {string} key
+     * @param {*} value 非字符串会被转成字符串（对象走 JSON.stringify）
+     * @param {{ expires?: number | Date, session?: boolean }} [options]
+     * @returns {string | undefined} 实际写入的字符串
+     */
+    function set(key: string, value: any, options?: {
+        expires?: number | Date;
+        session?: boolean;
+    }): string | undefined;
+    /**
+     * @param {string} key
+     */
+    function remove(key: string): void;
+}