@likable-hair/svelte 3.0.20 → 3.0.21

package/dist/components/simple/navigation/Drawer.svelte

@@ -1,10 +1,18 @@
 <script>import "../../../css/main.css";
 import "./Drawer.css";
 import Navigator from "./Navigator.svelte";
+import { createEventDispatcher } from "svelte";
 export let open = false, position = "left", overlay = true, items = [];
+const dispatch = createEventDispatcher();
 function handleClickOverlay() {
   open = false;
+  overlay = false;
+  dispatch("close");
 }
+$:
+  if (open) {
+    overlay = true;
+  }
 </script>
 
 <div
@@ -75,6 +83,8 @@ function handleClickOverlay() {
     );
     color: var(--drawer-color, var(--drawer-default-color));
     overflow: var(--drawer-overflow, var(--drawer-default-overflow));
+    border-radius: var(--drawer-border-radius);
+    margin: var(--drawer-margin);
   }
 
   .overlay {

package/dist/components/simple/navigation/Drawer.svelte.d.ts

@@ -13,6 +13,7 @@ declare const __propDef: {
         'item-click': CustomEvent<{
             item: Item;
         }>;
+        close: CustomEvent<{}>;
     } & {
         [evt: string]: CustomEvent<any>;
     };

package/dist/utils/filters/builder.d.ts

@@ -10,7 +10,7 @@ export default class Builder {
     where(callback: (builder: Builder) => void): Builder;
     where(key: Record<string, string | number | Date>): Builder;
     where(key: string, value: string | number | Date): Builder;
-    where(key: string, operator: string, value: string | number | Date): Builder;
+    where(key: string, operator: string, value: string | number | Date | boolean): Builder;
     whereNot(callback: (builder: Builder) => void): Builder;
     whereNot(key: Record<string, string | number | Date>): Builder;
     whereNot(key: string, value: string | number | Date): Builder;

package/dist/utils/filters/builder.js

@@ -7,7 +7,7 @@ export default class Builder {
         return this.applyWhereClause('and', first, second, third);
     }
     whereNot(first, second, third) {
-        return this.applyWhereClause('and', first, second, third);
+        return this.applyWhereClause('andNot', first, second, third);
     }
     orWhere(first, second, third) {
         return this.applyWhereClause('or', first, second, third);

package/dist/utils/filters/filters.d.ts

@@ -1,26 +1,89 @@
 import Builder from "./builder";
+export declare const StringModes: readonly ["equal", "like", "ilike"];
+export type StringMode = typeof StringModes[number];
+export declare const GenericModes: readonly ["equal", "greater", "lower", "between"];
+export type DateMode = typeof GenericModes[number];
+export type NumberMode = typeof GenericModes[number];
+export declare const SelectModes: readonly ["equal", "different"];
+export type SelectMode = typeof SelectModes[number];
 type MultiStringFilter = {
     type: 'multiString';
     columns: string[];
     operator?: 'or' | 'and';
+    value?: string;
+};
+type ChoiceFilter = {
+    type: 'choice';
+    column: string;
+    value?: string;
+    operator?: 'or' | 'and';
+    options: any[];
 };
 type StringFilter = {
     type: 'string';
     column: string;
-    value: string | undefined;
-    mode?: 'equal' | 'like' | 'ilike';
+    value?: string;
+    mode?: StringMode;
+};
+type DateFilter = {
+    type: 'date';
+    column: string;
+} & ({
+    mode: 'between';
+    from?: Date;
+    to?: Date;
+} | {
+    mode: 'equal' | 'greater' | 'lower';
+    value?: Date;
+});
+type NumberFilter = {
+    type: 'number';
+    column: string;
+} & ({
+    mode: 'between';
+    from?: number;
+    to?: number;
+} | {
+    mode: 'equal' | 'greater' | 'lower';
+    value?: number;
+});
+type SelectFilter = {
+    type: 'select';
+    column: string;
+    mode: SelectMode;
+    items: {
+        value: string | number;
+        label: string;
+    }[];
+    values?: {
+        value: string | number;
+        label?: string | number;
+    }[];
+};
+type BoolFilter = {
+    type: 'bool';
+    column: string;
+    mode: 'equal';
+    value?: boolean;
+    advanced?: false;
+    desctiprion: string;
 };
 export type Filter = {
     name: string;
-    active: boolean;
+    active?: boolean;
     hidden?: boolean;
     label: string;
-} & (StringFilter | MultiStringFilter);
+    advanced?: boolean;
+} & (StringFilter | MultiStringFilter | ChoiceFilter | DateFilter | NumberFilter | SelectFilter | BoolFilter);
 export default class Converter {
     constructor();
     createBuilder(params: {
         filters: Filter[];
     }): Builder;
     private applyStringFilter;
+    private applyDateFilter;
+    private applyNumberFilter;
+    private applySelectFilter;
+    private applyBooleanFilter;
 }
 export {};

package/dist/utils/filters/filters.js

@@ -1,4 +1,7 @@
 import Builder from "./builder";
+export const StringModes = ['equal', 'like', 'ilike'];
+export const GenericModes = ['equal', 'greater', 'lower', 'between'];
+export const SelectModes = ['equal', 'different'];
 export default class Converter {
     constructor() {
     }
@@ -9,6 +12,18 @@ export default class Converter {
             if (filter.type == 'string') {
                 this.applyStringFilter({ builder, filter });
             }
+            else if (filter.type == 'date') {
+                this.applyDateFilter({ builder, filter });
+            }
+            else if (filter.type == 'number') {
+                this.applyNumberFilter({ builder, filter });
+            }
+            else if (filter.type == 'select') {
+                this.applySelectFilter({ builder, filter });
+            }
+            else if (filter.type == 'bool') {
+                this.applyBooleanFilter({ builder, filter });
+            }
         }
         return builder;
     }
@@ -26,4 +41,62 @@ export default class Converter {
         }
         return params.builder;
     }
+    applyDateFilter(params) {
+        if (params.filter.mode == 'equal' && !!params.filter.value) {
+            params.builder.where(params.filter.column, '=', params.filter.value);
+        }
+        else if (params.filter.mode == 'greater' && !!params.filter.value) {
+            params.builder.where(params.filter.column, '>', params.filter.value);
+        }
+        else if (params.filter.mode == 'lower' && !!params.filter.value) {
+            params.builder.where(params.filter.column, '<', params.filter.value);
+        }
+        else if (params.filter.mode == 'between' && !!params.filter.from && !!params.filter.to) {
+            params.builder.where(params.filter.column, '>', params.filter.from);
+            params.builder.where(params.filter.column, '<', params.filter.to);
+        }
+        return params.builder;
+    }
+    applyNumberFilter(params) {
+        if (params.filter.mode == 'equal' && !!params.filter.value) {
+            params.builder.where(params.filter.column, '=', params.filter.value);
+        }
+        else if (params.filter.mode == 'greater' && !!params.filter.value) {
+            params.builder.where(params.filter.column, '>', params.filter.value);
+        }
+        else if (params.filter.mode == 'lower' && !!params.filter.value) {
+            params.builder.where(params.filter.column, '<', params.filter.value);
+        }
+        else if (params.filter.mode == 'between' && !!params.filter.from && !!params.filter.to) {
+            params.builder.where(params.filter.column, '>', params.filter.from);
+            params.builder.where(params.filter.column, '<', params.filter.to);
+        }
+        return params.builder;
+    }
+    applySelectFilter(params) {
+        if (!!params.filter.values && params.filter.values.length > 0) {
+            if (params.filter.mode == 'equal') {
+                params.builder.where(b => {
+                    b.where(params.filter.column, '=', params.filter.values[0].value);
+                    for (let i = 1; i < params.filter.values.length; i += 1) {
+                        b.orWhere(params.filter.column, '=', params.filter.values[i].value);
+                    }
+                });
+            }
+            else {
+                params.builder.where(b => {
+                    for (let i = 0; i < params.filter.values.length; i += 1) {
+                        b.whereNot(params.filter.column, '=', params.filter.values[i].value);
+                    }
+                });
+            }
+        }
+        return params.builder;
+    }
+    applyBooleanFilter(params) {
+        if (params.filter.value !== undefined) {
+            params.builder.where(params.filter.column, '=', params.filter.value);
+        }
+        return params.builder;
+    }
 }

