@likable-hair/svelte 3.1.11 → 3.1.13

package/dist/components/composed/forms/AsyncAutocomplete.svelte

@@ -3,7 +3,7 @@
 <script>import Autocomplete from "../../../components/simple/forms/Autocomplete.svelte";
 import debounceStore from "../../../stores/debounce";
 import { writable } from "svelte/store";
-export let items = [], values = [], multiple = false, searcher, placeholder = void 0, searchThreshold = 2, debounceTimeout = 500, searching = false, search = false, searchText = void 0, maxVisibleChips = void 0, menuOpened = false, mobileDrawer = false, closeOnSelect = false;
+export let items = [], values = [], multiple = false, searcher, placeholder = void 0, searchThreshold = 2, debounceTimeout = 500, searching = false, search = false, searchText = void 0, maxVisibleChips = void 0, menuOpened = false, mobileDrawer = false, closeOnSelect = false, disabled = false;
 const searchTextValue = writable(searchText);
 $:
   searchTextDebounce = debounceStore(searchTextValue, debounceTimeout);
@@ -40,6 +40,7 @@ $:
   bind:mobileDrawer
   bind:placeholder
   bind:closeOnSelect
+  bind:disabled
   searchFunction={() => true}
   on:change
 ></Autocomplete>

package/dist/components/composed/forms/AsyncAutocomplete.svelte.d.ts

@@ -19,6 +19,7 @@ declare const __propDef: {
         menuOpened?: boolean | undefined;
         mobileDrawer?: boolean | undefined;
         closeOnSelect?: boolean | undefined;
+        disabled?: boolean | undefined;
     };
     events: {
         change: CustomEvent<any>;

package/dist/components/simple/navigation/Chip.css

@@ -15,4 +15,5 @@
   --chip-default-outlined-focus-color: rgb(var(--global-color-primary-400));
   --chip-default-text-max-width: 200px;
   --chip-default-outlined-focus-box-shadow: 0px 0px 4px 2px rgba(var(--global-color-primary-400),0.1);
+  --chip-default-gap: 5px;
 }

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

