solid-new-bucket 0.0.1 → 0.0.2

package/dist/index.d.mts

@@ -0,0 +1,152 @@
+import { Accessor, SignalOptions, Context } from 'solid-js';
+
+/**
+ * Filter out and remove elements from array.
+ * @param arr array
+ * @param filter filter
+ * @returns new array
+ */
+declare function removeElementsFromArray<T>(arr: T[], filter: (t: T) => boolean): T[];
+/**
+ * Copy range or array.
+ * @param arr array
+ * @param start start pos
+ * @param end end pos
+ * @returns sub range of array
+ */
+declare function copyOfRange<T>(arr: T[], start: number, end: number): T[];
+/**
+ * Find first element in array which passes test.
+ * @param arr array
+ * @param test test
+ * @returns index
+ */
+declare function indexOf<T>(arr: T[], test: Func<T, boolean>): number;
+
+/**
+ * Stamped Bucket help to trigger rerendering after updating object without recreate new object.
+ * @returns StampedBucket<T>
+ */
+declare function stampedBucket<T>(value: T, options?: {
+    beforeUpdate?: (value: T) => void;
+    afterUpdate?: (value: T) => void;
+    localStorageName?: string;
+}): StampedBucket<T>;
+declare function asBucket<O, FieldType, DecadeType>(s: StampedBucket<O>, path: ObjectIndex[], mapper?: Mapper<FieldType, DecadeType>): Bucket<FieldType>;
+declare function asAccessor<T, K extends (keyof T)>(v: T | Accessor<T>, k: K): Accessor<T[K]>;
+/**
+ * Create a bucket to track data.
+ * @param value value or Accessor of value
+ * @param options options
+ * @returns Bucket<T>
+ */
+declare function bucket<T>(value: T | Accessor<T>, options?: {
+    useValueAsAccessor?: boolean;
+    beforeUpdate?: (newValue: T) => void;
+    afterUpdate?: (newValue: T) => void;
+    localStorageName?: string;
+} & SignalOptions<T>): Bucket<T>;
+
+/**
+ * Check if array or string is not empty.
+ * @param v array of any, string or undefined
+ * @returns true if target is not empty
+ */
+declare function isNotEmpty<T>(v?: T[]): boolean;
+declare function isNotEmpty(v?: string): boolean;
+/**
+ * Check if value is number.
+ * @param v any
+ * @returns true if value is number
+ */
+declare function isNumber(v: any): boolean;
+/**
+ * Compare two date string.
+ * @param a date 1
+ * @param b date 2
+ * @returns true if a is later than b
+ */
+declare function compareDateString(a: string, b: string): number;
+/**
+ * Check whether there is an element in b exists in a as well.
+ * @param a array 1
+ * @param b array 2
+ * @returns boolean
+ */
+declare function containsAny(a: any[], b: any[]): boolean;
+
+/**
+ * Parse and format timestamp from number to string.
+ * @param timestamp time
+ * @param showTime show only date if false
+ * @param showMilliseconds show ms if true
+ * @returns formatted string
+ */
+declare function parseTimestamp(timestamp: number, showTime?: boolean, showMilliseconds?: boolean): string;
+declare function toCapital(v: string): string;
+
+/**
+ * Genereate a sequence.
+ * @param start start
+ * @param end end
+ * @param step step
+ * @returns array
+ */
+declare function sequence(start: number, end: number, step?: number): number[];
+/**
+ * Generate a array of size.
+ * @param size size
+ * @returns
+ */
+declare function iterate(size: number): number[];
+
+declare function useCtx<T>(c: Context<T>): T;
+declare function names(...v: (string | undefined)[]): string;
+declare function clone(obj: any): any;
+
+declare function wrapDateNumber(v: number, bits?: number): string | number;
+declare function wrapString(v: any): string;
+declare function wrapNumber(v: any): number;
+
+/**
+ * Invoke function or return value if condition is true.
+ * @param condition any
+ * @param value function to be invoked or value to be return
+ * @param defaultValue fallback value, optional
+ */
+declare function conditional<T>(condition: any, value: () => void): void;
+declare function conditional<T>(condition: any, value: T, defaultValue?: T): T;
+declare function conditional<T>(condition: any, value: Supplier<T>, defaultValue?: T): T;
+
+declare global {
+    type Pair<K, V> = [key: K, value: V];
+    type Consumer<T> = (v: T) => void;
+    type BiConsumer<A, B> = (a: A, b: B) => void;
+    type TriConsumer<A, B, C> = (a: A, b: B, c: C) => void;
+    type Func<T, R> = (v: T) => R;
+    type BiFunc<A, B, R> = (a: A, b: B) => R;
+    type Callback = (...args: any) => any;
+    type Supplier<T> = () => T;
+    type Comparator<T> = (a: T, b: T) => -1 | 0 | 1;
+    type ObjectIndex = string | number;
+    interface Mapper<A, B> {
+        to?(a: A): B;
+        from?(b: B): A;
+    }
+    type Bucket<T> = {
+        <U extends T>(v?: T): U;
+        <U extends T>(v: (prev: T) => U): U;
+    };
+    type StampedBucket<T> = ((updater?: Consumer<T>) => T) & StampedBucketAction<T>;
+    interface StampedBucketAction<T> {
+        map<O>(call: (v: T) => O): O;
+        markChanged(): void;
+        reset(v: T): void;
+    }
+    interface StampedData<T> {
+        data: T;
+        timestamp: number;
+    }
+}
+
+export { asAccessor, asBucket, bucket, clone, compareDateString, conditional, containsAny, copyOfRange, indexOf, isNotEmpty, isNumber, iterate, names, parseTimestamp, removeElementsFromArray, sequence, stampedBucket, toCapital, useCtx, wrapDateNumber, wrapNumber, wrapString };

