npm - solid-new-bucket - Versions diffs - 0.0.1-d → 0.0.1 - Mend

solid-new-bucket 0.0.1-d → 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

package/app/index.tsx ADDED Viewed

@@ -0,0 +1,12 @@
+/* @refresh reload */
+import { render } from 'solid-js/web';
+const root = document.getElementById('root');
+if (import.meta.env.DEV && !(root instanceof HTMLElement)) {
+  throw new Error(
+    'Root element not found. Did you forget to add it to your index.html? Or maybe the id attribute got misspelled?',
+  );
+}
+render(() => 'app', root!);

package/index.html ADDED Viewed

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="theme-color" content="#000000" />
+    <link rel="shortcut icon" type="image/ico" href="/app/assets/favicon.ico" />
+    <title>Solid App</title>
+  </head>
+  <body>
+    <noscript>You need to enable JavaScript to run this app.</noscript>
+    <div id="root"></div>
+    <script src="/app/index.tsx" type="module"></script>
+  </body>
+</html>

package/package.json CHANGED Viewed

@@ -1,23 +1,16 @@
 {
   "name": "solid-new-bucket",
-  "version": "0.0.1d",
+  "version": "0.0.1",
   "description": "Better Signal API for SolidJS",
   "scripts": {
     "start": "vite",
     "dev": "vite",
-    "build": "tsup",
+    "build": "vite build",
     "serve": "vite preview"
   },
   "license": "GNU",
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
-  "files": [
-      "dist"
-  ],
   "devDependencies": {
     "solid-devtools": "^0.27.3",
-    "tsup": "^8.1.0",
     "typescript": "^5.1.3",
     "vite": "^4.3.9",
     "vite-plugin-solid": "^2.7.0"

package/src/arrayHelpers.ts ADDED Viewed

@@ -0,0 +1,48 @@
+/**
+ * Filter out and remove elements from array.
+ * @param arr array
+ * @param filter filter
+ * @returns new array
+ */
+export function removeElementsFromArray<T>(arr: T[], filter: (t: T) => boolean): T[] {
+  const idx: number[] = [];
+  arr.forEach((t, i) => {
+    if (filter(t)) {
+      idx.push(i);
+    }
+  });
+  return idx.map(i => arr.splice(i, 1)[0]);
+}
+/**
+ * Copy range or array.
+ * @param arr array
+ * @param start start pos
+ * @param end end pos
+ * @returns sub range of array
+ */
+export function copyOfRange<T>(arr: T[], start: number, end: number): T[] {
+  const r: T[] = [];
+  start = Math.max(0, start);
+  end = Math.min(arr.length, end);
+  for (let i = start; i < end; i++) {
+    r.push(arr[i]);
+  }
+  return r;
+}
+/**
+ * Find first element in array which passes test.
+ * @param arr array
+ * @param test test
+ * @returns index
+ */
+export function indexOf<T>(arr: T[], test: Func<T, boolean>) {
+  for (let i = 0; i < arr.length; i++) {
+    if (test(arr[i])) {
+      return i;
+    }
+  }
+  return -1;
+}

package/src/buckets.ts ADDED Viewed

@@ -0,0 +1,182 @@
+import { createSignal, Accessor, createMemo, SignalOptions, splitProps } from "solid-js";
+/**
+ * Stamped Bucket help to trigger rerendering after updating object without recreate new object.
+ * @returns StampedBucket<T>
+ */
+export function stampedBucket<T>(value: T, options?: {
+  beforeUpdate?: (value: T) => void;
+  afterUpdate?: (value: T) => void;
+  localStorageName?: string;
+}): StampedBucket<T> {
+  // load from local storage
+  if (options?.localStorageName) {
+    const raw = localStorage.getItem(options.localStorageName);
+    if (raw) {
+      value = JSON.parse(raw);
+    }
+  }
+  const [timestamp, setTimestamp] = createSignal(new Date().getTime());
+  const v: Accessor<StampedData<T>> = createMemo(() => {
+    return {
+      timestamp: timestamp(),
+      data: value,
+      markChanged() {
+        setTimestamp(new Date().getTime());
+      }
+    };
+  });
+  const setV = (newValue?: T) => {
+    if (newValue) {
+      value = newValue
+    }
+    setTimestamp(new Date().getTime())
+  };
+  const call = function(updater?: (v: T) => void) {
+    if (updater) {
+      options?.beforeUpdate?.(value)
+      updater(value)
+      // save to local storage
+      if (options?.localStorageName) {
+        localStorage.setItem(options.localStorageName, value ? JSON.stringify(value) : "")
+      }
+      setV();
+      options?.afterUpdate?.(value)
+    }
+    // add mapper function
+    (call as any).map = <O>(mapper: (v: T) => O) => {
+      return mapper(v().data);
+    }
+    // add markChanged function
+    (call as any).markChanged = () => {
+      setTimestamp(new Date().getTime())
+    }
+    (call as any).reset = (v: T) => {
+      setV(v)
+    }
+    return v().data
+  }
+  return call as any
+}
+function getFieldOfObject(o: any, paths: ObjectIndex[]) {
+  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: any, newValue: any, paths: ObjectIndex[]) {
+  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
+}
+export function asBucket<O, FieldType, DecadeType>(s: StampedBucket<O>, path: ObjectIndex[], mapper?: Mapper<FieldType, DecadeType>): Bucket<FieldType> {
+  const getField = (data: O) => {
+    let v = getFieldOfObject(data, path)
+    return mapper ? mapper.from?.(v) : v
+  }
+  const setField = (data: O, v: any) => {
+    if (mapper) {
+      v = mapper.to?.(v)
+    }
+    setFieldOfObject(data, v, path)
+  }
+  return (t) => {
+    if (t != undefined) {
+      s(data => {
+        if (typeof(t) === "function") {
+          const oldValue = getField(data)
+          // @ts-ignore
+          setField(data, t(oldValue))
+        } else {
+          setField(data, t)
+        }
+      })
+    }
+    return getField(s())
+  }
+}
+export function asAccessor<T, K extends (keyof T)>(v: T | Accessor<T>, k: K): Accessor<T[K]> {
+  return () => {
+    if (typeof(v) === "function") {
+      return (v as Function)()[k]
+    }
+    return v[k]
+  }
+}
+/**
+ * Create a bucket to track data.
+ * @param value value or Accessor of value
+ * @param options options
+ * @returns Bucket<T>
+ */
+export function bucket<T>(value: T | Accessor<T>, options?: {
+  useValueAsAccessor?: boolean
+  beforeUpdate?: (newValue: T) => void
+  afterUpdate?: (newValue: T) => void
+  localStorageName?: string;
+} & SignalOptions<T>): Bucket<T> {
+  if (options?.useValueAsAccessor && typeof(value) === "function") {
+    const [_, others] = splitProps(options, ["useValueAsAccessor"])
+    const memo = createMemo(() => bucket<T>((value as any)(), others))
+    return (t) => {
+      // @ts-ignore
+      return memo()(t)
+    }
+  }
+  const [local, others] = options && splitProps(options, ["beforeUpdate", "afterUpdate", "localStorageName"]) || [];
+  // load from local storage
+  if (local?.localStorageName) {
+    const raw = localStorage.getItem(local.localStorageName);
+    if (raw) {
+      value = JSON.parse(raw);
+    }
+  }
+  // @ts-ignore
+  const [v, setV] = createSignal<T>(value, others)
+  return (t) => {
+    if (t !== undefined) {
+      const newValue = setV((prev) => {
+        local?.beforeUpdate?.(prev);
+        if (typeof(t) === "function") {
+          return (t as Function)(prev);
+        } else {
+          return t;
+        }
+      });
+      // save to local storage
+      if (local?.localStorageName) {
+        localStorage.setItem(local.localStorageName, t ? JSON.stringify(t) : "");
+      }
+      local?.afterUpdate?.(newValue);
+      return newValue;
+    }
+    return v()
+  };
+}

package/src/checks.ts ADDED Viewed

@@ -0,0 +1,57 @@
+/**
+ * Check if array or string is not empty.
+ * @param v array of any, string or undefined
+ * @returns true if target is not empty
+ */
+export function isNotEmpty<T>(v?: T[]): boolean
+export function isNotEmpty(v?: string): boolean
+export function isNotEmpty(v: any) {
+  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
+}
+/**
+ * Check if value is number.
+ * @param v any
+ * @returns true if value is number
+ */
+export function isNumber(v: any) {
+  return typeof(v) === "number";
+}
+/**
+ * Compare two date string.
+ * @param a date 1
+ * @param b date 2
+ * @returns true if a is later than b
+ */
+export function compareDateString(a: string, b: string): number {
+  return Date.parse(a) - Date.parse(b);
+}
+/**
+ * Check whether there is an element in b exists in a as well.
+ * @param a array 1
+ * @param b array 2
+ * @returns boolean
+ */
+export function containsAny(a: any[], b: any[]) {
+  for (let i of a) {
+    for (let j of b) {
+      if (i === j) {
+        return true;
+      }
+    }
+  }
+  return false;
+}

package/src/conditionals.ts ADDED Viewed

@@ -0,0 +1,35 @@
+/**
+ * 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
+ */
+export function conditional<T>(condition: any, value: () => void): void;
+export function conditional<T>(condition: any, value: T, defaultValue?: T): T;
+export function conditional<T>(condition: any, value: Supplier<T>, defaultValue?: T): T;
+export function conditional(condition: any, value: any, defaultValue?: any) {
+  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 !== undefined && defaultValue !== null) {
+    return defaultValue
+  }
+}

package/src/converters.ts ADDED Viewed

@@ -0,0 +1,27 @@
+import { wrapDateNumber } from "./wrappers";
+/**
+ * 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
+ */
+export function parseTimestamp(timestamp: number, showTime?: boolean, showMilliseconds?: boolean) {
+  const date = new Date(timestamp);
+  // TODO: toLocaleString
+  // return date.toLocaleString(undefined, {
+  // });
+  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;
+}
+export function toCapital(v: string) {
+  return v.charAt(0).toUpperCase() + v.substring(1);
+}

package/src/functions.d.ts ADDED Viewed

@@ -0,0 +1,23 @@
+export {}
+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
+}

