@ngutil/data 0.0.10

package/query/executor.d.ts

@@ -0,0 +1,30 @@
+import { Primitive } from "utility-types";
+import { Model } from "../model";
+import { Query, QueryResult } from "./query";
+declare const INPUT: unique symbol;
+interface PartialExecutor {
+    [INPUT]: any;
+}
+export interface QueryExecutors<T extends Model> {
+    readonly filterFn?: FilterExecutor<T>;
+    readonly sorterFn?: SorterExecutor<T>;
+    readonly grouperFn?: GrouperExecutor<T>;
+    readonly slicerFn?: SliceExecutor<T>;
+}
+export interface QueryExecutor<T extends Model> extends QueryExecutors<T> {
+    (items: readonly T[]): QueryResult<T>;
+}
+export declare function queryExecutor<T extends Model>(query: Query<T>, previous?: QueryExecutor<T>): QueryExecutor<T>;
+interface FilterExecutor<T extends Model> extends PartialExecutor {
+    (item: T): boolean;
+}
+interface SorterExecutor<T extends Model> extends PartialExecutor {
+    (a: T, b: T): number;
+}
+interface GrouperExecutor<T extends Model> extends PartialExecutor {
+    (item: T): Primitive;
+}
+interface SliceExecutor<T extends Model> extends PartialExecutor {
+    (items: readonly T[]): T[];
+}
+export {};

package/query/filter.d.ts

@@ -0,0 +1,65 @@
+import { AsPrimitive, MaxRecursion } from "@ngutil/common";
+import { Model } from "../model";
+export declare const enum FilterOp {
+    Eq = "==",
+    EqStrict = "===",
+    EqInsesitive = "==*",
+    Neq = "!=",
+    NeqStrict = "!==",
+    NeqInsesitive = "!=*",
+    Gt = ">",
+    GtInsesitive = ">*",
+    Gte = ">=",
+    GteInsesitive = ">=*",
+    Lt = "<",
+    LtInsesitive = "<*",
+    Lte = "<=",
+    LteInsesitive = "<=*",
+    Contains = "%",
+    ContainsInsesitive = "%*",
+    StartsWith = "^",
+    StartsWithInsesitive = "^*",
+    EndsWith = "$",
+    EndsWithInsesitive = "$*",
+    Regexp = "~",
+    RegexpInsesitive = "~*",
+    Or = "|",
+    And = "&"
+}
+export declare const OPERATORS: Array<string>;
+export declare function asOperators(value: any): Array<{
+    op: FilterOp;
+    value: any;
+}>;
+export type Filter<T extends Model> = {
+    [key: string]: any;
+};
+export type Operators<T, P extends number[], D extends number = MaxRecursion> = P["length"] extends D ? never : SimpleOperators<T>;
+type SimpleOperators<T> = EqStrict<T> | NeqStrict<T> | Eq<T> | Neq<T> | Gt<T> | Gte<T> | Lt<T> | Lte<T> | Contains<T> | StartsWith<T> | EndsWith<T> | Regexp<T> | T | undefined | null;
+type EqStrict<T> = Operator<T, T, FilterOp.EqStrict, never, null>;
+type NeqStrict<T> = Operator<T, T, FilterOp.NeqStrict, never, null>;
+type Eq<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Eq, FilterOp.EqInsesitive, null>;
+type Neq<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Neq, FilterOp.NeqInsesitive, null>;
+type Gt<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Gt, FilterOp.GtInsesitive>;
+type Gte<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Gte, FilterOp.GteInsesitive>;
+type Lt<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Lt, FilterOp.LtInsesitive>;
+type Lte<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Lte, FilterOp.LteInsesitive>;
+type Contains<T> = Operator<T, string, FilterOp.Contains, FilterOp.ContainsInsesitive>;
+type StartsWith<T> = Operator<T, string, FilterOp.StartsWith, FilterOp.StartsWithInsesitive>;
+type EndsWith<T> = Operator<T, string, FilterOp.EndsWith, FilterOp.EndsWithInsesitive>;
+type Regexp<T> = Operator<T, string, FilterOp.Regexp, FilterOp.RegexpInsesitive, RegExp>;
+type Operator<T, R, OP extends string, OPI extends string = never, ET = never> = (T extends R ? {
+    [k in OP]: T | ET | R;
+} : never) | (T extends string ? (OPI extends never ? never : {
+    [k in OPI]: string;
+}) : never);
+export type FilterFn<T = any> = (item: T) => boolean;
+/**
+ * @example
+ * ```ts
+ * items.filter(filterBy({id: 42}))
+ * ```
+ */
+export declare function filterBy<T extends Model>(filters: Filter<T>): FilterFn<T>;
+export declare function filterMerge(...filters: any[]): any | undefined;
+export {};

package/query/grouper.d.ts

@@ -0,0 +1,6 @@
+import { Flatten, Primitive } from "@ngutil/common";
+import { Model } from "../model";
+export type GrouperFn<T = any> = (item: any) => Primitive;
+export type Grouper<T extends Model, F = Flatten<T>> = any;
+export declare function groupBy<T extends Model, F = Flatten<T>>(grouper: Grouper<T, F>): GrouperFn<T>;
+export declare function grouperMerge<T extends Model, F = Flatten<T>>(...groupers: Array<Grouper<T, F> | undefined | null>): Grouper<T, F> | undefined;

package/query/index.d.ts

