@dative-gpi/foundation-shared-components 0.0.7 → 0.0.9

package/utils/index.ts

@@ -0,0 +1,5 @@
+export * from "./css";
+export * from "./icons";
+export * from "./levenshtein";
+export * from "./lexical";
+export * from "./sort";

package/utils/levenshtein.ts

@@ -0,0 +1,97 @@
+
+const InnerMin = (d0: number, d1: number, d2: number, bx: number, ay: number) => {
+    return d0 < d1 || d2 < d1 ? d0 > d2 ? d2 + 1 : d0 + 1 : bx === ay ? d1 : d1 + 1;
+};
+
+export const levenshteinDistance = (a: string, b: string) => {
+    if (a === b) {
+      return 0;
+    }
+
+    if (a.length > b.length) {
+      let tmp = a;
+      a = b;
+      b = tmp;
+    }
+
+    let la = a.length;
+    let lb = b.length;
+
+    while (la > 0 && (a.charCodeAt(la - 1) === b.charCodeAt(lb - 1))) {
+      la--;
+      lb--;
+    }
+
+    let offset = 0;
+
+    while (offset < la && (a.charCodeAt(offset) === b.charCodeAt(offset))) {
+      offset++;
+    }
+
+    la -= offset;
+    lb -= offset;
+
+    if (la === 0 || lb < 3) {
+      return lb;
+    }
+
+    let dd = 0;
+    let x = 0;
+    let y: number;
+    let d0: number;
+    let d1: number;
+    let d2: number;
+    let d3: number;
+    let dy: number;
+    let ay: number;
+    let bx0: number;
+    let bx1: number;
+    let bx2: number;
+    let bx3: number;
+
+    let vector: number[] = [];
+
+    for (y = 0; y < la; y++) {
+      vector.push(y + 1);
+      vector.push(a.charCodeAt(offset + y));
+    }
+
+    let len = vector.length - 1;
+
+    for (; x < lb - 3;) {
+      bx0 = b.charCodeAt(offset + (d0 = x));
+      bx1 = b.charCodeAt(offset + (d1 = x + 1));
+      bx2 = b.charCodeAt(offset + (d2 = x + 2));
+      bx3 = b.charCodeAt(offset + (d3 = x + 3));
+      dd = (x += 4);
+      for (y = 0; y < len; y += 2) {
+        dy = vector[y];
+        ay = vector[y + 1];
+        d0 = InnerMin(dy, d0, d1, bx0, ay);
+        d1 = InnerMin(d0, d1, d2, bx1, ay);
+        d2 = InnerMin(d1, d2, d3, bx2, ay);
+        dd = InnerMin(d2, d3, dd, bx3, ay);
+        vector[y] = dd;
+        d3 = d2;
+        d2 = d1;
+        d1 = d0;
+        d0 = dy;
+      }
+    }
+
+    for (; x < lb;) {
+      bx0 = b.charCodeAt(offset + (d0 = x));
+      dd = ++x;
+      for (y = 0; y < len; y += 2) {
+        dy = vector[y];
+        vector[y] = dd = InnerMin(dy, d0, dd, bx0, vector[y + 1]);
+        d0 = dy;
+      }
+    }
+
+    return dd;
+};
+
+export const sortByLevenshteinDistance = (a: string, b: string, ref: string) => {
+  return levenshteinDistance(a, ref) - levenshteinDistance(b, ref);
+};

package/utils/lexical.ts

@@ -0,0 +1,27 @@
+import { ElementNode, LexicalNode, RangeSelection, TextNode } from "lexical";
+import { $isAtNodeEnd } from "@lexical/selection";
+
+export const getSelectedNode = (selection: RangeSelection): ElementNode | TextNode => {
+  const anchor = selection.anchor;
+  const focus = selection.focus;
+  const anchorNode = selection.anchor.getNode();
+  const focusNode = selection.focus.getNode();
+  if (anchorNode === focusNode) {
+    return anchorNode;
+  }
+  const isBackward = selection.isBackward();
+  if (isBackward) {
+    return $isAtNodeEnd(focus) ? anchorNode : focusNode;
+  }
+  else {
+    return $isAtNodeEnd(anchor) ? focusNode : anchorNode;
+  }
+}
+
+export const getAncestor = <NodeType extends LexicalNode = LexicalNode>(node: LexicalNode, predicate: (ancestor: LexicalNode) => ancestor is NodeType) => {
+  let parent = node;
+  while (parent !== null && parent.getParent() !== null && !predicate(parent)) {
+    parent = parent.getParentOrThrow();
+  }
+  return predicate(parent) ? parent : null;
+}

package/utils/sort.ts

@@ -0,0 +1,9 @@
+export const alphanumericSort = (a: any, b: any) => {
+    if (typeof(a) !== 'string') {
+        a = JSON.stringify(a);
+    }
+    if (typeof(b) !== 'string') {
+        b = JSON.stringify(b);
+    }
+    return a.localeCompare(b, undefined, { numeric: true });
+}

package/composables/useTouch.ts

@@ -1,9 +0,0 @@
-export const useTouch = () => {
-    const isEnabled = (): boolean => {
-        return navigator.maxTouchPoints > 0;
-    };
-
-    return {
-        isEnabled
-    };
-}

package/models/FSTags.ts

@@ -1,8 +0,0 @@
-import { ColorBase } from "@dative-gpi/foundation-shared-components/themes";
-
-export interface FSTagItem {
-    label: string,
-    variant: "standard" | "full",
-    color: ColorBase,
-    editable: boolean
-}

package/models/FSTextFields.ts

@@ -1,17 +0,0 @@
-export const TextRules = {
-    required: (message: string) => (value: string) => !!value || (message ?? "Required"),
-    minLength: (length: number, message: string) => (value: string) => value.length >= length || (message ?? `Must be at least ${length} characters`),
-    maxLength: (length: number, message: string) => (value: string) => value.length <= length || (message ?? `Must be at most ${length} characters`),
-    email: (message: string) => (value: string) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) || (message ?? "Must be a valid email"),
-    digit: (message: string) => (value: string) => /(?=.*\d)/.test(value) || (message ?? "Must contain a digit"),
-    uppercase: (message: string) => (value: string) => /(?=.*[A-Z])/.test(value) || (message ?? "Must contain an uppercase letter"),
-    lowercase: (message: string) => (value: string) => /(?=.*[a-z])/.test(value) || (message ?? "Must contain a lowercase letter"),
-    special: (message: string) => (value: string) => /(?=.*[!@#$%^&*])/.test(value) || (message ?? "Must contain a special character")
-};
-
-export const NumberRules = {
-    required: (message: string) => (value: number) => !!value || (message ?? "Required"),
-    min: (min: number, message: string) => (value: number) => value >= min || (message ?? `Must be at least ${min}`),
-    max: (max: number, message: string) => (value: number) => value <= max || (message ?? `Must be at most ${max}`),
-    integer: (message: string) => (value: number) => Number.isInteger(value) || (message ?? "Must be an integer")
-};