package/dist/index.d.ts

@@ -0,0 +1,152 @@
+import { Accessor, SignalOptions, Context } from 'solid-js';
+
+/**
+ * Filter out and remove elements from array.
+ * @param arr array
+ * @param filter filter
+ * @returns new array
+ */
+declare function removeElementsFromArray<T>(arr: T[], filter: (t: T) => boolean): T[];
+/**
+ * Copy range or array.
+ * @param arr array
+ * @param start start pos
+ * @param end end pos
+ * @returns sub range of array
+ */
+declare function copyOfRange<T>(arr: T[], start: number, end: number): T[];
+/**
+ * Find first element in array which passes test.
+ * @param arr array
+ * @param test test
+ * @returns index
+ */
+declare function indexOf<T>(arr: T[], test: Func<T, boolean>): number;
+
+/**
+ * Stamped Bucket help to trigger rerendering after updating object without recreate new object.
+ * @returns StampedBucket<T>
+ */
+declare function stampedBucket<T>(value: T, options?: {
+    beforeUpdate?: (value: T) => void;
+    afterUpdate?: (value: T) => void;
+    localStorageName?: string;
+}): StampedBucket<T>;
+declare function asBucket<O, FieldType, DecadeType>(s: StampedBucket<O>, path: ObjectIndex[], mapper?: Mapper<FieldType, DecadeType>): Bucket<FieldType>;
+declare function asAccessor<T, K extends (keyof T)>(v: T | Accessor<T>, k: K): Accessor<T[K]>;
+/**
+ * Create a bucket to track data.
+ * @param value value or Accessor of value
+ * @param options options
+ * @returns Bucket<T>
+ */
+declare function bucket<T>(value: T | Accessor<T>, options?: {
+    useValueAsAccessor?: boolean;
+    beforeUpdate?: (newValue: T) => void;
+    afterUpdate?: (newValue: T) => void;
+    localStorageName?: string;
+} & SignalOptions<T>): Bucket<T>;
+
+/**
+ * Check if array or string is not empty.
+ * @param v array of any, string or undefined
+ * @returns true if target is not empty
+ */
+declare function isNotEmpty<T>(v?: T[]): boolean;
+declare function isNotEmpty(v?: string): boolean;
+/**
+ * Check if value is number.
+ * @param v any
+ * @returns true if value is number
+ */
+declare function isNumber(v: any): boolean;
+/**
+ * Compare two date string.
+ * @param a date 1
+ * @param b date 2
+ * @returns true if a is later than b
+ */
+declare function compareDateString(a: string, b: string): number;
+/**
+ * Check whether there is an element in b exists in a as well.
+ * @param a array 1
+ * @param b array 2
+ * @returns boolean
+ */
+declare function containsAny(a: any[], b: any[]): boolean;
+
+/**
+ * Parse and format timestamp from number to string.
+ * @param timestamp time
+ * @param showTime show only date if false
+ * @param showMilliseconds show ms if true
+ * @returns formatted string
+ */
+declare function parseTimestamp(timestamp: number, showTime?: boolean, showMilliseconds?: boolean): string;
+declare function toCapital(v: string): string;
+
+/**
+ * Genereate a sequence.
+ * @param start start
+ * @param end end
+ * @param step step
+ * @returns array
+ */
+declare function sequence(start: number, end: number, step?: number): number[];
+/**
+ * Generate a array of size.
+ * @param size size
+ * @returns
+ */
+declare function iterate(size: number): number[];
+
+declare function useCtx<T>(c: Context<T>): T;
+declare function names(...v: (string | undefined)[]): string;
+declare function clone(obj: any): any;
+
+declare function wrapDateNumber(v: number, bits?: number): string | number;
+declare function wrapString(v: any): string;
+declare function wrapNumber(v: any): number;
+
+/**
+ * Invoke function or return value if condition is true.
+ * @param condition any
+ * @param value function to be invoked or value to be return
+ * @param defaultValue fallback value, optional
+ */
+declare function conditional<T>(condition: any, value: () => void): void;
+declare function conditional<T>(condition: any, value: T, defaultValue?: T): T;
+declare function conditional<T>(condition: any, value: Supplier<T>, defaultValue?: T): T;
+
+declare global {
+    type Pair<K, V> = [key: K, value: V];
+    type Consumer<T> = (v: T) => void;
+    type BiConsumer<A, B> = (a: A, b: B) => void;
+    type TriConsumer<A, B, C> = (a: A, b: B, c: C) => void;
+    type Func<T, R> = (v: T) => R;
+    type BiFunc<A, B, R> = (a: A, b: B) => R;
+    type Callback = (...args: any) => any;
+    type Supplier<T> = () => T;
+    type Comparator<T> = (a: T, b: T) => -1 | 0 | 1;
+    type ObjectIndex = string | number;
+    interface Mapper<A, B> {
+        to?(a: A): B;
+        from?(b: B): A;
+    }
+    type Bucket<T> = {
+        <U extends T>(v?: T): U;
+        <U extends T>(v: (prev: T) => U): U;
+    };
+    type StampedBucket<T> = ((updater?: Consumer<T>) => T) & StampedBucketAction<T>;
+    interface StampedBucketAction<T> {
+        map<O>(call: (v: T) => O): O;
+        markChanged(): void;
+        reset(v: T): void;
+    }
+    interface StampedData<T> {
+        data: T;
+        timestamp: number;
+    }
+}
+
+export { asAccessor, asBucket, bucket, clone, compareDateString, conditional, containsAny, copyOfRange, indexOf, isNotEmpty, isNumber, iterate, names, parseTimestamp, removeElementsFromArray, sequence, stampedBucket, toCapital, useCtx, wrapDateNumber, wrapNumber, wrapString };