package/src/generators.ts ADDED Viewed

@@ -0,0 +1,24 @@
+/**
+ * Genereate a sequence.
+ * @param start start
+ * @param end end
+ * @param step step
+ * @returns array
+ */
+export function sequence(start: number, end: number, step: number = 1) {
+  const r = [];
+  for (let i = start; i < end; i += step) {
+    r.push(i);
+  }
+  return r;
+}
+/**
+ * Generate a array of size.
+ * @param size size
+ * @returns
+ */
+export function iterate(size: number) {
+  return Array.from(Array(size).keys())
+}

package/src/global.d.ts ADDED Viewed

@@ -0,0 +1,30 @@
+export { }
+declare global {
+  interface Mapper<A, B> {
+    to?(a: A): B;
+    from?(b: B): A;
+  }
+  type Bucket<T> = {
+    // (v?: T): T;
+    // (v: (prev: T) => T): T;
+    <U extends T>(v?: T): U;
+    <U extends T>(v: (prev: T) => U): U;
+  }
+  interface StampedBucketAction<T> {
+    map<O>(call: (v: T) => O): O
+    markChanged(): void
+    reset(v: T): void
+  }
+  type StampedBucket<T> = ((updater?: Consumer<T>) => T) & StampedBucketAction<T>;
+  interface StampedData<T> {
+    data: T
+    timestamp: number
+  }
+}

