ngx-tethys 19.1.13 → 20.0.0-next.0

package/util/index.d.ts

@@ -1,14 +1,595 @@
-export * from './date/functions';
-export * from './date/tiny-date';
-export * from './dom';
-export * from './helpers/index';
-export { produce } from './immutable';
-import * as dom from './dom';
-import * as helpers from './helpers/index';
-import * as references from './references';
-export { EntityAddOptions as EntityAddOptions$0, EntityMoveOptions, Producer, ProducerOptions } from './immutable';
-export * from './ng';
-export * from './references';
-export * from './keycodes';
-export * from './logger/index';
-export { dom, helpers, references };
+import * as dateFns from 'date-fns';
+import { Locale, FirstWeekContainsDate } from 'date-fns';
+import { ElementRef, TemplateRef, SimpleChanges } from '@angular/core';
+import { Id } from 'ngx-tethys/types';
+export * from '@angular/cdk/keycodes';
+import * as keycodes from '@angular/cdk/keycodes';
+export { keycodes };
+
+declare const differenceInCalendarDays: typeof dateFns.differenceInCalendarDays;
+declare const differenceInCalendarMonths: typeof dateFns.differenceInCalendarMonths;
+declare const differenceInCalendarYears: typeof dateFns.differenceInCalendarYears;
+declare const differenceInCalendarQuarters: typeof dateFns.differenceInCalendarQuarters;
+declare const differenceInWeeks: typeof dateFns.differenceInWeeks;
+declare const differenceInHours: typeof dateFns.differenceInHours;
+declare const differenceInMinutes: typeof dateFns.differenceInMinutes;
+declare const differenceInSeconds: typeof dateFns.differenceInSeconds;
+declare const differenceInDays: typeof dateFns.differenceInDays;
+declare const differenceInMonths: typeof dateFns.differenceInMonths;
+declare const differenceInYears: typeof dateFns.differenceInYears;
+declare const isSameDay: typeof dateFns.isSameDay;
+declare const isSameHour: typeof dateFns.isSameHour;
+declare const isSameMinute: typeof dateFns.isSameMinute;
+declare const isSameMonth: typeof dateFns.isSameMonth;
+declare const isSameSecond: typeof dateFns.isSameSecond;
+declare const isSameYear: typeof dateFns.isSameYear;
+declare const isSameQuarter: typeof dateFns.isSameQuarter;
+declare const isToday: typeof dateFns.isToday;
+declare const isTomorrow: typeof dateFns.isTomorrow;
+declare const isValid: typeof dateFns.isValid;
+declare const isAfter: typeof dateFns.isAfter;
+declare const setYear: typeof dateFns.setYear;
+declare const startOfMonth: typeof dateFns.startOfMonth;
+declare const startOfWeek: typeof dateFns.startOfWeek;
+declare const addMonths: typeof dateFns.addMonths;
+declare const addYears: typeof dateFns.addYears;
+declare const setDay: typeof dateFns.setDay;
+declare const setDate: typeof dateFns.setDate;
+declare const setMonth: typeof dateFns.setMonth;
+declare const setQuarter: typeof dateFns.setQuarter;
+declare const getUnixTime: typeof dateFns.getUnixTime;
+declare const startOfDay: typeof dateFns.startOfDay;
+declare const endOfDay: typeof dateFns.endOfDay;
+declare const fromUnixTime: typeof dateFns.fromUnixTime;
+declare const isWeekend: typeof dateFns.isWeekend;
+declare const getTime: typeof dateFns.getTime;
+declare const getDay: typeof dateFns.getDay;
+declare const getWeek: typeof dateFns.getWeek;
+declare const getMonth: typeof dateFns.getMonth;
+declare const getYear: typeof dateFns.getYear;
+declare const getDate: typeof dateFns.getDate;
+declare const getHours: typeof dateFns.getHours;
+declare const getMinutes: typeof dateFns.getMinutes;
+declare const getSeconds: typeof dateFns.getSeconds;
+declare const getDaysInMonth: typeof dateFns.getDaysInMonth;
+declare const addSeconds: typeof dateFns.addSeconds;
+declare const addMinutes: typeof dateFns.addMinutes;
+declare const addHours: typeof dateFns.addHours;
+declare const addWeeks: typeof dateFns.addWeeks;
+declare const addQuarters: typeof dateFns.addQuarters;
+declare const startOfQuarter: typeof dateFns.startOfQuarter;
+declare const startOfYear: typeof dateFns.startOfYear;
+declare const startOfMinute: typeof dateFns.startOfMinute;
+declare const startOfHour: typeof dateFns.startOfHour;
+declare const startOfISOWeek: typeof dateFns.startOfISOWeek;
+declare const endOfMinute: typeof dateFns.endOfMinute;
+declare const endOfHour: typeof dateFns.endOfHour;
+declare const endOfWeek: typeof dateFns.endOfWeek;
+declare const endOfMonth: typeof dateFns.endOfMonth;
+declare const endOfQuarter: typeof dateFns.endOfQuarter;
+declare const endOfYear: typeof dateFns.endOfYear;
+declare const endOfISOWeek: typeof dateFns.endOfISOWeek;
+declare const format: typeof dateFns.format;
+declare const getQuarter: typeof dateFns.getQuarter;
+declare const addDays: typeof dateFns.addDays;
+declare const subMilliseconds: typeof dateFns.subMilliseconds;
+declare const subSeconds: typeof dateFns.subSeconds;
+declare const subMinutes: typeof dateFns.subMinutes;
+declare const subHours: typeof dateFns.subHours;
+declare const subDays: typeof dateFns.subDays;
+declare const subBusinessDays: typeof dateFns.subBusinessDays;
+declare const subWeeks: typeof dateFns.subWeeks;
+declare const subMonths: typeof dateFns.subMonths;
+declare const subQuarters: typeof dateFns.subQuarters;
+declare const subYears: typeof dateFns.subYears;
+declare const eachDayOfInterval: typeof dateFns.eachDayOfInterval;
+declare const eachWeekOfInterval: typeof dateFns.eachWeekOfInterval;
+declare const eachMonthOfInterval: typeof dateFns.eachMonthOfInterval;
+declare const eachYearOfInterval: typeof dateFns.eachYearOfInterval;
+declare const eachHourOfInterval: typeof dateFns.eachHourOfInterval;
+declare const setDefaultOptions: typeof dateFns.setDefaultOptions;
+declare const formatDistance: typeof dateFns.formatDistance;
+declare const getDateFnsLocale: (locale: string) => dateFns.Locale;
+
+type TinyDateCompareGrain = 'decade' | 'year' | 'quarter' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second';
+type WeekDayIndex = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+type TinyDateType = TinyDate | Date | null;
+declare function sortRangeValue(rangeValue: TinyDate[]): TinyDate[];
+declare const DEFAULT_TIMEZONE = "Asia/Shanghai";
+declare class TinyDate implements Record<string, any> {
+    nativeDate: Date;
+    private useTimeZone;
+    private static locale;
+    protected static dateFnsLocale: Locale;
+    protected static defaultTimeZone: string;
+    constructor(date?: Date | string | number, zone?: string);
+    static setDefaultLocale(locale: string): void;
+    static getDefaultLocale(): {
+        locale: string;
+        dateFnsLocale: Locale;
+    };
+    static setDefaultTimeZone(zone: string): void;
+    static getDefaultTimeZone(): string;
+    static utcToZonedTime(value: Date | number, timeZone?: string): Date;
+    static createDateInTimeZone(year: number, month: number, day: number, hours: number, minutes: number, seconds: number, timeZone?: string): Date;
+    static fromUnixTime(unixTime: number, timeZone?: string): TinyDate;
+    getTime(): number;
+    getDate(): number;
+    getYear(): number;
+    getQuarter(): number;
+    getMonth(): number;
+    getFullYear(): number;
+    getWeek(options?: {
+        locale?: Locale;
+        weekStartsOn?: WeekDayIndex;
+    }): number;
+    getDay(): number;
+    getHours(): number;
+    getMinutes(): number;
+    getSeconds(): number;
+    getMilliseconds(): number;
+    getDaysInMonth(): number;
+    getDaysInQuarter(): number;
+    setDate(amount: number): TinyDate;
+    setHms(hour: number, minute: number, second: number): TinyDate;
+    setYear(year: number): TinyDate;
+    setMonth(month: number): TinyDate;
+    setQuarter(quarter: number): TinyDate;
+    setDay(day: number, options?: {
+        weekStartsOn: WeekDayIndex;
+    }): TinyDate;
+    setHours(hours: number): TinyDate;
+    setMinutes(minutes: number): TinyDate;
+    setSeconds(seconds: number): TinyDate;
+    addYears(amount: number): TinyDate;
+    addQuarters(amount: number): TinyDate;
+    addMonths(amount: number): TinyDate;
+    addWeeks(amount: number): TinyDate;
+    addDays(amount: number): TinyDate;
+    addHours(amount: number): TinyDate;
+    addSeconds(amount: number): TinyDate;
+    addMinutes(amount: number): TinyDate;
+    isSame(date: TinyDateType, grain?: TinyDateCompareGrain): boolean;
+    isSameYear(date: TinyDateType): boolean;
+    isSameMonth(date: TinyDateType): boolean;
+    isSameQuarter(date: TinyDateType): boolean;
+    isSameDay(date: TinyDateType): boolean;
+    isSameHour(date: TinyDateType): boolean;
+    isSameMinute(date: TinyDateType): boolean;
+    isSameSecond(date: TinyDateType): boolean;
+    isBeforeYear(date: TinyDateType): boolean;
+    isBeforeQuarter(date: TinyDate): boolean;
+    isBeforeMonth(date: TinyDateType): boolean;
+    isBeforeWeek(date: TinyDateType): boolean;
+    isBeforeDay(date: TinyDateType): boolean;
+    isBeforeHour(date: TinyDateType): boolean;
+    isBeforeMinute(date: TinyDateType): boolean;
+    isBeforeSecond(date: TinyDateType): boolean;
+    isAfterYear(date: TinyDateType): boolean;
+    isAfterQuarter(date: TinyDate): boolean;
+    isAfterMonth(date: TinyDateType): boolean;
+    isAfterWeek(date: TinyDateType): boolean;
+    isAfterDay(date: TinyDateType): boolean;
+    isAfterHour(date: TinyDateType): boolean;
+    isAfterMinute(date: TinyDateType): boolean;
+    isAfterSecond(date: TinyDateType): boolean;
+    isWeekend(): boolean;
+    isToday(): boolean;
+    isTomorrow(): boolean;
+    isValid(): boolean;
+    startOfYear(): TinyDate;
+    startOfQuarter(): TinyDate;
+    startOfMonth(): TinyDate;
+    startOfWeek(options?: {
+        locale?: Locale;
+        weekStartsOn?: WeekDayIndex;
+    }): TinyDate;
+    startOfDay(): TinyDate;
+    endOfYear(): TinyDate;
+    endOfQuarter(): TinyDate;
+    endOfMonth(): TinyDate;
+    endOfWeek(options?: {
+        locale?: Locale;
+        weekStartsOn?: WeekDayIndex;
+    }): TinyDate;
+    endOfDay(): TinyDate;
+    format(mat: string, options?: {
+        locale?: Locale;
+        weekStartsOn?: WeekDayIndex;
+        firstWeekContainsDate?: FirstWeekContainsDate;
+        useAdditionalWeekYearTokens?: boolean;
+        useAdditionalDayOfYearTokens?: boolean;
+    }): string;
+    calendarStart(options?: {
+        weekStartsOn: WeekDayIndex | undefined;
+    }): TinyDate;
+    clone(): TinyDate;
+    getUnixTime(): number;
+    compare(date: TinyDateType, grain?: TinyDateCompareGrain, isBefore?: boolean): boolean;
+    private toNativeDate;
+    startOfISOWeek(): TinyDate;
+    endOfISOWeek(): TinyDate;
+    differenceInDays(date: Date): number;
+    differenceInHours(date: Date): number;
+    subWeeks(amount: number): TinyDate;
+    subDays(amount: number): TinyDate;
+}
+
+declare function fallbackMatches(el: Element | Node, selector: string): boolean;
+/**
+ * Match `el` to `selector`.
+ */
+declare function match(el: Element | Node, selector: string): any;
+declare function isDocument(element: any): element is Document;
+declare function isElement(element: any): boolean;
+declare function getWindow(elem: any): any;
+declare function getElementOffset(elem: HTMLElement): any;
+declare function getOffset(element: HTMLElement, container: HTMLElement | Window): {
+    left: number;
+    top: number;
+} | null;
+declare function getClientSize(): {
+    width: number;
+    height: number;
+};
+type ElementSelector = HTMLElement | ElementRef | string;
+declare function getHTMLElementBySelector(selector: ElementSelector, defaultElementRef: ElementRef): HTMLElement;
+declare function isInputOrTextarea(element: HTMLElement): boolean;
+declare function isWindow(container: Element | Window): container is Window;
+interface SimpleRect {
+    top: number;
+    left: number;
+    width?: number;
+    height?: number;
+    bottom?: number;
+}
+declare function getContainerRect(container: Element | Window): SimpleRect;
+declare function getStyleAsText(styles?: any): string;
+declare function isTouchEvent(event: MouseEvent | TouchEvent): event is TouchEvent;
+/**
+ * Assert wrapper element whether only contains icon.
+ */
+declare function assertIconOnly(wrapperElement: Element): boolean;
+/**
+ *
+ * calc position x,y point
+ *
+ * CASE (width <= clientWidth && height <= clientHeight):
+ *
+ * ------------- clientWidth -------------
+ * |                                     |
+ * |        ------ width ------          |
+ * |        |                 |          |
+ * |        |                 |          |
+ * client   height            |          |
+ * Height   |                 |          |
+ * |        |                 |          |
+ * |        -------------------          |
+ * |                                     |
+ * |                                     |
+ * ---------------------------------------
+ * fixedPosition = { x: 0, y: 0 }
+ *
+ *
+ *
+ * CASE (width > clientWidth || height > clientHeight):
+ *
+ * ------------- clientWidth -------------
+ * |        |                            |
+ * |        top                          |
+ * |        |                            |
+ * |--left--|--------------- width -----------------
+ * |        |                                      |
+ * client   |                                      |
+ * Height   |                                      |
+ * |        |                                      |
+ * |        |                                      |
+ * |        height                                 |
+ * |        |                                      |
+ * ---------|                                      |
+ *          |                                      |
+ *          |                                      |
+ *          |                                      |
+ *          ----------------------------------------
+ *
+ *
+ * - left || top > 0
+ *   left -> 0 || top -> 0
+ *
+ * - (left + width) < clientWidth || (top + height) < clientHeight
+ * - left | top + width | height < clientWidth | clientHeight -> Back left | top + width | height === clientWidth | clientHeight
+ *
+ * DEFAULT:
+ * - hold position
+ *
+ */
+declare function getFitContentPosition(params: {
+    width: number;
+    height: number;
+    left: number;
+    top: number;
+    clientWidth: number;
+    clientHeight: number;
+}): {
+    x?: number;
+    y?: number;
+};
+declare function elementMatchClosest(element: HTMLElement, selectors: string | string[]): boolean;
+
+type dom_d_ElementSelector = ElementSelector;
+type dom_d_SimpleRect = SimpleRect;
+declare const dom_d_assertIconOnly: typeof assertIconOnly;
+declare const dom_d_elementMatchClosest: typeof elementMatchClosest;
+declare const dom_d_fallbackMatches: typeof fallbackMatches;
+declare const dom_d_getClientSize: typeof getClientSize;
+declare const dom_d_getContainerRect: typeof getContainerRect;
+declare const dom_d_getElementOffset: typeof getElementOffset;
+declare const dom_d_getFitContentPosition: typeof getFitContentPosition;
+declare const dom_d_getHTMLElementBySelector: typeof getHTMLElementBySelector;
+declare const dom_d_getOffset: typeof getOffset;
+declare const dom_d_getStyleAsText: typeof getStyleAsText;
+declare const dom_d_getWindow: typeof getWindow;
+declare const dom_d_isDocument: typeof isDocument;
+declare const dom_d_isElement: typeof isElement;
+declare const dom_d_isInputOrTextarea: typeof isInputOrTextarea;
+declare const dom_d_isTouchEvent: typeof isTouchEvent;
+declare const dom_d_isWindow: typeof isWindow;
+declare const dom_d_match: typeof match;
+declare namespace dom_d {
+  export { dom_d_assertIconOnly as assertIconOnly, dom_d_elementMatchClosest as elementMatchClosest, dom_d_fallbackMatches as fallbackMatches, dom_d_getClientSize as getClientSize, dom_d_getContainerRect as getContainerRect, dom_d_getElementOffset as getElementOffset, dom_d_getFitContentPosition as getFitContentPosition, dom_d_getHTMLElementBySelector as getHTMLElementBySelector, dom_d_getOffset as getOffset, dom_d_getStyleAsText as getStyleAsText, dom_d_getWindow as getWindow, dom_d_isDocument as isDocument, dom_d_isElement as isElement, dom_d_isInputOrTextarea as isInputOrTextarea, dom_d_isTouchEvent as isTouchEvent, dom_d_isWindow as isWindow, dom_d_match as match };
+  export type { dom_d_ElementSelector as ElementSelector, dom_d_SimpleRect as SimpleRect };
+}
+
+type ThyBooleanInput = boolean | string | number | unknown;
+declare function isUndefined(value: any): value is undefined;
+declare function isNull(value: any): value is null;
+declare function isUndefinedOrNull(value: any): value is undefined | null;
+declare function isArray<T = any>(value: any): value is Array<T>;
+declare function isEmpty(value?: any): boolean;
+declare function isString(value?: any): value is string;
+declare function isNumber(value: any): value is number;
+declare function isObject(value: any): value is object;
+declare function isFunction(value: any): value is Function;
+declare function isDate(value: any): value is Date;
+declare function coerceArray<T>(value: T | T[]): T[];
+declare function get(object: any, path: string, defaultValue?: any): any;
+declare function set(object: any, path: string, value: any): void;
+declare function isBoolean(value: any): value is boolean;
+declare function isClass(value: any): value is Function;
+declare function htmlElementIsEmpty(element: HTMLElement): boolean;
+declare function hexToRgb(hexValue: string, alpha?: number): string;
+declare function dateToUnixTimestamp(date: Date | number): number;
+declare function clamp(value: number, min?: number, max?: number): number;
+declare function keyBy<T>(array: T[], key: T extends object ? keyof T : never): {
+    [key: string]: T;
+};
+declare function indexKeyBy<T>(array: T[], key: T extends object ? keyof T : never): {
+    [key: string]: number;
+};
+declare function camelCase(values: string[]): string;
+declare function generateRandomStr(): string;
+declare function isTemplateRef<C = any>(value: any): value is TemplateRef<C>;
+declare function isHTMLElement(value: any): value is HTMLElement;
+declare function isElementRef(value: any): value is ElementRef;
+/**
+ * fix angular cdk's coerceBooleanProperty will transform 0 to true
+ */
+declare function coerceBooleanProperty(value: ThyBooleanInput): boolean;
+type FunctionProp<T> = (...args: any[]) => T;
+/**
+ * @deprecated Please use Angular cdk's coerceNumberProperty instead
+ */
+declare function coerceNumberValue(value: number | string): number;
+/**
+ * @deprecated Please use Angular cdk's coerceNumberProperty instead
+ */
+declare function coerceNumberValue<D>(value: number | string, fallback: D): number | D;
+/**
+ * @deprecated Please use Angular cdk's coerceCssPixelValue instead
+ */
+declare function coerceCssPixelValue(value: number | string): string;
+declare function valueFunctionProp<T>(prop: FunctionProp<T>, ...args: any[]): T;
+declare function shallowEqual(objA?: Record<string, any>, objB?: Record<string, any>): boolean;
+declare function concatArray<TItem>(items: TItem | TItem[], originalItems?: TItem | TItem[]): TItem[];
+declare function humanizeBytes(bytes: number, noSpace?: boolean, fractionDigits?: number): string;
+declare function isFloat(value: string): boolean;
+declare function hasTimeInStringDate(dateString: string): boolean;
+
+type index_d_FunctionProp<T> = FunctionProp<T>;
+type index_d_ThyBooleanInput = ThyBooleanInput;
+declare const index_d_camelCase: typeof camelCase;
+declare const index_d_clamp: typeof clamp;
+declare const index_d_coerceArray: typeof coerceArray;
+declare const index_d_coerceBooleanProperty: typeof coerceBooleanProperty;
+declare const index_d_coerceCssPixelValue: typeof coerceCssPixelValue;
+declare const index_d_coerceNumberValue: typeof coerceNumberValue;
+declare const index_d_concatArray: typeof concatArray;
+declare const index_d_dateToUnixTimestamp: typeof dateToUnixTimestamp;
+declare const index_d_generateRandomStr: typeof generateRandomStr;
+declare const index_d_get: typeof get;
+declare const index_d_hasTimeInStringDate: typeof hasTimeInStringDate;
+declare const index_d_hexToRgb: typeof hexToRgb;
+declare const index_d_htmlElementIsEmpty: typeof htmlElementIsEmpty;
+declare const index_d_humanizeBytes: typeof humanizeBytes;
+declare const index_d_indexKeyBy: typeof indexKeyBy;
+declare const index_d_isArray: typeof isArray;
+declare const index_d_isBoolean: typeof isBoolean;
+declare const index_d_isClass: typeof isClass;
+declare const index_d_isDate: typeof isDate;
+declare const index_d_isElementRef: typeof isElementRef;
+declare const index_d_isEmpty: typeof isEmpty;
+declare const index_d_isFloat: typeof isFloat;
+declare const index_d_isFunction: typeof isFunction;
+declare const index_d_isHTMLElement: typeof isHTMLElement;
+declare const index_d_isNull: typeof isNull;
+declare const index_d_isNumber: typeof isNumber;
+declare const index_d_isObject: typeof isObject;
+declare const index_d_isString: typeof isString;
+declare const index_d_isTemplateRef: typeof isTemplateRef;
+declare const index_d_isUndefined: typeof isUndefined;
+declare const index_d_isUndefinedOrNull: typeof isUndefinedOrNull;
+declare const index_d_keyBy: typeof keyBy;
+declare const index_d_set: typeof set;
+declare const index_d_shallowEqual: typeof shallowEqual;
+declare const index_d_valueFunctionProp: typeof valueFunctionProp;
+declare namespace index_d {
+  export { index_d_camelCase as camelCase, index_d_clamp as clamp, index_d_coerceArray as coerceArray, index_d_coerceBooleanProperty as coerceBooleanProperty, index_d_coerceCssPixelValue as coerceCssPixelValue, index_d_coerceNumberValue as coerceNumberValue, index_d_concatArray as concatArray, index_d_dateToUnixTimestamp as dateToUnixTimestamp, index_d_generateRandomStr as generateRandomStr, index_d_get as get, index_d_hasTimeInStringDate as hasTimeInStringDate, index_d_hexToRgb as hexToRgb, index_d_htmlElementIsEmpty as htmlElementIsEmpty, index_d_humanizeBytes as humanizeBytes, index_d_indexKeyBy as indexKeyBy, index_d_isArray as isArray, index_d_isBoolean as isBoolean, index_d_isClass as isClass, index_d_isDate as isDate, index_d_isElementRef as isElementRef, index_d_isEmpty as isEmpty, index_d_isFloat as isFloat, index_d_isFunction as isFunction, index_d_isHTMLElement as isHTMLElement, index_d_isNull as isNull, index_d_isNumber as isNumber, index_d_isObject as isObject, index_d_isString as isString, index_d_isTemplateRef as isTemplateRef, index_d_isUndefined as isUndefined, index_d_isUndefinedOrNull as isUndefinedOrNull, index_d_keyBy as keyBy, index_d_set as set, index_d_shallowEqual as shallowEqual, index_d_valueFunctionProp as valueFunctionProp };
+  export type { index_d_FunctionProp as FunctionProp, index_d_ThyBooleanInput as ThyBooleanInput };
+}
+
+interface EntityAddOptions {
+    prepend?: boolean;
+    afterId?: Id;
+}
+interface EntityMoveOptions {
+    afterId?: Id;
+    toIndex?: number;
+}
+interface ProducerOptions {
+    idKey?: string;
+}
+declare class Producer<TEntity> {
+    private idKey;
+    private entities;
+    constructor(entities: TEntity[], options?: ProducerOptions);
+    /**
+     * Add an entity or entities.
+     *
+     * @example
+     * produce([users]).add(Entity);
+     * produce([users]).add([Entity, Entity]);
+     * produce([users]).add(Entity, { prepend: true });
+     * produce([users]).add(Entity, { afterId: '' });
+     */
+    add(entity: TEntity | TEntity[], addOptions?: EntityAddOptions): TEntity[];
+    /**
+     *
+     * Update an entity or entities.
+     *
+     * @example
+     * produce([users]).update(3, {
+     *   name: 'New Name'
+     * });
+     *
+     * produce([users]).update(3, entity => {
+     *    return {
+     *      ...entity,
+     *      name: 'New Name'
+     *    }
+     *  });
+     *
+     * produce([users]).update([1,2,3], {
+     *   name: 'New Name'
+     * });
+     */
+    update(id: Id | Id[] | null, newStateFn: (entity: Readonly<TEntity>) => Partial<TEntity>): TEntity[];
+    update(id: Id | Id[] | null, newState?: Partial<TEntity>): TEntity[];
+    /**
+     *
+     * Remove one or more entities:
+     *
+     * @example
+     * produce([users]).remove(5);
+     * produce([users]).remove([1,2,3]);
+     * produce([users]).remove(entity => entity.id === 1);
+     */
+    remove(id: Id | Id[]): TEntity[];
+    remove(predicate: (entity: Readonly<TEntity>) => boolean): TEntity[];
+    /**
+     *
+     * Move one or more entities:
+     *
+     * @example
+     * produce([users]).move(5, {afterId: 2});
+     * produce([users]).move(5, {toIndex: 0});
+     */
+    move(id: Id, moveOptions?: EntityMoveOptions): TEntity[];
+}
+declare function produce<TEntity>(entities: TEntity[], options?: ProducerOptions): Producer<TEntity>;
+
+type ArrayInferExtract<T> = T extends Array<infer P> ? P : T;
+type ArrayAlwaysExtract<T> = T extends Array<infer P> ? P : never;
+type ReferenceObjectExtract<T> = {
+    [key in keyof T]: ArrayInferExtract<T[key]> extends object ? ArrayInferExtract<T[key]> : never;
+};
+type ReferenceExtractNames<T> = {
+    [key in keyof T]: ArrayInferExtract<T[key]> extends object ? key : never;
+};
+type ReferenceArrayExtractNames<T> = {
+    [key in keyof T]: T[key] extends Array<object> ? key : never;
+};
+type ReferenceExtractAllowNames<T> = {
+    [key in ReferenceExtractNames<T>[keyof T]]: ReferenceExtractNames<T>[key];
+};
+type ReferenceArrayExtractAllowNames<T> = {
+    [key in ReferenceArrayExtractNames<T>[keyof T]]: ReferenceExtractNames<T>[key];
+};
+/**
+ * 根据 ReferenceExtractAllowKeys 抽取出的 Object Keys 组合新的对象
+ * @example ReferenceExtractAllowKeys<{
+    users: { uid: string; name: string }[];
+    info: { id: number; name: string };
+    departments: { dept: number }[];
+    ids: string[];
+    id: string;
+  }> => {
+      users: "uid" | "name",
+      info: "id" | "name",
+      departments: "dept"
+
+  }
+ */
+type ReferenceExtractAllowKeys<T> = {
+    [key in keyof ReferenceExtractAllowNames<T>]?: keyof ReferenceObjectExtract<T>[key];
+};
+type ReferenceArrayExtractAllowKeys<T> = {
+    [key in keyof ReferenceArrayExtractAllowNames<T>]?: keyof ReferenceObjectExtract<T>[key];
+};
+/**
+ * Append references to original references
+ * @example
+ * mergeReferences({departments: [{ _id: '1', name: 'name-1'}]}, {departments: [{ _id: '3', name: 'name-3'}]})
+ * mergeReferences({users: [{ uid: '1', name: 'name-1'}]}, {users: [{ uid: '3', name: 'name-3'}]}, { users: "uid" })
+ * @param originalReferences original references
+ * @param references append references
+ * @param idKeys references 's id key, default is '_id'
+ *
+ * @returns TReferences
+ */
+declare function mergeReferences<TReferences>(originalReferences: TReferences, references: Partial<TReferences>, idKeys?: ReferenceArrayExtractAllowKeys<TReferences>): TReferences;
+/**
+ * Build dictionary for references
+ * @param references references
+ * @param idKeys references 's id key, default is '_id'
+ */
+declare function buildReferencesKeyBy<TReferences>(references: Partial<TReferences>, idKeys?: Partial<ReferenceArrayExtractAllowKeys<TReferences>>): { [key in keyof TReferences]?: {
+    [key: string]: ArrayInferExtract<TReferences[key]>;
+}; };
+
+type references_d_ArrayAlwaysExtract<T> = ArrayAlwaysExtract<T>;
+type references_d_ArrayInferExtract<T> = ArrayInferExtract<T>;
+type references_d_ReferenceArrayExtractAllowKeys<T> = ReferenceArrayExtractAllowKeys<T>;
+type references_d_ReferenceArrayExtractAllowNames<T> = ReferenceArrayExtractAllowNames<T>;
+type references_d_ReferenceArrayExtractNames<T> = ReferenceArrayExtractNames<T>;
+type references_d_ReferenceExtractAllowKeys<T> = ReferenceExtractAllowKeys<T>;
+type references_d_ReferenceExtractAllowNames<T> = ReferenceExtractAllowNames<T>;
+type references_d_ReferenceExtractNames<T> = ReferenceExtractNames<T>;
+type references_d_ReferenceObjectExtract<T> = ReferenceObjectExtract<T>;
+declare const references_d_buildReferencesKeyBy: typeof buildReferencesKeyBy;
+declare const references_d_mergeReferences: typeof mergeReferences;
+declare namespace references_d {
+  export { references_d_buildReferencesKeyBy as buildReferencesKeyBy, references_d_mergeReferences as mergeReferences };
+  export type { references_d_ArrayAlwaysExtract as ArrayAlwaysExtract, references_d_ArrayInferExtract as ArrayInferExtract, references_d_ReferenceArrayExtractAllowKeys as ReferenceArrayExtractAllowKeys, references_d_ReferenceArrayExtractAllowNames as ReferenceArrayExtractAllowNames, references_d_ReferenceArrayExtractNames as ReferenceArrayExtractNames, references_d_ReferenceExtractAllowKeys as ReferenceExtractAllowKeys, references_d_ReferenceExtractAllowNames as ReferenceExtractAllowNames, references_d_ReferenceExtractNames as ReferenceExtractNames, references_d_ReferenceObjectExtract as ReferenceObjectExtract };
+}
+
+declare function hasLaterChange(changes: SimpleChanges): boolean;
+
+declare const PREFIX = "[NGX-TETHYS]:";
+declare const warn: (...args: any[]) => void;
+declare function createWarnDeprecation(prefix: string): (...args: any[]) => void;
+declare const warnDeprecation: (...args: any[]) => void;
+declare const log: (...args: any[]) => void;
+declare function setWarnDeprecation(enabled: boolean): void;
+
+export { DEFAULT_TIMEZONE, PREFIX, Producer, TinyDate, addDays, addHours, addMinutes, addMonths, addQuarters, addSeconds, addWeeks, addYears, assertIconOnly, buildReferencesKeyBy, camelCase, clamp, coerceArray, coerceBooleanProperty, coerceCssPixelValue, coerceNumberValue, concatArray, createWarnDeprecation, dateToUnixTimestamp, differenceInCalendarDays, differenceInCalendarMonths, differenceInCalendarQuarters, differenceInCalendarYears, differenceInDays, differenceInHours, differenceInMinutes, differenceInMonths, differenceInSeconds, differenceInWeeks, differenceInYears, dom_d as dom, eachDayOfInterval, eachHourOfInterval, eachMonthOfInterval, eachWeekOfInterval, eachYearOfInterval, elementMatchClosest, endOfDay, endOfHour, endOfISOWeek, endOfMinute, endOfMonth, endOfQuarter, endOfWeek, endOfYear, fallbackMatches, format, formatDistance, fromUnixTime, generateRandomStr, get, getClientSize, getContainerRect, getDate, getDateFnsLocale, getDay, getDaysInMonth, getElementOffset, getFitContentPosition, getHTMLElementBySelector, getHours, getMinutes, getMonth, getOffset, getQuarter, getSeconds, getStyleAsText, getTime, getUnixTime, getWeek, getWindow, getYear, hasLaterChange, hasTimeInStringDate, index_d as helpers, hexToRgb, htmlElementIsEmpty, humanizeBytes, indexKeyBy, isAfter, isArray, isBoolean, isClass, isDate, isDocument, isElement, isElementRef, isEmpty, isFloat, isFunction, isHTMLElement, isInputOrTextarea, isNull, isNumber, isObject, isSameDay, isSameHour, isSameMinute, isSameMonth, isSameQuarter, isSameSecond, isSameYear, isString, isTemplateRef, isToday, isTomorrow, isTouchEvent, isUndefined, isUndefinedOrNull, isValid, isWeekend, isWindow, keyBy, log, match, mergeReferences, produce, references_d as references, set, setDate, setDay, setDefaultOptions, setMonth, setQuarter, setWarnDeprecation, setYear, shallowEqual, sortRangeValue, startOfDay, startOfHour, startOfISOWeek, startOfMinute, startOfMonth, startOfQuarter, startOfWeek, startOfYear, subBusinessDays, subDays, subHours, subMilliseconds, subMinutes, subMonths, subQuarters, subSeconds, subWeeks, subYears, valueFunctionProp, warn, warnDeprecation };
+export type { ArrayAlwaysExtract, ArrayInferExtract, ElementSelector, EntityAddOptions as EntityAddOptions$0, EntityMoveOptions, FunctionProp, ProducerOptions, ReferenceArrayExtractAllowKeys, ReferenceArrayExtractAllowNames, ReferenceArrayExtractNames, ReferenceExtractAllowKeys, ReferenceExtractAllowNames, ReferenceExtractNames, ReferenceObjectExtract, SimpleRect, ThyBooleanInput, TinyDateCompareGrain, TinyDateType, WeekDayIndex };

