@latitude-ui/widgets 0.0.13 → 0.0.14

package/cdk/latitude-ui-widgets-cdk.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@latitude-ui/widgets/cdk" />
+export * from './public-api';

package/cdk/public-api.d.ts

@@ -0,0 +1,12 @@
+export * from './src/collection/collection';
+export * from './src/expression/expression';
+export * from './src/expression/linq';
+export * from './src/expression/sort/sort-descriptor';
+export * from './src/expression/sort/sort-logic';
+export * from './src/expression/filter/filter-logic';
+export * from './src/expression/filter/filter-descriptor';
+export * from './src/expression/filter/filter-criteria-descriptor';
+export * from './src/queryable/query';
+export * from './src/queryable/queryable';
+export * from './src/queryable/transport';
+export * from './src/queryable/http-transport/http-transport';

package/cdk/src/collection/collection.d.ts

@@ -0,0 +1,20 @@
+import { WritableSignal } from '@angular/core';
+export declare class Collection<T> {
+    readonly values: import("@angular/core").Signal<T[]>;
+    readonly length: import("@angular/core").Signal<number>;
+    readonly _values: WritableSignal<T[]>;
+    constructor(items?: T[]);
+    set(values: T[]): void;
+    update(updateFn: (values: ReadonlyArray<T>) => T[]): void;
+    append(value: T): void;
+    delete(value: T): void;
+    insert(value: T, index?: number): void;
+    splice(start: number, deleteCount: number): void;
+    splice(start: number, deleteCount: number, ...newItems: T[]): void;
+    indexOf(searchElement: T, fromIndex?: number): number;
+    lastIndexOf(searchElement: T, fromIndex?: number): number;
+    find(predicate: (value: T, index: number, values: ReadonlyArray<T>) => unknown): T | undefined;
+    findIndex(predicate: (value: T, index: number, values: ReadonlyArray<T>) => unknown): number;
+    includes(value: T): boolean;
+    forEach(callbackFn: (value: T, index: number, array: ReadonlyArray<T>) => void): void;
+}

package/cdk/src/expression/expression.d.ts

@@ -0,0 +1,12 @@
+export declare class Expression {
+    readonly kind: string;
+    constructor(kind: string);
+}
+export declare class ValueExpression<T> extends Expression {
+    readonly value: T;
+    constructor(value: T);
+}
+export declare class PropertyExpression extends Expression {
+    readonly name: string;
+    constructor(name: string);
+}

package/cdk/src/expression/filter/filter-criteria-descriptor.d.ts

@@ -0,0 +1,6 @@
+import { Expression } from '../expression';
+export declare class FilterCriteriaDescriptor {
+    readonly operator: string;
+    readonly operands: [Expression, Expression];
+    constructor(operator: string, operands: [Expression, Expression]);
+}

package/cdk/src/expression/filter/filter-descriptor.d.ts

@@ -0,0 +1,7 @@
+import { FilterLogic } from './filter-logic';
+import { FilterCriteriaDescriptor } from './filter-criteria-descriptor';
+export declare class FilterDescriptor {
+    readonly logic: FilterLogic;
+    readonly values: Array<FilterDescriptor | FilterCriteriaDescriptor>;
+    constructor(logic: FilterLogic, values?: Array<FilterDescriptor | FilterCriteriaDescriptor>);
+}

package/cdk/src/expression/filter/filter-logic.d.ts

@@ -0,0 +1 @@
+export type FilterLogic = 'and' | 'or';

package/cdk/src/expression/linq.d.ts