@@ -0,0 +1,8 @@
+export { Filter, filterBy, filterMerge, FilterOp } from "./filter";
+export { Grouper, groupBy, grouperMerge } from "./grouper";
+export { Sorter, sortBy, sorterMerge } from "./sorter";
+export { Slimer, slimBy, slimerMerge } from "./slimer";
+export { Slice, sliceMerge, sliceApply, sliceInsert, sliceToPages, sliceClamp, sliceEq } from "./slice";
+export { pathGetterCompile } from "./path";
+export { Query, QueryResult } from "./query";
+export { queryExecutor, QueryExecutor } from "./executor";

package/query/path.d.ts

@@ -0,0 +1,2 @@
+export type PathGetter<T = any, R = any> = (obj: T) => R[];
+export declare function pathGetterCompile(path: string): PathGetter;

package/query/query.d.ts

@@ -0,0 +1,19 @@
+import { type DeepReadonly } from "@ngutil/common";
+import { type Model } from "../model";
+import { type Filter } from "./filter";
+import { type Grouper } from "./grouper";
+import { type Slice } from "./slice";
+import { type Slimer } from "./slimer";
+import { type Sorter } from "./sorter";
+export interface Query<T extends Model> {
+    filter?: DeepReadonly<Filter<T>>;
+    sorter?: DeepReadonly<Sorter<T>>;
+    slimer?: DeepReadonly<Slimer<T>>;
+    grouper?: DeepReadonly<Grouper<T>>;
+    slice?: DeepReadonly<Slice>;
+}
+export interface QueryResult<T extends Model> {
+    items: readonly T[];
+    total?: number;
+    groups?: any[];
+}

package/query/slice.d.ts

@@ -0,0 +1,32 @@
+import { ListRange } from "@angular/cdk/collections";
+/**
+ * @example
+ * ```ts
+ * {start: 0, end: 0} // empty range
+ * {start: 0, end: 1} // range with one item.eg sliceApply([1, 2, 3], {start:0, end:1}) -> [1]
+ * ```
+ */
+export interface Slice extends ListRange {
+    /**
+     * Start of slice, exact index of item in list
+     */
+    readonly start: number;
+    /**
+     * End of slice, not include end index of item in list
+     */
+    readonly end: number;
+    readonly pageSize?: number;
+}
+export declare function sliceMerge(...slices: Slice[]): Slice | undefined;
+/**
+ * Apply slice to array, and force the result length to equal with Slice length,
+ * so fill array with undefined if not enought elements
+ */
+export declare function sliceApply(slice: Slice, array: readonly any[]): any[];
+/**
+ * @returns Page numbers, eg.: `[10, 11, 12, 13, ...]`
+ */
+export declare function sliceToPages(slice: Slice): number[];
+export declare function sliceInsert(slice: Slice, array: readonly any[], newItems: readonly any[]): any[];
+export declare function sliceClamp(slice: Slice, constraint: Slice): Slice;
+export declare function sliceEq(a: Slice, b: Slice): boolean;

package/query/slimer.d.ts

@@ -0,0 +1,18 @@
+import { Model } from "../model";
+/**
+ * @exmaple
+ * ```ts
+ * [
+ *  "field_name",
+ *  {"child_name": ["child_field_name"]},
+ *  {"children": ["children_field_name", {"$type": Article, slimer: ["id", "title"]}]},
+ *  {"$type": Employee, slimer: ["name"]}.
+ *  {"$filter": Filter<T, F>}
+ * ]
+ * ```
+ */
+export type Slimer<T extends Model> = any;
+export type SlimerFn<T> = (item: T) => T;
+export declare function slimBy<T extends Model>(slimer: Slimer<T>): void;
+export declare function slimerNormalize<T extends Model>(slimer: Slimer<T>): void;
+export declare function slimerMerge<T extends Model>(...slimers: Slimer<T>): void;

package/query/sorter.d.ts

@@ -0,0 +1,40 @@
+import { Model } from "../model";
+export type SorterFn<T = any> = (a: T, b: T) => number;
+export declare const enum SortDirection {
+    Asc = "asc",
+    Desc = "desc"
+}
+type Direction = SortDirection.Asc | SortDirection.Desc | "asc" | "desc";
+type DirectionExtra = {
+    dir: Direction;
+    emptyFirst: boolean;
+};
+export type Sorter<T extends Model> = Array<{
+    [key: string]: Direction | DirectionExtra;
+}>;
+type NormalizedEntry = {
+    path: string;
+    isAsc: boolean;
+    emptyFirst: boolean;
+};
+export type SorterNormalized = Array<NormalizedEntry>;
+/**
+ * @example
+ *```ts
+ * items.toSorted(sortBy([{"author.name": "asc"}]))
+ * ```
+ */
+export declare function sortBy<T extends Model>(sorters: Sorter<T>): SorterFn<T>;
+/**
+ * Normalize sorter definition
+ *
+ * @example
+ * ```ts
+ * normalizeSorter([{id: "asc"}]) -> [{path: "id", isAsc: true, emptyFirst: true}]
+ * normalizeSorter([{id: {dir: "desc", emptyFirst: false}}]) -> [{path: "id", isAsc: false, emptyFirst: false}]
+ * ```
+ */
+export declare function sorterNormalize<T extends Model>(sorters: Sorter<T>): SorterNormalized;
+export declare function compare(a: any, b: any, emptyFirst: boolean): number;
+export declare function sorterMerge<T extends Model>(...sorters: Array<Sorter<T> | undefined | null>): Sorter<T> | undefined;
+export {};