package/src/index.ts ADDED Viewed

@@ -0,0 +1,14 @@
+export * from "./arrayHelpers"
+export * from "./buckets"
+export * from "./checks"
+export * from "./converters"
+export * from "./generators"
+export * from "./others"
+export * from "./wrappers"
+export * from "./conditionals"
+declare global {
+  type ObjectIndex = string | number
+}

package/src/others.ts ADDED Viewed

@@ -0,0 +1,28 @@
+import { Context, useContext } from "solid-js";
+export function useCtx<T>(c: Context<T>): T {
+  const context = useContext(c);
+  if (!context) {
+    throw new Error("cannot find a " + JSON.stringify(c))
+  }
+  return context;
+}
+export function names(...v: (string | undefined)[]) {
+  return v.filter((name) => Boolean(name)).join(' ');
+}
+export function clone(obj: any) {
+  const type = typeof(obj);
+  switch (type) {
+    case 'object': {
+      let r: any = Array.isArray(obj) ? [] : {};
+      for (let key of Object.keys(obj)) {
+        r[key] = clone(obj[key]);
+      }
+      return r;
+    }
+    default:
+      return obj;
+  }
+}

package/src/wrappers.ts ADDED Viewed

@@ -0,0 +1,28 @@
+export function wrapDateNumber(v: number, bits: number = 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;
+}
+export function wrapString(v: any): string {
+  if (typeof(v) === "string") {
+    return v;
+  }
+  return v?.toString() || "";
+}
+export function wrapNumber(v: any) {
+  if (typeof(v) === "number") {
+    return v;
+  }
+  return 0;
+}

package/tsconfig.json ADDED Viewed

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "strictPropertyInitialization": false,
+    "esModuleInterop": true,
+    "jsx": "preserve",
+    "jsxImportSource": "solid-js",
+    "types": ["vite/client"],
+    "noEmit": true,
+    "isolatedModules": true,
+    "resolveJsonModule": true
+  }
+}

package/vite.config.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import { defineConfig } from 'vite';
+import solidPlugin from 'vite-plugin-solid';
+// import devtools from 'solid-devtools/vite';
+export default defineConfig({
+  plugins: [
+    /*
+    Uncomment the following line to enable solid-devtools.
+    For more info see https://github.com/thetarnav/solid-devtools/tree/main/packages/extension#readme
+    */
+    // devtools(),
+    solidPlugin(),
+  ],
+  server: {
+    port: 3000,
+  },
+  build: {
+    target: 'esnext',
+  },
+});