package/vote/index.d.ts

@@ -1,2 +1,66 @@
-export * from './vote.module';
-export * from './vote.component';
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import * as i1 from '@angular/common';
+import * as i2 from 'ngx-tethys/shared';
+import * as i3 from 'ngx-tethys/icon';
+
+type ThyVoteSizes = 'default' | 'sm';
+type ThyVoteType = 'primary' | 'success' | 'primary-weak' | 'success-weak';
+type ThyVoteLayout = 'vertical' | 'horizontal';
+/**
+ * 投票组件
+ * @name thy-vote,[thyVote]
+ * @order 10
+ */
+declare class ThyVote {
+    private hostRenderer;
+    /**
+     * 大小，thyLayout="vertical" 时，支持: sm | default
+     */
+    readonly thySize: _angular_core.InputSignalWithTransform<ThyVoteSizes, ThyVoteSizes>;
+    /**
+     * 标签类型: primary | success | primary-weak | success-weak
+     */
+    readonly thyVote: _angular_core.InputSignalWithTransform<ThyVoteType, ThyVoteType>;
+    /**
+     * 是否是偏圆型
+     */
+    readonly thyRound: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * 布局: horizontal | vertical
+     */
+    readonly thyLayout: _angular_core.InputSignalWithTransform<ThyVoteLayout, ThyVoteLayout>;
+    /**
+     * 赞同的数量
+     */
+    readonly thyVoteCount: _angular_core.InputSignal<string | number>;
+    /**
+     * 图标
+     */
+    readonly thyIcon: _angular_core.InputSignalWithTransform<string, string>;
+    /**
+     * 是否赞同
+     */
+    readonly thyHasVoted: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * 是否禁用
+     */
+    readonly thyDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * 自定义Icon模板
+     */
+    readonly voteIcon: _angular_core.Signal<TemplateRef<any>>;
+    constructor();
+    private setClassesByType;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThyVote, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThyVote, "thy-vote,[thyVote]", never, { "thySize": { "alias": "thySize"; "required": false; "isSignal": true; }; "thyVote": { "alias": "thyVote"; "required": false; "isSignal": true; }; "thyRound": { "alias": "thyRound"; "required": false; "isSignal": true; }; "thyLayout": { "alias": "thyLayout"; "required": false; "isSignal": true; }; "thyVoteCount": { "alias": "thyVoteCount"; "required": false; "isSignal": true; }; "thyIcon": { "alias": "thyIcon"; "required": false; "isSignal": true; }; "thyHasVoted": { "alias": "thyHasVoted"; "required": false; "isSignal": true; }; "thyDisabled": { "alias": "thyDisabled"; "required": false; "isSignal": true; }; }, {}, ["voteIcon"], never, true, never>;
+}
+
+declare class ThyVoteModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThyVoteModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ThyVoteModule, never, [typeof i1.CommonModule, typeof i2.ThySharedModule, typeof i3.ThyIconModule, typeof ThyVote], [typeof ThyVote]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ThyVoteModule>;
+}
+
+export { ThyVote, ThyVoteModule };
+export type { ThyVoteLayout, ThyVoteSizes, ThyVoteType };