@nice-code/util 0.2.5

package/README.md

@@ -0,0 +1 @@
+# @nice-code/utils

package/build/index.js

@@ -0,0 +1,145 @@
+// src/storage_adapter/storage_adapter.types.ts
+var EStorageAdapterType;
+((EStorageAdapterType2) => {
+  EStorageAdapterType2["string"] = "string";
+  EStorageAdapterType2["json"] = "json";
+})(EStorageAdapterType ||= {});
+
+// src/storage_adapter/StorageAdapter.ts
+class StorageAdapter {
+  implementation;
+  constructor(implementation) {
+    this.implementation = implementation;
+  }
+  async removeItem(key) {
+    await this.implementation.removeItem(key);
+  }
+  async setJson(key, value) {
+    if (this.implementation.type === "string" /* string */) {
+      await this.implementation.setItem(key, JSON.stringify(value));
+    } else {
+      await this.implementation.setItem(key, value);
+    }
+  }
+  async getJson(key) {
+    if (this.implementation.type === "string" /* string */) {
+      const val = await this.implementation.getItem(key);
+      if (val == null || val === "undefined" || val === "null") {
+        return;
+      }
+      return JSON.parse(val);
+    } else {
+      const val = await this.implementation.getItem(key);
+      if (val == null || val === "undefined" || val === "null") {
+        return;
+      }
+      return val;
+    }
+  }
+  async getJsonOrDef(key, defVal) {
+    if (this.implementation.type === "string" /* string */) {
+      const val2 = await this.implementation.getItem(key);
+      if (val2 == null || val2 === "undefined" || val2 === "null") {
+        return defVal;
+      }
+      return JSON.parse(val2);
+    }
+    const val = await this.implementation.getItem(key);
+    if (val == null || val === "undefined" || val === "null") {
+      return defVal;
+    }
+    return val;
+  }
+  createJsonGetterSetter(key) {
+    return {
+      get: () => this.getJson(key),
+      set: (value) => this.setJson(key, value)
+    };
+  }
+}
+// src/storage_adapter/typed_storage/createTypedStorage.ts
+function createTypedStorage({
+  storageAdapter
+}) {
+  const getJson = async (key) => {
+    return storageAdapter.getJson(key);
+  };
+  const getJsonOrDef = async (key, defVal) => {
+    return await storageAdapter.getJson(key) ?? defVal;
+  };
+  const setJson = async (key, val) => {
+    return storageAdapter.setJson(key, val);
+  };
+  const removeItem = async (key) => {
+    await storageAdapter.removeItem(key);
+  };
+  return {
+    getJson,
+    getJsonOrDef,
+    setJson,
+    removeItem
+  };
+}
+
+// src/storage_adapter/specific/browser/browser_storage.ts
+function createWebLocalStorageMethods(_localStorage) {
+  return {
+    type: "string" /* string */,
+    getItem: async (key) => _localStorage.getItem(key),
+    setItem: async (key, value) => {
+      _localStorage.setItem(key, value);
+    },
+    removeItem: async (key) => {
+      _localStorage.removeItem(key);
+    }
+  };
+}
+function createTypedWebLocalStorage(_localStorage) {
+  return createTypedStorage({
+    storageAdapter: new StorageAdapter(createWebLocalStorageMethods(_localStorage))
+  });
+}
+function createWebSessionStorageMethods(_sessionStorage) {
+  return {
+    type: "string" /* string */,
+    getItem: async (key) => _sessionStorage.getItem(key),
+    setItem: async (key, value) => {
+      _sessionStorage.setItem(key, value);
+    },
+    removeItem: async (key) => {
+      _sessionStorage.removeItem(key);
+    }
+  };
+}
+function createTypedWebSessionStorage(_sessionStorage) {
+  return createTypedStorage({
+    storageAdapter: new StorageAdapter(createWebSessionStorageMethods(_sessionStorage))
+  });
+}
+// src/storage_adapter/specific/durable_object/durable_object_storage.ts
+function createDurableObjectStorageMethods(durableObjectStorage) {
+  return {
+    type: "json" /* json */,
+    getItem: (key) => durableObjectStorage.get(key),
+    setItem: (key, value) => durableObjectStorage.put(key, value),
+    removeItem: async (key) => {
+      await durableObjectStorage.delete(key);
+    }
+  };
+}
+function createDurableObjectTypedStorage(durableObjectStorage) {
+  return createTypedStorage({
+    storageAdapter: new StorageAdapter(createDurableObjectStorageMethods(durableObjectStorage))
+  });
+}
+export {
+  createWebSessionStorageMethods,
+  createWebLocalStorageMethods,
+  createTypedWebSessionStorage,
+  createTypedWebLocalStorage,
+  createTypedStorage,
+  createDurableObjectTypedStorage,
+  createDurableObjectStorageMethods,
+  StorageAdapter,
+  EStorageAdapterType
+};

