@vope/utils 1.6.3 → 1.6.5

package/dist/cron.d.ts

@@ -85,6 +85,9 @@ export declare const default_max_month = 12;
 export declare const default_min_month = 1;
 export declare const default_max_week = 6;
 export declare const default_min_week = 0;
+/**
+ * 生成Cron表达式正则
+ */
 export declare const createCronRegexText: (options?: Options) => {
     regex: string;
     enableSlot: boolean;
@@ -94,74 +97,110 @@ export declare const createCronRegexText: (options?: Options) => {
     enableWeekLast: boolean;
     enableInvalid: boolean;
 };
-interface BasicValue {
+interface BasicUnit {
     text(): string;
 }
-export declare class InvalidValue implements BasicValue {
+/**
+ * 占位符单元(即'?')
+ */
+export declare class InvalidUnit implements BasicUnit {
     private isEnableInvalid;
     constructor(isEnableInvalid: boolean);
     text(): "?" | "*";
 }
-export declare const isInvalidValue: (value: unknown) => value is InvalidValue;
-declare abstract class LastValue implements BasicValue {
+/**
+ * 判断一个值是否为占位符单元
+ */
+export declare const isInvalidUnit: (value: unknown) => value is InvalidUnit;
+declare abstract class LastValue implements BasicUnit {
     value: number;
     constructor(value: number);
     abstract text(): string;
 }
-export declare class DayLastValue extends LastValue {
+/**
+ * 倒数(日)值单元
+ */
+export declare class DayLastUnit extends LastValue {
     text(): string;
 }
-export declare const isDayLastValue: (value: unknown) => value is DayLastValue;
-export declare class WeekLastValue extends LastValue {
+/**
+ * 判断一个值是否为倒数(日)值单元
+ */
+export declare const isDayLastUnit: (value: unknown) => value is DayLastUnit;
+/**
+ * 倒数(周)值单元
+ */
+export declare class WeekLastUnit extends LastValue {
     text(): string;
 }
-export declare const isWeekLastValue: (value: unknown) => value is WeekLastValue;
-export declare class WildcardValue implements BasicValue {
+/**
+ * 判断一个值是否为倒数(周)值单元
+ */
+export declare const isWeekLastUnit: (value: unknown) => value is WeekLastUnit;
+/**
+ * 通配值单元(即'*')
+ */
+export declare class WildcardUnit implements BasicUnit {
     text(): string;
 }
-export declare const isWildcardValue: (value: unknown) => value is WildcardValue;
-export declare class RangeValue implements BasicValue {
+/**
+ * 判断一个值是否为通配值单元
+ */
+export declare const isWildcardUnit: (value: unknown) => value is WildcardUnit;
+/**
+ * 范围值单元
+ */
+export declare class RangeUnit implements BasicUnit {
     start: number;
     stop: number;
     constructor(start: number, stop: number);
     text(): string;
 }
-export declare const isRangeValue: (value: unknown) => value is RangeValue;
-type IGroup = number | DayLastValue | WeekLastValue | RangeValue;
-type IValues = WildcardValue | IGroup[];
-export declare class DigitsValue implements BasicValue {
+/**
+ * 判断一个值是否为范围值单元
+ */
+export declare const isRangeUnit: (value: unknown) => value is RangeUnit;
+type IGroup = number | DayLastUnit | WeekLastUnit | RangeUnit;
+type IValues = WildcardUnit | IGroup[];
+/**
+ * 聚合值单元
+ */
+export declare class AggUnit implements BasicUnit {
     values: IValues;
     increment?: number | undefined;
     constructor(values: IValues, increment?: number | undefined);
     text(): string;
 }
-export declare const isDigitsValue: (value: unknown) => value is DigitsValue;
-type Digits<T extends string = never> = '*' | number | T | (number | T | [number, number])[];
-type BasicDigits = Digits;
-type DayDigits = Digits<'L' | `L-${number}`>;
-type WeekDigits = Digits<`${number}L`>;
+/**
+ * 判断一个值是否为聚合值单元
+ */
+export declare const isAggUnit: (value: unknown) => value is AggUnit;
+type IValue<T extends string = never> = '*' | number | T | (number | T | [number, number])[];
+type BasicValue = IValue;
+type DayValue = IValue<'L' | `L-${number}`>;
+type WeekValue = IValue<`${number}L`>;
 declare class Parse {
     cron: Cron;
-    second?: DigitsValue;
-    minute: DigitsValue;
-    hour: DigitsValue;
-    day: InvalidValue | DigitsValue;
-    month: DigitsValue;
-    week: InvalidValue | DigitsValue;
-    year?: DigitsValue;
+    second?: AggUnit;
+    minute: AggUnit;
+    hour: AggUnit;
+    day: InvalidUnit | AggUnit;
+    month: AggUnit;
+    week: InvalidUnit | AggUnit;
+    year?: AggUnit;
     constructor(second: string | undefined, minute: string, hour: string, day: string, month: string, week: string, year: string | undefined, cron: Cron);
-    parse(text: string): InvalidValue | DigitsValue;
-    setSecond(value: BasicDigits, increment?: number): boolean;
-    setMinute(value: BasicDigits, increment?: number): boolean;
-    setHour(value: BasicDigits, increment?: number): boolean;
+    parse(text: string): InvalidUnit | AggUnit;
+    setSecond(value: BasicValue, increment?: number): boolean;
+    setMinute(value: BasicValue, increment?: number): boolean;
+    setHour(value: BasicValue, increment?: number): boolean;
     setDayInvalid(): void;
     setDay(value: '?'): boolean;
-    setDay(value: DayDigits, increment?: number): boolean;
-    setMonth(value: BasicDigits, increment?: number): boolean;
+    setDay(value: DayValue, increment?: number): boolean;
+    setMonth(value: BasicValue, increment?: number): boolean;
     setWeekInvalid(): void;
     setWeek(value: '?'): boolean;
-    setWeek(value: WeekDigits, increment?: number): boolean;
-    setYear(value: BasicDigits, increment?: number): boolean;
+    setWeek(value: WeekValue, increment?: number): boolean;
+    setYear(value: BasicValue, increment?: number): boolean;
     text(): string;
 }
 export declare class Cron {

package/dist/cron.js

@@ -261,7 +261,7 @@ const createCronRegexText = (options = {}) => {
     enableInvalid
   };
 };
-class InvalidValue {
+class InvalidUnit {
   constructor(isEnableInvalid) {
     this.isEnableInvalid = isEnableInvalid;
   }
@@ -269,32 +269,32 @@ class InvalidValue {
     return this.isEnableInvalid ? "?" : "*";
   }
 }
-const isInvalidValue = (value) => value instanceof InvalidValue;
+const isInvalidUnit = (value) => value instanceof InvalidUnit;
 class LastValue {
   constructor(value) {
     this.value = value;
   }
 }
-class DayLastValue extends LastValue {
+class DayLastUnit extends LastValue {
   text() {
     const { value } = this;
     return "L" + (value ? `-${value}` : "");
   }
 }
-const isDayLastValue = (value) => value instanceof DayLastValue;
-class WeekLastValue extends LastValue {
+const isDayLastUnit = (value) => value instanceof DayLastUnit;
+class WeekLastUnit extends LastValue {
   text() {
     return `${this.value}L`;
   }
 }
-const isWeekLastValue = (value) => value instanceof WeekLastValue;
-class WildcardValue {
+const isWeekLastUnit = (value) => value instanceof WeekLastUnit;
+class WildcardUnit {
   text() {
     return "*";
   }
 }
-const isWildcardValue = (value) => value instanceof WildcardValue;
-class RangeValue {
+const isWildcardUnit = (value) => value instanceof WildcardUnit;
+class RangeUnit {
   constructor(start, stop) {
     this.start = start;
     this.stop = stop;
@@ -303,8 +303,8 @@ class RangeValue {
     return `${this.start}-${this.stop}`;
   }
 }
-const isRangeValue = (value) => value instanceof RangeValue;
-class DigitsValue {
+const isRangeUnit = (value) => value instanceof RangeUnit;
+class AggUnit {
   constructor(values, increment) {
     this.values = values;
     this.increment = increment;
@@ -328,7 +328,7 @@ class DigitsValue {
     return increment ? `${tmp}/${increment}` : tmp;
   }
 }
-const isDigitsValue = (value) => value instanceof DigitsValue;
+const isAggUnit = (value) => value instanceof AggUnit;
 const re_num = /\d/;
 const parseDigit = (text) => {
   if (re_num.test(text[0])) {
@@ -337,22 +337,22 @@ const parseDigit = (text) => {
     return weekDic.item(text.toLocaleUpperCase());
   }
 };
-const parseDigits = (text) => {
+const parseAgg = (text) => {
   return text.split(",").map((text2) => {
     const [a, b] = text2.split("-");
     if (a === "L" && b === void 0) {
-      return new DayLastValue(0);
+      return new DayLastUnit(0);
     } else if (b === void 0) {
       if (a.slice(-1) === "L") {
-        return new WeekLastValue(parseInt(a.slice(0, -1)));
+        return new WeekLastUnit(parseInt(a.slice(0, -1)));
       } else {
         return parseDigit(a);
       }
     } else {
       if (a === "L") {
-        return new DayLastValue(parseInt(b));
+        return new DayLastUnit(parseInt(b));
       } else {
-        return new RangeValue(parseDigit(a), parseDigit(b));
+        return new RangeUnit(parseDigit(a), parseDigit(b));
       }
     }
   });
@@ -370,16 +370,16 @@ const validate = (value, min, max) => {
 const validateIncrement = (value, min, max) => {
   return isInteger(value) && value > 0 && value >= min && value <= max;
 };
-const formaterDigits = (value, min, max) => {
+const formaterAgg = (value, min, max) => {
   let values;
   if (value === "*") {
-    values = new WildcardValue();
+    values = new WildcardUnit();
   } else if (Array.isArray(value)) {
     const tmp = [];
     value.some((data) => {
       if (validate(data, min, max)) {
         tmp.push(
-          isNumber(data) ? data : new RangeValue(data[0], data[1])
+          isNumber(data) ? data : new RangeUnit(data[0], data[1])
         );
         return false;
       } else {
@@ -391,23 +391,23 @@ const formaterDigits = (value, min, max) => {
   }
   return values;
 };
-const formaterLastDigits = (value, min, max, prototype) => {
+const formaterAggByLast = (value, min, max, prototype) => {
   let values;
   if (value === "*") {
-    values = new WildcardValue();
+    values = new WildcardUnit();
   } else {
     const tmp = [];
     const list = Array.isArray(value) ? value : [value];
     list.some((data) => {
       if (isString(data)) {
-        const result = parseDigits(data);
+        const result = parseAgg(data);
         if (result.length === 1 && result[0] instanceof prototype && validate(result[0].value, min, max - 1)) {
           tmp.push(result[0]);
           return false;
         }
       } else if (validate(data, min, max)) {
         tmp.push(
-          isNumber(data) ? data : new RangeValue(data[0], data[1])
+          isNumber(data) ? data : new RangeUnit(data[0], data[1])
         );
         return false;
       }
@@ -439,18 +439,18 @@ class Parse {
   week;
   year;
   parse(text) {
-    if (text === "?") return new InvalidValue(this.cron.isEnableInvalid);
+    if (text === "?") return new InvalidUnit(this.cron.isEnableInvalid);
     const [slices, increment] = text.split("/");
-    return new DigitsValue(
-      slices === "*" ? new WildcardValue() : parseDigits(slices),
+    return new AggUnit(
+      slices === "*" ? new WildcardUnit() : parseAgg(slices),
       increment ? parseInt(increment) : void 0
     );
   }
   setSecond(value, increment) {
     if (!this.cron.isEnableSecond) return false;
-    const values = formaterDigits(value, default_min_second, default_max_second);
+    const values = formaterAgg(value, default_min_second, default_max_second);
     if (!values) return false;
-    const second = new DigitsValue(values);
+    const second = new AggUnit(values);
     if (validateIncrement(increment, default_min_second, default_max_second)) {
       second.increment = increment;
     }
@@ -458,9 +458,9 @@ class Parse {
     return true;
   }
   setMinute(value, increment) {
-    const values = formaterDigits(value, default_min_minute, default_max_minute);
+    const values = formaterAgg(value, default_min_minute, default_max_minute);
     if (!values) return false;
-    const minute = new DigitsValue(values);
+    const minute = new AggUnit(values);
     if (validateIncrement(increment, default_min_minute, default_max_minute)) {
       minute.increment = increment;
     }
@@ -468,9 +468,9 @@ class Parse {
     return true;
   }
   setHour(value, increment) {
-    const values = formaterDigits(value, default_min_hour, default_max_hour);
+    const values = formaterAgg(value, default_min_hour, default_max_hour);
     if (!values) return false;
-    const hour = new DigitsValue(values);
+    const hour = new AggUnit(values);
     if (validateIncrement(increment, default_min_hour, default_max_hour)) {
       hour.increment = increment;
     }
@@ -478,9 +478,9 @@ class Parse {
     return true;
   }
   setDayInvalid() {
-    this.day = new InvalidValue(this.cron.isEnableInvalid);
-    if (this.week instanceof InvalidValue) {
-      this.week = new DigitsValue(new WildcardValue());
+    this.day = new InvalidUnit(this.cron.isEnableInvalid);
+    if (this.week instanceof InvalidUnit) {
+      this.week = new AggUnit(new WildcardUnit());
     }
   }
   setDay(value, increment) {
@@ -489,30 +489,30 @@ class Parse {
       this.setDayInvalid();
       return true;
     } else {
-      const tmp2 = formaterLastDigits(value, default_min_day, default_max_day, DayLastValue);
+      const tmp2 = formaterAggByLast(value, default_min_day, default_max_day, DayLastUnit);
       if (!tmp2) return false;
       values = tmp2;
     }
-    const tmp = new DigitsValue(values);
+    const tmp = new AggUnit(values);
     if (validateIncrement(increment, default_min_day, default_max_day)) {
       tmp.increment = increment;
     }
     this.day = tmp;
     const { week } = this;
-    if (isDigitsValue(week) && (week.increment !== void 0 || !isWildcardValue(week.values))) {
+    if (isAggUnit(week) && (week.increment !== void 0 || !isWildcardUnit(week.values))) {
       if (this.cron.isEnableInvalid) {
-        this.week = new InvalidValue(true);
+        this.week = new InvalidUnit(true);
       } else {
-        week.values = new WildcardValue();
+        week.values = new WildcardUnit();
         week.increment = void 0;
       }
     }
     return true;
   }
   setMonth(value, increment) {
-    const values = formaterDigits(value, default_min_month, default_max_month);
+    const values = formaterAgg(value, default_min_month, default_max_month);
     if (!values) return false;
-    const month = new DigitsValue(values);
+    const month = new AggUnit(values);
     if (validateIncrement(increment, default_min_month, default_max_month)) {
       month.increment = increment;
     }
@@ -520,9 +520,9 @@ class Parse {
     return true;
   }
   setWeekInvalid() {
-    this.week = new InvalidValue(this.cron.isEnableInvalid);
-    if (this.day instanceof InvalidValue) {
-      this.day = new DigitsValue(new WildcardValue());
+    this.week = new InvalidUnit(this.cron.isEnableInvalid);
+    if (this.day instanceof InvalidUnit) {
+      this.day = new AggUnit(new WildcardUnit());
     }
   }
   setWeek(value, increment) {
@@ -531,21 +531,21 @@ class Parse {
       this.setWeekInvalid();
       return true;
     } else {
-      const tmp2 = formaterLastDigits(value, default_min_week, default_max_week, WeekLastValue);
+      const tmp2 = formaterAggByLast(value, default_min_week, default_max_week, WeekLastUnit);
       if (!tmp2) return false;
       values = tmp2;
     }
-    const tmp = new DigitsValue(values);
+    const tmp = new AggUnit(values);
     if (validateIncrement(increment, default_min_week, default_max_week)) {
       tmp.increment = increment;
     }
     this.week = tmp;
     const { day } = this;
-    if (isDigitsValue(day) && (day.increment !== void 0 || !isWildcardValue(day.values))) {
+    if (isAggUnit(day) && (day.increment !== void 0 || !isWildcardUnit(day.values))) {
       if (this.cron.isEnableInvalid) {
-        this.day = new InvalidValue(true);
+        this.day = new InvalidUnit(true);
       } else {
-        day.values = new WildcardValue();
+        day.values = new WildcardUnit();
         day.increment = void 0;
       }
     }
@@ -553,9 +553,9 @@ class Parse {
   }
   setYear(value, increment) {
     if (!this.cron.isEnableYear) return false;
-    const values = formaterDigits(value, 0, MAX_SAFE_INTEGER);
+    const values = formaterAgg(value, 0, MAX_SAFE_INTEGER);
     if (!values) return false;
-    const year = new DigitsValue(values);
+    const year = new AggUnit(values);
     if (validateIncrement(increment, 0, MAX_SAFE_INTEGER)) {
       year.increment = increment;
     }
@@ -644,13 +644,13 @@ class Cron {
   }
 }
 export {
+  AggUnit,
   Cron,
-  DayLastValue,
-  DigitsValue,
-  InvalidValue,
-  RangeValue,
-  WeekLastValue,
-  WildcardValue,
+  DayLastUnit,
+  InvalidUnit,
+  RangeUnit,
+  WeekLastUnit,
+  WildcardUnit,
   createCronRegexText,
   default_max_day,
   default_max_hour,
@@ -664,11 +664,11 @@ export {
   default_min_month,
   default_min_second,
   default_min_week,
-  isDayLastValue,
-  isDigitsValue,
-  isInvalidValue,
-  isRangeValue,
-  isWeekLastValue,
-  isWildcardValue,
+  isAggUnit,
+  isDayLastUnit,
+  isInvalidUnit,
+  isRangeUnit,
+  isWeekLastUnit,
+  isWildcardUnit,
   weekDic
 };

package/dist/dic.d.ts

@@ -0,0 +1,36 @@
+import { IsNever, Revise } from '@vope/types';
+type Key = string | number;
+export interface Dic<V extends Key> {
+    label: string;
+    value: V;
+}
+type CustomLabel<T, M extends string> = ((data: T) => string) | Record<M, (data: T) => string>;
+interface Options<K extends Key, T extends Dic<K>, M extends string> {
+    defaultValue?: K;
+    customLabel?: CustomLabel<T, M>;
+}
+/**
+ * 字典操作
+ */
+declare class DicRollup<K extends Key, T extends Dic<K> = Dic<K>, Mode extends string = never> {
+    #private;
+    protected readonly memory: Record<K, T>;
+    constructor(list: T[], { defaultValue, customLabel, }?: Options<K, T, Mode>);
+    get size(): number;
+    get default(): K | undefined;
+    get list(): T[];
+    includes(key: Key): key is K;
+    label(key: K, mode?: Mode): string | undefined;
+    get<P extends keyof T>(key: K, property: P): Record<K, T>[K][P];
+    item(key: K): Readonly<T>;
+    map<V>(callback: (data: Readonly<T>, index: number) => V): V[];
+    reduce<V>(callback: (previousValue: V, currentValue: T, currentIndex: number) => V, initialValue: V): V;
+    copy<P extends K, M extends string = never>(keys: P[], options?: Options<P, Readonly<Revise<T, 'value', P>>, M>): DicRollup<P, Revise<T, "value", P>, IsNever<M> extends true ? Mode : M>;
+    copyAnti<P extends K, M extends string = never>(keys: P[], options?: Options<Exclude<K, P>, Readonly<Revise<T, 'value', Exclude<K, P>>>, M>): DicRollup<Exclude<K, P>, Revise<T, "value", Exclude<K, P>>, IsNever<M> extends true ? Mode : M>;
+}
+declare namespace DicRollup {
+    type Type<T extends DicRollup<any, any, string>> = T extends DicRollup<infer K, any, string> ? K : never;
+    type Dic<T extends DicRollup<any, any, string>> = T extends DicRollup<any, infer V, string> ? V : never;
+    type Mode<T extends DicRollup<any, any, string>> = T extends DicRollup<any, any, infer M> ? M : never;
+}
+export default DicRollup;

package/dist/dic.js

@@ -0,0 +1,95 @@
+import { isFunction } from "lodash-es";
+import { hash8json } from "./convert/json";
+import { hash8strings } from "./convert/strings";
+class DicRollup {
+  #list;
+  #default;
+  #customLabel;
+  memory;
+  constructor(list, {
+    defaultValue,
+    customLabel
+  } = {}) {
+    this.#list = list;
+    this.#default = defaultValue;
+    this.#customLabel = customLabel;
+    const getter = () => hash8json(list, "value");
+    Object.defineProperty(this, "memory", {
+      get() {
+        return getter();
+      }
+    });
+  }
+  get size() {
+    return this.#list.length;
+  }
+  get default() {
+    return this.#default;
+  }
+  get list() {
+    return this.#list;
+  }
+  includes(key) {
+    return key in this.memory;
+  }
+  label(key, mode) {
+    const data = this.memory[key];
+    if (!data) return;
+    const custom = this.#customLabel;
+    if (!custom) return data.label;
+    if (!mode && isFunction(custom)) {
+      return custom(data);
+    } else if (mode) {
+      const tmp = custom[mode];
+      return tmp ? tmp(data) : data.label;
+    } else {
+      return data.label;
+    }
+  }
+  get(key, property) {
+    return this.memory[key]?.[property];
+  }
+  item(key) {
+    return this.memory[key];
+  }
+  map(callback) {
+    return this.#list.map(callback);
+  }
+  reduce(callback, initialValue) {
+    return this.#list.reduce(callback, initialValue);
+  }
+  copy(keys, options) {
+    const tmp = hash8strings(keys);
+    const opts = Object.assign({
+      defaultValue: this.#default,
+      customLabel: this.#customLabel
+    }, options);
+    const { defaultValue } = opts;
+    if (defaultValue !== void 0 && defaultValue in tmp === false) {
+      opts.defaultValue = void 0;
+    }
+    return new DicRollup(
+      this.#list.filter((data) => data.value in tmp),
+      opts
+    );
+  }
+  copyAnti(keys, options) {
+    const tmp = hash8strings(keys);
+    const opts = Object.assign({
+      defaultValue: this.#default,
+      customLabel: this.#customLabel
+    }, options);
+    const { defaultValue } = opts;
+    if (defaultValue !== void 0 && defaultValue in tmp) {
+      opts.defaultValue = void 0;
+    }
+    return new DicRollup(
+      this.#list.filter((data) => data.value in tmp === false),
+      opts
+    );
+  }
+}
+var dic_default = DicRollup;
+export {
+  dic_default as default
+};