@@ -0,0 +1,38 @@
+import { Expression, PropertyExpression, ValueExpression } from './expression';
+import { FilterDescriptor } from './filter/filter-descriptor';
+import { FilterCriteriaDescriptor } from './filter/filter-criteria-descriptor';
+import { FilterLogic } from './filter/filter-logic';
+export declare function or(...values: Array<FilterDescriptor | FilterCriteriaDescriptor>): FilterDescriptor;
+export declare function and(...values: Array<FilterDescriptor | FilterCriteriaDescriptor>): FilterDescriptor;
+export declare function eq(operand0: Expression, operand1: Expression): FilterCriteriaDescriptor;
+export declare function neq(operand0: Expression, operand1: Expression): FilterCriteriaDescriptor;
+export declare function lt(operand0: Expression, operand1: Expression): FilterCriteriaDescriptor;
+export declare function lte(operand0: Expression, operand1: Expression): FilterCriteriaDescriptor;
+export declare function gt(operand0: Expression, operand1: Expression): FilterCriteriaDescriptor;
+export declare function gte(operand0: Expression, operand1: Expression): FilterCriteriaDescriptor;
+export declare function value<T>(value: T): ValueExpression<T>;
+export declare function property(name: string): PropertyExpression;
+export interface FilterBuilderFn {
+    (...values: Array<FilterDescriptor | FilterCriteriaDescriptor>): FilterDescriptor;
+    (logic: FilterLogic, ...values: Array<FilterDescriptor | FilterCriteriaDescriptor>): FilterDescriptor;
+}
+export declare const where: FilterBuilderFn & {
+    eq: typeof eq;
+    neq: typeof neq;
+    lt: typeof lt;
+    lte: typeof lte;
+    gt: typeof gt;
+    gte: typeof gte;
+};
+export declare const linq: {
+    readonly v: typeof value;
+    readonly p: typeof property;
+    readonly where: FilterBuilderFn & {
+        eq: typeof eq;
+        neq: typeof neq;
+        lt: typeof lt;
+        lte: typeof lte;
+        gt: typeof gt;
+        gte: typeof gte;
+    };
+};

package/cdk/src/expression/sort/sort-descriptor.d.ts

@@ -0,0 +1,7 @@
+import { Expression } from '../expression';
+import { SortLogic } from './sort-logic';
+export declare class SortDescriptor {
+    readonly logic: SortLogic;
+    readonly operand: Expression;
+    constructor(logic: SortLogic, operand: Expression);
+}

package/cdk/src/expression/sort/sort-logic.d.ts

@@ -0,0 +1 @@
+export type SortLogic = 'asc' | 'desc' | '-asc' | '-desc';

package/cdk/src/queryable/http-transport/http-transport.d.ts

@@ -0,0 +1,15 @@
+import { WritableSignal } from '@angular/core';
+import { HttpResourceRef, HttpResourceRequest } from '@angular/common/http';
+import { Transport, TransportCollection, TransportFn, TransportParams } from '../transport';
+export type HttpTransportRequest = HttpResourceRequest | undefined;
+export declare class HttpTransport<T> implements Transport<T> {
+    readonly idle: import("@angular/core").Signal<boolean>;
+    readonly pending: import("@angular/core").Signal<boolean>;
+    readonly rejected: import("@angular/core").Signal<boolean>;
+    readonly fulfilled: import("@angular/core").Signal<boolean>;
+    readonly collection: import("@angular/core").Signal<TransportCollection<T>>;
+    readonly httpRequest: WritableSignal<HttpTransportRequest>;
+    readonly httpResource: HttpResourceRef<TransportCollection<T> | undefined>;
+    constructor(params: TransportParams, requestFn: (params: TransportParams) => HttpTransportRequest);
+}
+export declare function httpTransport<T>(requestFn: (params: TransportParams) => HttpTransportRequest): TransportFn<T>;

package/cdk/src/queryable/query.d.ts

@@ -0,0 +1,16 @@
+import { Signal } from '@angular/core';
+import { FilterDescriptor } from '../expression/filter/filter-descriptor';
+export interface Query {
+    sort: unknown;
+    group: unknown;
+    filter: FilterDescriptor | null;
+    aggregate: unknown;
+}
+export declare class QueryCollection {
+    readonly sort: Signal<unknown>;
+    readonly group: Signal<unknown>;
+    readonly filter: Signal<FilterDescriptor | null>;
+    readonly aggregate: Signal<unknown>;
+    readonly value: Signal<Query>;
+    constructor(query?: Partial<Query>);
+}

package/cdk/src/queryable/queryable.d.ts