package/build/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./storage_adapter/StorageAdapter";
+export * from "./storage_adapter/specific/browser/browser_storage";
+export * from "./storage_adapter/specific/durable_object/durable_object_storage";
+export * from "./storage_adapter/storage_adapter.types";
+export * from "./storage_adapter/typed_storage/createTypedStorage";
+export * from "./typescript/special_typescript_types";

package/build/types/storage_adapter/StorageAdapter.d.ts

@@ -0,0 +1,10 @@
+import { type IStorageKeyGetterAndSetter, type TStorageAdapterMethods } from "./storage_adapter.types";
+export declare class StorageAdapter {
+    private implementation;
+    constructor(implementation: TStorageAdapterMethods);
+    removeItem(key: string): Promise<void>;
+    setJson(key: string, value: any): Promise<void>;
+    getJson<T>(key: string): Promise<T | undefined>;
+    getJsonOrDef<T>(key: string, defVal: T): Promise<T>;
+    createJsonGetterSetter<T>(key: string): IStorageKeyGetterAndSetter<T>;
+}

package/build/types/storage_adapter/specific/browser/browser_storage.d.ts

@@ -0,0 +1,6 @@
+import { type IStorageAdapterMethods_String } from "../../storage_adapter.types";
+import { type ITypedStorage } from "../../typed_storage/createTypedStorage";
+export declare function createWebLocalStorageMethods(_localStorage: typeof localStorage): IStorageAdapterMethods_String;
+export declare function createTypedWebLocalStorage<T extends Record<string, any>>(_localStorage: typeof localStorage): ITypedStorage<T>;
+export declare function createWebSessionStorageMethods(_sessionStorage: typeof sessionStorage): IStorageAdapterMethods_String;
+export declare function createTypedWebSessionStorage<T extends Record<string, any>>(_sessionStorage: typeof sessionStorage): ITypedStorage<T>;

package/build/types/storage_adapter/specific/durable_object/durable_object_storage.d.ts

@@ -0,0 +1,5 @@
+import { type IStorageAdapterMethods_Json } from "../../storage_adapter.types";
+import { type ITypedStorage } from "../../typed_storage/createTypedStorage";
+import type { IDurableObjectStorage } from "./durable_object_storage.types";
+export declare function createDurableObjectStorageMethods(durableObjectStorage: IDurableObjectStorage): IStorageAdapterMethods_Json;
+export declare function createDurableObjectTypedStorage<T extends Record<string, any>>(durableObjectStorage: IDurableObjectStorage): ITypedStorage<T>;

package/build/types/storage_adapter/specific/durable_object/durable_object_storage.types.d.ts

