@terrygonguet/utils 0.0.8 → 0.0.9

package/dist/functional.js

@@ -159,9 +159,13 @@ function w(t, e) {
 function $(t) {
   return t;
 }
+function O(t) {
+  return () => t;
+}
 export {
   y as Maybe,
   v as Result,
   N as compose,
+  O as constant,
   $ as identity
 };

package/dist/main.js

@@ -1,22 +1,55 @@
-function o(n, t, r) {
-  return Math.min(Math.max(n, t), r);
+import { constant as r } from "./functional.js";
+function s(n, t, e) {
+  return Math.min(Math.max(n, t), e);
 }
-function c(n, t, r) {
+function a(n, t, e) {
   try {
-    return JSON.parse(n, r);
+    return JSON.parse(n, e);
   } catch {
     return t;
   }
 }
-function f(...n) {
-  return function(t, r) {
-    for (const e of n)
-      r = e(t, r);
-    return r;
+function i(...n) {
+  return function(t, e) {
+    for (const o of n)
+      e = o(t, e);
+    return e;
   };
 }
+function u() {
+  const n = () => o, t = r(!1), e = r(!0), o = new Proxy(() => {
+  }, {
+    get: n,
+    set: n,
+    apply: n,
+    construct: n,
+    deleteProperty: e,
+    has: e,
+    preventExtensions: t,
+    defineProperty: t
+  });
+  return o;
+}
+function f() {
+}
+function p(n) {
+  throw new Error("This should never be called");
+}
+async function h(n) {
+  const e = new TextEncoder().encode(n);
+  return await crypto.subtle.digest("SHA-1", e);
+}
+function* d(n, t, e = 1) {
+  for (let o = n; o < t; o += e)
+    yield o;
+}
 export {
-  o as clamp,
-  f as composeJSONRevivers,
-  c as safeParse
+  s as clamp,
+  i as composeJSONRevivers,
+  u as createNoopProxy,
+  p as exhaustive,
+  h as hash,
+  f as noop,
+  d as range,
+  a as safeParse
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@terrygonguet/utils",
-	"version": "0.0.8",
+	"version": "0.0.9",
 	"type": "module",
 	"module": "./dist/main.js",
 	"author": {

package/src/functional/index.ts

@@ -5,3 +5,7 @@ export { default as compose } from "just-compose"
 export function identity<T>(value: T) {
 	return value
 }
+
+export function constant<T>(value: T) {
+	return () => value
+}

package/src/main.ts

@@ -1,3 +1,5 @@
+import { constant } from "./functional/index.ts"
+
 /**
  * Behaviour is undefined when max < min
  */
@@ -23,3 +25,39 @@ export function composeJSONRevivers(...revivers: JSONReviver[]): JSONReviver {
 		return value
 	}
 }
+
+export function createNoopProxy<T>() {
+	const noop = () => proxy
+	const no = constant(false)
+	const yes = constant(true)
+	const proxy: any = new Proxy(() => {}, {
+		get: noop,
+		set: noop,
+		apply: noop,
+		construct: noop,
+		deleteProperty: yes,
+		has: yes,
+		preventExtensions: no,
+		defineProperty: no,
+	})
+	return proxy as T
+}
+
+export function noop() {}
+
+export function exhaustive(_: never): never {
+	throw new Error("This should never be called")
+}
+
+export async function hash(message: string) {
+	const encoder = new TextEncoder()
+	const data = encoder.encode(message)
+	const hash = await crypto.subtle.digest("SHA-1", data)
+	return hash
+}
+
+export function* range(start: number, end: number, step = 1) {
+	for (let i = start; i < end; i += step) {
+		yield i
+	}
+}

package/types/functional/index.d.ts

@@ -2,3 +2,4 @@ export * from "./maybe.ts";
 export * from "./result.ts";
 export { default as compose } from "just-compose";
 export declare function identity<T>(value: T): T;
+export declare function constant<T>(value: T): () => T;

package/types/main.d.ts

@@ -5,4 +5,9 @@ export declare function clamp(value: number, min: number, max: number): number;
 type JSONReviver = (key: string, value: any) => any;
 export declare function safeParse<T>(str: string, defaultValue: T, reviver?: JSONReviver): any;
 export declare function composeJSONRevivers(...revivers: JSONReviver[]): JSONReviver;
+export declare function createNoopProxy<T>(): T;
+export declare function noop(): void;
+export declare function exhaustive(_: never): never;
+export declare function hash(message: string): Promise<ArrayBuffer>;
+export declare function range(start: number, end: number, step?: number): Generator<number, void, unknown>;
 export {};