package/dist/index.js

@@ -0,0 +1,371 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  asAccessor: () => asAccessor,
+  asBucket: () => asBucket,
+  bucket: () => bucket,
+  clone: () => clone,
+  compareDateString: () => compareDateString,
+  conditional: () => conditional,
+  containsAny: () => containsAny,
+  copyOfRange: () => copyOfRange,
+  indexOf: () => indexOf,
+  isNotEmpty: () => isNotEmpty,
+  isNumber: () => isNumber,
+  iterate: () => iterate,
+  names: () => names,
+  parseTimestamp: () => parseTimestamp,
+  removeElementsFromArray: () => removeElementsFromArray,
+  sequence: () => sequence,
+  stampedBucket: () => stampedBucket,
+  toCapital: () => toCapital,
+  useCtx: () => useCtx,
+  wrapDateNumber: () => wrapDateNumber,
+  wrapNumber: () => wrapNumber,
+  wrapString: () => wrapString
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/arrayHelpers.ts
+function removeElementsFromArray(arr, filter) {
+  const idx = [];
+  arr.forEach((t, i) => {
+    if (filter(t)) {
+      idx.push(i);
+    }
+  });
+  return idx.map((i) => arr.splice(i, 1)[0]);
+}
+function copyOfRange(arr, start, end) {
+  const r = [];
+  start = Math.max(0, start);
+  end = Math.min(arr.length, end);
+  for (let i = start; i < end; i++) {
+    r.push(arr[i]);
+  }
+  return r;
+}
+function indexOf(arr, test) {
+  for (let i = 0; i < arr.length; i++) {
+    if (test(arr[i])) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+// src/buckets.ts
+var import_solid_js = require("solid-js");
+function stampedBucket(value, options) {
+  if (options?.localStorageName) {
+    const raw = localStorage.getItem(options.localStorageName);
+    if (raw) {
+      value = JSON.parse(raw);
+    }
+  }
+  const [timestamp, setTimestamp] = (0, import_solid_js.createSignal)((/* @__PURE__ */ new Date()).getTime());
+  const v = (0, import_solid_js.createMemo)(() => {
+    return {
+      timestamp: timestamp(),
+      data: value,
+      markChanged() {
+        setTimestamp((/* @__PURE__ */ new Date()).getTime());
+      }
+    };
+  });
+  const setV = (newValue) => {
+    if (newValue) {
+      value = newValue;
+    }
+    setTimestamp((/* @__PURE__ */ new Date()).getTime());
+  };
+  const call = function(updater) {
+    if (updater) {
+      options?.beforeUpdate?.(value);
+      updater(value);
+      if (options?.localStorageName) {
+        localStorage.setItem(options.localStorageName, value ? JSON.stringify(value) : "");
+      }
+      setV();
+      options?.afterUpdate?.(value);
+    }
+    call.map = (mapper) => {
+      return mapper(v().data);
+    };
+    call.markChanged = () => {
+      setTimestamp((/* @__PURE__ */ new Date()).getTime());
+    };
+    call.reset = (v2) => {
+      setV(v2);
+    };
+    return v().data;
+  };
+  return call;
+}
+function getFieldOfObject(o, paths) {
+  for (let i = 0; i < paths.length - 1; i++) {
+    o = o[paths[i]];
+    if (!o) {
+      throw new Error(`cannot find ${paths.join(".")} in ${o}`);
+    }
+  }
+  return o[paths[paths.length - 1]];
+}
+function setFieldOfObject(o, newValue, paths) {
+  for (let i = 0; i < paths.length - 1; i++) {
+    o = o[paths[i]];
+    if (!o) {
+      throw new Error(`cannot find ${paths.join(".")} in ${o}`);
+    }
+  }
+  o[paths[paths.length - 1]] = newValue;
+}
+function asBucket(s, path, mapper) {
+  const getField = (data) => {
+    let v = getFieldOfObject(data, path);
+    return mapper ? mapper.from?.(v) : v;
+  };
+  const setField = (data, v) => {
+    if (mapper) {
+      v = mapper.to?.(v);
+    }
+    setFieldOfObject(data, v, path);
+  };
+  return (t) => {
+    if (t != void 0) {
+      s((data) => {
+        if (typeof t === "function") {
+          const oldValue = getField(data);
+          setField(data, t(oldValue));
+        } else {
+          setField(data, t);
+        }
+      });
+    }
+    return getField(s());
+  };
+}
+function asAccessor(v, k) {
+  return () => {
+    if (typeof v === "function") {
+      return v()[k];
+    }
+    return v[k];
+  };
+}
+function bucket(value, options) {
+  if (options?.useValueAsAccessor && typeof value === "function") {
+    const [_, others2] = (0, import_solid_js.splitProps)(options, ["useValueAsAccessor"]);
+    const memo = (0, import_solid_js.createMemo)(() => bucket(value(), others2));
+    return (t) => {
+      return memo()(t);
+    };
+  }
+  const [local, others] = options && (0, import_solid_js.splitProps)(options, ["beforeUpdate", "afterUpdate", "localStorageName"]) || [];
+  if (local?.localStorageName) {
+    const raw = localStorage.getItem(local.localStorageName);
+    if (raw) {
+      value = JSON.parse(raw);
+    }
+  }
+  const [v, setV] = (0, import_solid_js.createSignal)(value, others);
+  return (t) => {
+    if (t !== void 0) {
+      const newValue = setV((prev) => {
+        local?.beforeUpdate?.(prev);
+        if (typeof t === "function") {
+          return t(prev);
+        } else {
+          return t;
+        }
+      });
+      if (local?.localStorageName) {
+        localStorage.setItem(local.localStorageName, t ? JSON.stringify(t) : "");
+      }
+      local?.afterUpdate?.(newValue);
+      return newValue;
+    }
+    return v();
+  };
+}
+
+// src/checks.ts
+function isNotEmpty(v) {
+  if (!v) return false;
+  if (typeof v === "string") {
+    return v.length > 0;
+  }
+  if (typeof v === "object") {
+    if (Array.isArray(v)) {
+      return v.length > 0;
+    }
+    return Object.keys(v).length > 0;
+  }
+  return false;
+}
+function isNumber(v) {
+  return typeof v === "number";
+}
+function compareDateString(a, b) {
+  return Date.parse(a) - Date.parse(b);
+}
+function containsAny(a, b) {
+  for (let i of a) {
+    for (let j of b) {
+      if (i === j) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// src/wrappers.ts
+function wrapDateNumber(v, bits = 2) {
+  if (v == 0) {
+    return "0".repeat(bits);
+  }
+  let n = v;
+  while (n > 0) {
+    n = Math.floor(n / 10);
+    bits--;
+  }
+  return bits > 0 ? "0".repeat(bits) + v : v;
+}
+function wrapString(v) {
+  if (typeof v === "string") {
+    return v;
+  }
+  return v?.toString() || "";
+}
+function wrapNumber(v) {
+  if (typeof v === "number") {
+    return v;
+  }
+  return 0;
+}
+
+// src/converters.ts
+function parseTimestamp(timestamp, showTime, showMilliseconds) {
+  const date = new Date(timestamp);
+  let r = `${wrapDateNumber(date.getFullYear())}-${wrapDateNumber(date.getMonth() + 1)}-${wrapDateNumber(date.getDate())}`;
+  if (showTime) {
+    r += ` ${wrapDateNumber(date.getHours())}:${wrapDateNumber(date.getMinutes())}:${wrapDateNumber(date.getSeconds())}`;
+  }
+  if (showMilliseconds) {
+    r += `.${wrapDateNumber(date.getMilliseconds(), 3)}`;
+  }
+  ;
+  return r;
+}
+function toCapital(v) {
+  return v.charAt(0).toUpperCase() + v.substring(1);
+}
+
+// src/generators.ts
+function sequence(start, end, step = 1) {
+  const r = [];
+  for (let i = start; i < end; i += step) {
+    r.push(i);
+  }
+  return r;
+}
+function iterate(size) {
+  return Array.from(Array(size).keys());
+}
+
+// src/others.ts
+var import_solid_js2 = require("solid-js");
+function useCtx(c) {
+  const context = (0, import_solid_js2.useContext)(c);
+  if (!context) {
+    throw new Error("cannot find a " + JSON.stringify(c));
+  }
+  return context;
+}
+function names(...v) {
+  return v.filter((name) => Boolean(name)).join(" ");
+}
+function clone(obj) {
+  const type = typeof obj;
+  switch (type) {
+    case "object": {
+      let r = Array.isArray(obj) ? [] : {};
+      for (let key of Object.keys(obj)) {
+        r[key] = clone(obj[key]);
+      }
+      return r;
+    }
+    default:
+      return obj;
+  }
+}
+
+// src/conditionals.ts
+function conditional(condition, value, defaultValue) {
+  if (typeof value === "function") {
+    if (condition) {
+      const r = value();
+      if (r) {
+        return r;
+      }
+    }
+    return defaultValue;
+  }
+  if (typeof (value === "string")) {
+    return condition ? value : defaultValue || "";
+  }
+  if (typeof value === "number") {
+    return condition ? value : defaultValue || 0;
+  }
+  if (condition) {
+    return value;
+  } else if (defaultValue !== void 0 && defaultValue !== null) {
+    return defaultValue;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  asAccessor,
+  asBucket,
+  bucket,
+  clone,
+  compareDateString,
+  conditional,
+  containsAny,
+  copyOfRange,
+  indexOf,
+  isNotEmpty,
+  isNumber,
+  iterate,
+  names,
+  parseTimestamp,
+  removeElementsFromArray,
+  sequence,
+  stampedBucket,
+  toCapital,
+  useCtx,
+  wrapDateNumber,
+  wrapNumber,
+  wrapString
+});
+//# sourceMappingURL=index.js.map