package/dist/utils/filters/modifiers/where.d.ts

@@ -16,7 +16,7 @@ type SimpleWhere = {
     logicalOperator?: 'and' | 'or' | 'andNot' | 'orNot';
     key: string;
     operator?: string;
-    value: string | number | Date;
+    value: string | number | Date | boolean;
 };
 type InWhere = {
     method: 'where';

package/dist/utils/filters/validator.d.ts

@@ -0,0 +1,4 @@
+import type { Filter } from "./filters";
+export default class Validator {
+    static isValid(filter?: Filter): boolean;
+}

package/dist/utils/filters/validator.js

@@ -0,0 +1,30 @@
+export default class Validator {
+    static isValid(filter) {
+        if (!filter)
+            return false;
+        else if (filter.type == 'string')
+            return !!filter.value;
+        else if (filter.type == 'date') {
+            if (filter.mode == 'between')
+                return !!filter.from && !!filter.to;
+            else
+                return !!filter.value;
+        }
+        else if (filter.type == 'multiString')
+            return !!filter.value;
+        else if (filter.type == 'number') {
+            if (filter.mode == 'between')
+                return filter.from != undefined && filter.to != undefined;
+            else
+                return filter.value != undefined;
+        }
+        else if (filter.type == 'select') {
+            return filter.values != undefined && filter.values.length > 0;
+        }
+        else if (filter.type == 'bool') {
+            return filter.value !== undefined;
+        }
+        else
+            return false;
+    }
+}

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@likable-hair/svelte",
   "description": "A Svelte component for likablehair",
-  "version": "3.0.20",
+  "version": "3.0.21",
   "scripts": {
+    "host": "vite --host",
     "dev": "vite dev",
     "build": "vite build && npm run package",
     "preview": "vite preview",