@@ -155,7 +155,9 @@ function handleCloseClick(e) {
     margin-left: 10px;
   }
   .text {
-    display: inline-block;
+    display: flex;
+    align-items: center;
+    gap: var(--chip-gap, var(--chip-default-gap));
     vertical-align: middle;
     user-select: none;
     font-size: var(

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

@@ -1,6 +1,8 @@
 import type { JoinModifier } from "./modifiers/join";
 import type { WhereModifier, WhereFilterValue } from "./modifiers/where";
-export type Modifier = WhereModifier | JoinModifier;
+import type { SelectModifier } from "./modifiers/select";
+import type { FromModifier } from "./modifiers/from";
+export type Modifier = WhereModifier | JoinModifier | SelectModifier | FromModifier;
 export type JsonQuery = {
     modifiers: Modifier[];
 };
@@ -29,6 +31,20 @@ export default class Builder {
     orWhereColumn(key: string, operator: string, compareColumn: string): Builder;
     whereJsonSuperset(key: string, object: Object): Builder;
     orWhereJsonSuperset(key: string, object: Object): Builder;
+    whereIn(key: string, callback: (builder: Builder) => void): Builder;
+    whereIn(key: string, values: WhereFilterValue[]): Builder;
+    orWhereIn(key: string, callback: (builder: Builder) => void): Builder;
+    orWhereIn(key: string, values: WhereFilterValue[]): Builder;
+    notWhereIn(key: string, callback: (builder: Builder) => void): Builder;
+    notWhereIn(key: string, values: WhereFilterValue[]): Builder;
+    orNotWhereIn(key: string, callback: (builder: Builder) => void): Builder;
+    orNotWhereIn(key: string, values: WhereFilterValue[]): Builder;
+    private applyWhereInClause;
+    whereNull(key: string): Builder;
+    orWhereNull(key: string): Builder;
+    notWhereNull(key: string): Builder;
+    orNotWhereNull(key: string): Builder;
+    private applyWhereNullClause;
     private applyWhereClause;
     private applyWhereColumnClause;
     private applyWhereJsonSupersetClause;
@@ -37,6 +53,8 @@ export default class Builder {
     rightJoin(table: string, onCallback: (onBuilder: OnClauseBuilder) => void): this;
     private applyJoinClause;
     toJson(): JsonQuery;
+    select(fields: string | string[]): this;
+    from(from: string): this;
 }
 import type { JoinModifierOnClause } from "./modifiers/join";
 declare class OnClauseBuilder {

package/dist/utils/filters/builder.js

@@ -27,6 +27,62 @@ export default class Builder {
     orWhereJsonSuperset(first, second) {
         return this.applyWhereJsonSupersetClause('or', first, second);
     }
+    whereIn(key, second) {
+        return this.applyWhereInClause('and', key, second);
+    }
+    orWhereIn(key, second) {
+        return this.applyWhereInClause('or', key, second);
+    }
+    notWhereIn(key, second) {
+        return this.applyWhereInClause('andNot', key, second);
+    }
+    orNotWhereIn(key, second) {
+        return this.applyWhereInClause('orNot', key, second);
+    }
+    applyWhereInClause(logicalOperator, key, second) {
+        if (typeof second == 'function') {
+            let inBuilder = new Builder();
+            second(inBuilder);
+            this.modifiers.push({
+                method: 'where',
+                kind: 'inBuilder',
+                logicalOperator: logicalOperator,
+                key: key,
+                modifiers: inBuilder.modifiers
+            });
+        }
+        else {
+            this.modifiers.push({
+                method: 'where',
+                kind: 'in',
+                logicalOperator: logicalOperator,
+                key: key,
+                value: second
+            });
+        }
+        return this;
+    }
+    whereNull(key) {
+        return this.applyWhereNullClause('and', key);
+    }
+    orWhereNull(key) {
+        return this.applyWhereNullClause('or', key);
+    }
+    notWhereNull(key) {
+        return this.applyWhereNullClause('andNot', key);
+    }
+    orNotWhereNull(key) {
+        return this.applyWhereNullClause('orNot', key);
+    }
+    applyWhereNullClause(logicalOperator, key) {
+        this.modifiers.push({
+            method: 'where',
+            kind: 'null',
+            logicalOperator: logicalOperator,
+            key: key
+        });
+        return this;
+    }
     applyWhereClause(logicalOperator, first, second, third) {
         if (third !== undefined) {
             if (!!second && typeof first == 'string' && typeof second == 'string') {
@@ -48,7 +104,7 @@ export default class Builder {
                 });
             }
         }
-        else if (typeof first == 'string' && !!second) {
+        else if (typeof first == 'string' && second !== undefined) {
             this.modifiers.push({
                 method: 'where',
                 kind: 'simple',
@@ -135,6 +191,20 @@ export default class Builder {
             modifiers: this.modifiers
         };
     }
+    select(fields) {
+        this.modifiers.push({
+            method: 'select',
+            fields: fields
+        });
+        return this;
+    }
+    from(from) {
+        this.modifiers.push({
+            method: 'from',
+            from: from
+        });
+        return this;
+    }
 }
 class OnClauseBuilder {
     onClauses;

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

@@ -0,0 +1,4 @@
+export type FromModifier = {
+    method: 'from';
+    from: string;
+};

package/dist/utils/filters/modifiers/from.js

@@ -0,0 +1 @@
+export {};

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

@@ -16,11 +16,11 @@ type InnerJoinModifier = {
     table: string;
     on: JoinModifierOnClause[];
 };
-type LeftJoinJsonModifier = {
+type LeftJoinModifier = {
     method: 'join';
     kind: 'left';
     table: string;
     on: JoinModifierOnClause[];
 };
-export type JoinModifier = LeftJoinJsonModifier | InnerJoinModifier | RightJoinModifier;
+export type JoinModifier = LeftJoinModifier | InnerJoinModifier | RightJoinModifier;
 export {};

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

@@ -0,0 +1,4 @@
+export type SelectModifier = {
+    method: 'select';
+    fields: string | string[];
+};

package/dist/utils/filters/modifiers/select.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,9 +1,10 @@
+import type { Modifier } from "../builder";
 export type WhereFilterValue = string | number | Date | boolean;
 type GroupedWhere = {
     method: 'where';
     kind: 'grouped';
     logicalOperator?: 'and' | 'or' | 'andNot' | 'orNot';
-    children: (ObjectWhere | SimpleWhere | GroupedWhere | InWhere | ColumnWhere | WhereJsonSuperset)[];
+    children: (ObjectWhere | SimpleWhere | GroupedWhere | InWhere | ColumnWhere | JsonSupersetWhere | InBuilderWhere | NullWhere)[];
 };
 type ObjectWhere = {
     method: 'where';
@@ -17,7 +18,7 @@ type SimpleWhere = {
     logicalOperator?: 'and' | 'or' | 'andNot' | 'orNot';
     key: string;
     operator?: string;
-    value: WhereFilterValue | boolean;
+    value: WhereFilterValue;
 };
 type ColumnWhere = {
     method: 'where';
@@ -34,12 +35,25 @@ type InWhere = {
     key: string;
     value: (WhereFilterValue)[];
 };
-type WhereJsonSuperset = {
+type InBuilderWhere = {
+    method: 'where';
+    kind: 'inBuilder';
+    logicalOperator?: 'and' | 'or' | 'andNot' | 'orNot';
+    key: string;
+    modifiers: Modifier[];
+};
+type JsonSupersetWhere = {
     method: 'where';
     kind: 'jsonSuperset';
     logicalOperator?: 'and' | 'or' | 'andNot' | 'orNot';
     key: string;
     value: Object;
 };
-export type WhereModifier = SimpleWhere | ObjectWhere | GroupedWhere | InWhere | ColumnWhere | WhereJsonSuperset;
+type NullWhere = {
+    method: 'where';
+    kind: 'null';
+    logicalOperator?: 'and' | 'or' | 'andNot' | 'orNot';
+    key: string;
+};
+export type WhereModifier = SimpleWhere | ObjectWhere | GroupedWhere | InWhere | ColumnWhere | JsonSupersetWhere | InBuilderWhere | NullWhere;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likable-hair/svelte",
   "description": "A Svelte component for likablehair and others",
-  "version": "3.1.11",
+  "version": "3.1.13",
   "scripts": {
     "host": "vite --host",
     "dev": "vite dev",