@@ -0,0 +1,18 @@
+import { Transport, TransportFn } from './transport';
+import { Query, QueryCollection } from './query';
+export interface QueryableOptions<T> {
+    transport: TransportFn<T>;
+    defaultQuery?: Partial<Query>;
+}
+export declare class Queryable<T> {
+    readonly values: import("@angular/core").WritableSignal<T[]>;
+    readonly length: import("@angular/core").WritableSignal<number>;
+    readonly idle: import("@angular/core").Signal<boolean>;
+    readonly pending: import("@angular/core").Signal<boolean>;
+    readonly rejected: import("@angular/core").Signal<boolean>;
+    readonly fulfilled: import("@angular/core").Signal<boolean>;
+    readonly query: QueryCollection;
+    readonly transport: Transport<T>;
+    constructor({ transport, defaultQuery }: QueryableOptions<T>);
+}
+export declare function queryable<T>(options: QueryableOptions<T>): Queryable<T>;

package/cdk/src/queryable/transport.d.ts

@@ -0,0 +1,19 @@
+import { Signal } from '@angular/core';
+import { Query } from './query';
+export interface TransportFn<T> {
+    (params: TransportParams): Transport<T>;
+}
+export interface TransportParams {
+    query: Signal<Query>;
+}
+export interface TransportCollection<T> {
+    values: T[];
+    length: number;
+}
+export interface Transport<T> {
+    readonly idle: Signal<boolean>;
+    readonly pending: Signal<boolean>;
+    readonly rejected: Signal<boolean>;
+    readonly fulfilled: Signal<boolean>;
+    readonly collection: Signal<TransportCollection<T>>;
+}

package/checkbox/src/checkbox.component.d.ts

@@ -1,7 +1,7 @@
 import { BuildInInputValueAccessor } from '@latitude-ui/widgets/input';
 import * as i0 from "@angular/core";
 export declare class CheckBoxComponent extends BuildInInputValueAccessor<boolean> {
-    protected handleValueChange(): void;
+    toggle(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CheckBoxComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<CheckBoxComponent, "lat-checkbox", ["latCheckBox"], {}, {}, never, ["*"], true, never>;
 }

package/core/src/listeners.d.ts

@@ -3,6 +3,6 @@ import { Injector } from '@angular/core';
  *  https://github.com/angular/angular/issues/9587
  */
 export declare function listenMouseEvent<T extends HTMLElement>(nativeElement: T, options?: {
-    disabled?: () => boolean;
+    disabled?: () => boolean | undefined;
     injector?: Injector;
 }): VoidFunction;

package/esm2022/button/src/button.component.js

@@ -41,4 +41,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.4", ngImpor
                         '[class.lat-button-icon]': 'onlyicon()',
                     }, template: "<ng-content />\n" }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/latitude-ui-widgets-cdk.js

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF0aXR1ZGUtdWktd2lkZ2V0cy1jZGsuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy93aWRnZXRzL2Nkay9sYXRpdHVkZS11aS13aWRnZXRzLWNkay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/cdk/public-api.js