@@ -0,0 +1,18 @@
+interface DurableObjectGetOptions {
+    allowConcurrency?: boolean;
+    noCache?: boolean;
+}
+interface DurableObjectPutOptions {
+    allowConcurrency?: boolean;
+    allowUnconfirmed?: boolean;
+    noCache?: boolean;
+}
+export interface IDurableObjectStorage {
+    get<T = unknown>(key: string, options?: DurableObjectGetOptions): Promise<T | undefined>;
+    get<T = unknown>(keys: string[], options?: DurableObjectGetOptions): Promise<Map<string, T>>;
+    put<T>(key: string, value: T, options?: DurableObjectPutOptions): Promise<void>;
+    put<T>(entries: Record<string, T>, options?: DurableObjectPutOptions): Promise<void>;
+    delete(key: string, options?: DurableObjectPutOptions): Promise<boolean>;
+    delete(keys: string[], options?: DurableObjectPutOptions): Promise<number>;
+}
+export {};

package/build/types/storage_adapter/storage_adapter.types.d.ts

@@ -0,0 +1,21 @@
+export declare enum EStorageAdapterType {
+    string = "string",
+    json = "json"
+}
+export interface IStorageAdapterMethods_String {
+    type: EStorageAdapterType.string;
+    setItem: (key: string, value: string) => Promise<void>;
+    getItem: (key: string) => Promise<string | null | undefined>;
+    removeItem: (key: string) => Promise<void>;
+}
+export interface IStorageAdapterMethods_Json {
+    type: EStorageAdapterType.json;
+    setItem: <T>(key: string, value: T) => Promise<void>;
+    getItem: <T>(key: string) => Promise<T | null | undefined>;
+    removeItem: (key: string) => Promise<void>;
+}
+export type TStorageAdapterMethods = IStorageAdapterMethods_String | IStorageAdapterMethods_Json;
+export interface IStorageKeyGetterAndSetter<T> {
+    get: () => Promise<T | undefined>;
+    set: (value: T) => Promise<void>;
+}

package/build/types/storage_adapter/typed_storage/createTypedStorage.d.ts

@@ -0,0 +1,13 @@
+import type { StringKeys } from "../../typescript/special_typescript_types";
+import type { StorageAdapter } from "../StorageAdapter";
+export interface ITypedStorage<T extends Record<string, any>> {
+    getJson<K extends StringKeys<T>>(key: K): Promise<T[K] | undefined>;
+    getJsonOrDef<K extends StringKeys<T>>(key: K, defVal: T[K]): Promise<T[K]>;
+    setJson<K extends StringKeys<T>>(key: K, val: T[K]): Promise<void>;
+    removeItem<K extends StringKeys<T>>(key: K): Promise<void>;
+}
+interface ITypedStorage_Create_Input {
+    storageAdapter: StorageAdapter;
+}
+export declare function createTypedStorage<T extends Record<string, any>>({ storageAdapter, }: ITypedStorage_Create_Input): ITypedStorage<T>;
+export {};

package/build/types/typescript/special_typescript_types.d.ts

@@ -0,0 +1 @@
+export type StringKeys<T> = keyof T & string;

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@nice-code/util",
+  "version": "0.2.5",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./build/types/index.d.ts",
+      "import": "./build/index.js"
+    }
+  },
+  "files": [
+    "build",
+    "package.json",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "type-check": "bunx tsc --noEmit",
+    "type-check-watch": "bunx tsc --noEmit --watch",
+    "clean-build": "bunx rimraf build",
+    "vitest": "vitest --typecheck",
+    "vitest-agent": "vitest --typecheck --reporter=agent",
+    "build": "bun run clean-build && bun run build.ts && bun run build-types",
+    "build-watch": "bun run clean-build && bun run build.ts --watch && bun run build-types --watch",
+    "build-types": "tsc --project tsconfig.build.json"
+  },
+  "dependencies": {
+    "nanoid": "^5.1.9"
+  },
+  "devDependencies": {},
+  "peerDependencies": {
+    "@tanstack/react-query": "^5.100.3",
+    "react": ">=18",
+    "valibot": "^1.3.1",
+    "wrangler": "4.94.0"
+  },
+  "peerDependenciesMeta": {
+    "wrangler": {
+      "optional": true
+    }
+  }
+}