@@ -0,0 +1,13 @@
+export * from './src/collection/collection';
+export * from './src/expression/expression';
+export * from './src/expression/linq';
+export * from './src/expression/sort/sort-descriptor';
+export * from './src/expression/sort/sort-logic';
+export * from './src/expression/filter/filter-logic';
+export * from './src/expression/filter/filter-descriptor';
+export * from './src/expression/filter/filter-criteria-descriptor';
+export * from './src/queryable/query';
+export * from './src/queryable/queryable';
+export * from './src/queryable/transport';
+export * from './src/queryable/http-transport/http-transport';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3dpZGdldHMvY2RrL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2QkFBNkIsQ0FBQztBQUU1QyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsdUJBQXVCLENBQUM7QUFFdEMsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLGtDQUFrQyxDQUFDO0FBRWpELGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYywyQ0FBMkMsQ0FBQztBQUMxRCxjQUFjLG9EQUFvRCxDQUFDO0FBRW5FLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLDJCQUEyQixDQUFDO0FBRTFDLGNBQWMsK0NBQStDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NyYy9jb2xsZWN0aW9uL2NvbGxlY3Rpb24nO1xuXG5leHBvcnQgKiBmcm9tICcuL3NyYy9leHByZXNzaW9uL2V4cHJlc3Npb24nO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvZXhwcmVzc2lvbi9saW5xJztcblxuZXhwb3J0ICogZnJvbSAnLi9zcmMvZXhwcmVzc2lvbi9zb3J0L3NvcnQtZGVzY3JpcHRvcic7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9leHByZXNzaW9uL3NvcnQvc29ydC1sb2dpYyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vc3JjL2V4cHJlc3Npb24vZmlsdGVyL2ZpbHRlci1sb2dpYyc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9leHByZXNzaW9uL2ZpbHRlci9maWx0ZXItZGVzY3JpcHRvcic7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9leHByZXNzaW9uL2ZpbHRlci9maWx0ZXItY3JpdGVyaWEtZGVzY3JpcHRvcic7XG5cbmV4cG9ydCAqIGZyb20gJy4vc3JjL3F1ZXJ5YWJsZS9xdWVyeSc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9xdWVyeWFibGUvcXVlcnlhYmxlJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL3F1ZXJ5YWJsZS90cmFuc3BvcnQnO1xuXG5leHBvcnQgKiBmcm9tICcuL3NyYy9xdWVyeWFibGUvaHR0cC10cmFuc3BvcnQvaHR0cC10cmFuc3BvcnQnO1xuXG4iXX0=

package/esm2022/cdk/src/collection/collection.js

@@ -0,0 +1,51 @@
+import { computed, signal } from '@angular/core';
+export class Collection {
+    values = computed(() => this._values());
+    length = computed(() => this._values().length);
+    _values;
+    constructor(items = []) {
+        this._values = signal(items);
+    }
+    set(values) {
+        this._values.set(values);
+    }
+    update(updateFn) {
+        this._values.update(updateFn);
+    }
+    append(value) {
+        this._values.update((values) => [...values, value]);
+    }
+    delete(value) {
+        this._values.update((values) => values.filter((x) => x !== value));
+    }
+    insert(value, index) {
+        this._values.update((values) => {
+            index ??= 0;
+            return [...values.slice(0, index), value, ...values.slice(index)];
+        });
+    }
+    splice(start, deleteCount, ...newItems) {
+        this._values.update((items) => {
+            return items.splice(start, deleteCount, ...newItems);
+        });
+    }
+    indexOf(searchElement, fromIndex) {
+        return this._values().indexOf(searchElement, fromIndex);
+    }
+    lastIndexOf(searchElement, fromIndex) {
+        return this._values().lastIndexOf(searchElement, fromIndex);
+    }
+    find(predicate) {
+        return this._values().find(predicate);
+    }
+    findIndex(predicate) {
+        return this._values().findIndex(predicate);
+    }
+    includes(value) {
+        return this._values().includes(value);
+    }
+    forEach(callbackFn) {
+        return this._values().forEach(callbackFn);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/src/expression/expression.js

@@ -0,0 +1,21 @@
+export class Expression {
+    kind;
+    constructor(kind) {
+        this.kind = kind;
+    }
+}
+export class ValueExpression extends Expression {
+    value;
+    constructor(value) {
+        super('ValueExpression');
+        this.value = value;
+    }
+}
+export class PropertyExpression extends Expression {
+    name;
+    constructor(name) {
+        super('PropertyExpression');
+        this.name = name;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwcmVzc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3dpZGdldHMvY2RrL3NyYy9leHByZXNzaW9uL2V4cHJlc3Npb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLFVBQVU7SUFDWixJQUFJLENBQVM7SUFFdEIsWUFBWSxJQUFZO1FBQ3RCLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO0lBQ25CLENBQUM7Q0FDRjtBQUVELE1BQU0sT0FBTyxlQUFtQixTQUFRLFVBQVU7SUFDdkMsS0FBSyxDQUFJO0lBRWxCLFlBQVksS0FBUTtRQUNsQixLQUFLLENBQUMsaUJBQWlCLENBQUMsQ0FBQztRQUV6QixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztJQUNyQixDQUFDO0NBQ0Y7QUFHRCxNQUFNLE9BQU8sa0JBQW1CLFNBQVEsVUFBVTtJQUN2QyxJQUFJLENBQVM7SUFFdEIsWUFBWSxJQUFZO1FBQ3RCLEtBQUssQ0FBQyxvQkFBb0IsQ0FBQyxDQUFDO1FBRTVCLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO0lBQ25CLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIlxyXG5cclxuZXhwb3J0IGNsYXNzIEV4cHJlc3Npb24ge1xyXG4gIHJlYWRvbmx5IGtpbmQ6IHN0cmluZztcclxuXHJcbiAgY29uc3RydWN0b3Ioa2luZDogc3RyaW5nKSB7XHJcbiAgICB0aGlzLmtpbmQgPSBraW5kO1xyXG4gIH1cclxufVxyXG5cclxuZXhwb3J0IGNsYXNzIFZhbHVlRXhwcmVzc2lvbjxUPiBleHRlbmRzIEV4cHJlc3Npb24ge1xyXG4gIHJlYWRvbmx5IHZhbHVlOiBUO1xyXG5cclxuICBjb25zdHJ1Y3Rvcih2YWx1ZTogVCkge1xyXG4gICAgc3VwZXIoJ1ZhbHVlRXhwcmVzc2lvbicpO1xyXG5cclxuICAgIHRoaXMudmFsdWUgPSB2YWx1ZTtcclxuICB9XHJcbn1cclxuXHJcblxyXG5leHBvcnQgY2xhc3MgUHJvcGVydHlFeHByZXNzaW9uIGV4dGVuZHMgRXhwcmVzc2lvbiB7XHJcbiAgcmVhZG9ubHkgbmFtZTogc3RyaW5nO1xyXG5cclxuICBjb25zdHJ1Y3RvcihuYW1lOiBzdHJpbmcpIHtcclxuICAgIHN1cGVyKCdQcm9wZXJ0eUV4cHJlc3Npb24nKTtcclxuXHJcbiAgICB0aGlzLm5hbWUgPSBuYW1lO1xyXG4gIH1cclxufVxyXG5cclxuIl19

package/esm2022/cdk/src/expression/filter/filter-criteria-descriptor.js

@@ -0,0 +1,9 @@
+export class FilterCriteriaDescriptor {
+    operator;
+    operands;
+    constructor(operator, operands) {
+        this.operator = operator;
+        this.operands = operands;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLWNyaXRlcmlhLWRlc2NyaXB0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy93aWRnZXRzL2Nkay9zcmMvZXhwcmVzc2lvbi9maWx0ZXIvZmlsdGVyLWNyaXRlcmlhLWRlc2NyaXB0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLHdCQUF3QjtJQUMxQixRQUFRLENBQVM7SUFDakIsUUFBUSxDQUEyQjtJQUU1QyxZQUFZLFFBQWdCLEVBQUUsUUFBa0M7UUFDOUQsSUFBSSxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUM7UUFDekIsSUFBSSxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUM7SUFDM0IsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXhwcmVzc2lvbiB9IGZyb20gJy4uL2V4cHJlc3Npb24nO1xuXG5leHBvcnQgY2xhc3MgRmlsdGVyQ3JpdGVyaWFEZXNjcmlwdG9yIHtcbiAgcmVhZG9ubHkgb3BlcmF0b3I6IHN0cmluZztcbiAgcmVhZG9ubHkgb3BlcmFuZHM6IFtFeHByZXNzaW9uLCBFeHByZXNzaW9uXTtcblxuICBjb25zdHJ1Y3RvcihvcGVyYXRvcjogc3RyaW5nLCBvcGVyYW5kczogW0V4cHJlc3Npb24sIEV4cHJlc3Npb25dKSB7XG4gICAgdGhpcy5vcGVyYXRvciA9IG9wZXJhdG9yO1xuICAgIHRoaXMub3BlcmFuZHMgPSBvcGVyYW5kcztcbiAgfVxufVxuIl19

package/esm2022/cdk/src/expression/filter/filter-descriptor.js

@@ -0,0 +1,9 @@
+export class FilterDescriptor {
+    logic;
+    values;
+    constructor(logic, values = []) {
+        this.logic = logic;
+        this.values = values;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLWRlc2NyaXB0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy93aWRnZXRzL2Nkay9zcmMvZXhwcmVzc2lvbi9maWx0ZXIvZmlsdGVyLWRlc2NyaXB0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsTUFBTSxPQUFPLGdCQUFnQjtJQUNsQixLQUFLLENBQWE7SUFDbEIsTUFBTSxDQUFxRDtJQUVwRSxZQUFZLEtBQWtCLEVBQUUsU0FBNkQsRUFBRTtRQUM3RixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztRQUNuQixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztJQUN2QixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGaWx0ZXJMb2dpYyB9IGZyb20gJy4vZmlsdGVyLWxvZ2ljJztcclxuaW1wb3J0IHsgRmlsdGVyQ3JpdGVyaWFEZXNjcmlwdG9yIH0gZnJvbSAnLi9maWx0ZXItY3JpdGVyaWEtZGVzY3JpcHRvcic7XHJcblxyXG5leHBvcnQgY2xhc3MgRmlsdGVyRGVzY3JpcHRvciB7XHJcbiAgcmVhZG9ubHkgbG9naWM6IEZpbHRlckxvZ2ljXHJcbiAgcmVhZG9ubHkgdmFsdWVzOiBBcnJheTxGaWx0ZXJEZXNjcmlwdG9yIHwgRmlsdGVyQ3JpdGVyaWFEZXNjcmlwdG9yPjtcclxuXHJcbiAgY29uc3RydWN0b3IobG9naWM6IEZpbHRlckxvZ2ljLCB2YWx1ZXM6IEFycmF5PEZpbHRlckRlc2NyaXB0b3IgfCBGaWx0ZXJDcml0ZXJpYURlc2NyaXB0b3I+ID0gW10pIHtcclxuICAgIHRoaXMubG9naWMgPSBsb2dpYztcclxuICAgIHRoaXMudmFsdWVzID0gdmFsdWVzO1xyXG4gIH1cclxufVxyXG5cclxuXHJcbiJdfQ==

package/esm2022/cdk/src/expression/filter/filter-logic.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLWxvZ2ljLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvd2lkZ2V0cy9jZGsvc3JjL2V4cHJlc3Npb24vZmlsdGVyL2ZpbHRlci1sb2dpYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiXHJcbmV4cG9ydCB0eXBlIEZpbHRlckxvZ2ljID0gJ2FuZCcgfCAnb3InO1xyXG4iXX0=

package/esm2022/cdk/src/expression/linq.js

@@ -0,0 +1,55 @@
+import { PropertyExpression, ValueExpression } from './expression';
+import { FilterDescriptor } from './filter/filter-descriptor';
+import { FilterCriteriaDescriptor } from './filter/filter-criteria-descriptor';
+export function or(...values) {
+    return new FilterDescriptor('and', values);
+}
+export function and(...values) {
+    return new FilterDescriptor('and', values);
+}
+export function eq(operand0, operand1) {
+    return new FilterCriteriaDescriptor('eq', [operand0, operand1]);
+}
+export function neq(operand0, operand1) {
+    return new FilterCriteriaDescriptor('neq', [operand0, operand1]);
+}
+export function lt(operand0, operand1) {
+    return new FilterCriteriaDescriptor('lt', [operand0, operand1]);
+}
+export function lte(operand0, operand1) {
+    return new FilterCriteriaDescriptor('lte', [operand0, operand1]);
+}
+export function gt(operand0, operand1) {
+    return new FilterCriteriaDescriptor('gt', [operand0, operand1]);
+}
+export function gte(operand0, operand1) {
+    return new FilterCriteriaDescriptor('gte', [operand0, operand1]);
+}
+export function value(value) {
+    return new ValueExpression(value);
+}
+export function property(name) {
+    return new PropertyExpression(name);
+}
+export const where = (() => {
+    const fn = (logic, ...values) => {
+        if (typeof logic === 'string') {
+            return new FilterDescriptor(logic, values);
+        }
+        return new FilterDescriptor('and', values);
+    };
+    return Object.assign(fn, {
+        eq,
+        neq,
+        lt,
+        lte,
+        gt,
+        gte,
+    });
+})();
+export const linq = {
+    v: value,
+    p: property,
+    where: where,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/src/expression/sort/sort-descriptor.js

@@ -0,0 +1,9 @@
+export class SortDescriptor {
+    logic;
+    operand;
+    constructor(logic, operand) {
+        this.logic = logic;
+        this.operand = operand;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29ydC1kZXNjcmlwdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvd2lkZ2V0cy9jZGsvc3JjL2V4cHJlc3Npb24vc29ydC9zb3J0LWRlc2NyaXB0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsTUFBTSxPQUFPLGNBQWM7SUFDaEIsS0FBSyxDQUFZO0lBQ2pCLE9BQU8sQ0FBYTtJQUU3QixZQUFZLEtBQWdCLEVBQUUsT0FBbUI7UUFDL0MsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7UUFDbkIsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7SUFDekIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXhwcmVzc2lvbiB9IGZyb20gJy4uL2V4cHJlc3Npb24nO1xuaW1wb3J0IHsgU29ydExvZ2ljIH0gZnJvbSAnLi9zb3J0LWxvZ2ljJztcblxuXG5leHBvcnQgY2xhc3MgU29ydERlc2NyaXB0b3Ige1xuICByZWFkb25seSBsb2dpYzogU29ydExvZ2ljO1xuICByZWFkb25seSBvcGVyYW5kOiBFeHByZXNzaW9uO1xuXG4gIGNvbnN0cnVjdG9yKGxvZ2ljOiBTb3J0TG9naWMsIG9wZXJhbmQ6IEV4cHJlc3Npb24pIHtcbiAgICB0aGlzLmxvZ2ljID0gbG9naWM7XG4gICAgdGhpcy5vcGVyYW5kID0gb3BlcmFuZDtcbiAgfVxufVxuIl19

package/esm2022/cdk/src/expression/sort/sort-logic.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29ydC1sb2dpYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3dpZGdldHMvY2RrL3NyYy9leHByZXNzaW9uL3NvcnQvc29ydC1sb2dpYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiXHJcbmV4cG9ydCB0eXBlIFNvcnRMb2dpYyA9ICdhc2MnIHwgJ2Rlc2MnIHwgJy1hc2MnIHwgJy1kZXNjJztcclxuIl19

package/esm2022/cdk/src/queryable/http-transport/http-transport.js

@@ -0,0 +1,24 @@
+import { computed, linkedSignal } from '@angular/core';
+import { httpResource } from '@angular/common/http';
+export class HttpTransport {
+    idle = computed(() => this.httpResource.status() === 'idle');
+    pending = computed(() => this.httpResource.status() === 'loading' || this.httpResource.status() === 'reloading');
+    rejected = computed(() => this.httpResource.status() === 'error');
+    fulfilled = computed(() => this.httpResource.status() === 'resolved');
+    collection = computed(() => {
+        if (this.httpResource.hasValue()) {
+            return this.httpResource.value();
+        }
+        return { values: [], length: 0 };
+    });
+    httpRequest;
+    httpResource;
+    constructor(params, requestFn) {
+        this.httpRequest = linkedSignal(() => requestFn(params));
+        this.httpResource = httpResource(() => this.httpRequest());
+    }
+}
+export function httpTransport(requestFn) {
+    return (params) => new HttpTransport(params, requestFn);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/src/queryable/query.js

@@ -0,0 +1,22 @@
+import { computed, signal } from '@angular/core';
+export class QueryCollection {
+    sort;
+    group;
+    filter;
+    aggregate;
+    value = computed(() => {
+        return {
+            sort: this.sort(),
+            group: this.group(),
+            filter: this.filter(),
+            aggregate: this.aggregate(),
+        };
+    });
+    constructor(query = {}) {
+        this.sort = signal(query.sort ?? null);
+        this.group = signal(query.group ?? null);
+        this.filter = signal(query.filter ?? null);
+        this.aggregate = signal(query.aggregate ?? null);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/src/queryable/queryable.js

@@ -0,0 +1,20 @@
+import { computed, linkedSignal } from '@angular/core';
+import { QueryCollection } from './query';
+export class Queryable {
+    values = linkedSignal(() => this.transport.collection().values);
+    length = linkedSignal(() => this.transport.collection().length);
+    idle = computed(() => this.transport.idle());
+    pending = computed(() => this.transport.pending());
+    rejected = computed(() => this.transport.rejected());
+    fulfilled = computed(() => this.transport.fulfilled());
+    query;
+    transport;
+    constructor({ transport, defaultQuery }) {
+        this.query = new QueryCollection(defaultQuery);
+        this.transport = transport({ query: this.query.value });
+    }
+}
+export function queryable(options) {
+    return new Queryable(options);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/src/queryable/transport.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNwb3J0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvd2lkZ2V0cy9jZGsvc3JjL3F1ZXJ5YWJsZS90cmFuc3BvcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNpZ25hbCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgUXVlcnkgfSBmcm9tICcuL3F1ZXJ5JztcblxuZXhwb3J0IGludGVyZmFjZSBUcmFuc3BvcnRGbjxUPiB7XG4gIChwYXJhbXM6IFRyYW5zcG9ydFBhcmFtcyk6IFRyYW5zcG9ydDxUPlxufVxuXG5leHBvcnQgaW50ZXJmYWNlIFRyYW5zcG9ydFBhcmFtcyB7XG4gIHF1ZXJ5OiBTaWduYWw8UXVlcnk+XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgVHJhbnNwb3J0Q29sbGVjdGlvbjxUPiB7XG4gIHZhbHVlczogVFtdO1xuICBsZW5ndGg6IG51bWJlcjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBUcmFuc3BvcnQ8VD4ge1xuICByZWFkb25seSBpZGxlOiBTaWduYWw8Ym9vbGVhbj47XG4gIHJlYWRvbmx5IHBlbmRpbmc6IFNpZ25hbDxib29sZWFuPjtcbiAgcmVhZG9ubHkgcmVqZWN0ZWQ6IFNpZ25hbDxib29sZWFuPjtcbiAgcmVhZG9ubHkgZnVsZmlsbGVkOiBTaWduYWw8Ym9vbGVhbj47XG5cbiAgcmVhZG9ubHkgY29sbGVjdGlvbjogU2lnbmFsPFRyYW5zcG9ydENvbGxlY3Rpb248VD4+O1xufVxuXG4iXX0=

package/esm2022/checkbox/src/checkbox.component.js

@@ -3,14 +3,14 @@ import { BuildInInputValueAccessor } from '@latitude-ui/widgets/input';
 import { IconComponent } from '@latitude-ui/widgets/icons';
 import * as i0 from "@angular/core";
 export class CheckBoxComponent extends BuildInInputValueAccessor {
-    handleValueChange() {
+    toggle() {
         if (!this.disabled()) {
             const value = this.value() ?? false;
             this.writeValue(!value);
         }
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.4", ngImport: i0, type: CheckBoxComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.0.4", type: CheckBoxComponent, isStandalone: true, selector: "lat-checkbox", host: { listeners: { "click": "handleValueChange()" } }, providers: [
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.0.4", type: CheckBoxComponent, isStandalone: true, selector: "lat-checkbox", host: { listeners: { "click": "toggle()" } }, providers: [
             {
                 provide: BuildInInputValueAccessor,
                 useExisting: forwardRef(() => CheckBoxComponent),
@@ -27,7 +27,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.4", ngImpor
                             useExisting: forwardRef(() => CheckBoxComponent),
                         },
                     ], host: {
-                        '(click)': 'handleValueChange()',
+                        '(click)': 'toggle()',
                     }, template: "<button\r\n  type=\"button\"\r\n  role=\"checkbox\"\r\n  [attr.id]=\"inputId()\"\r\n  [attr.value]=\"value() ? 'on' : 'off'\"\r\n  [attr.tabindex]=\"disabled() ? -1 : tabindex()\"\r\n  [attr.disabled]=\"disabled() || undefined\"\r\n  [attr.aria-checked]=\"value() || false\"\r\n>\r\n  <lat-icon name=\"check\" />\r\n</button>\r\n<ng-content/>\r\n" }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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