@nomix-ai/nomix-harness 0.2.4 → 0.2.6

package/dist/kernel/cordis-plugin-timer/lib/types/index.js

@@ -0,0 +1,134 @@
+import { Service } from '../../../cordis/lib/index.js';
+/** Disposable timer helpers mixed into Cordis contexts. */
+export class TimerService extends Service {
+    constructor(ctx) {
+        super(ctx, 'timer');
+        ctx.mixin('timer', ['timeout', 'interval', 'throttle', 'debounce', 'setTimeout', 'setInterval']);
+    }
+    /** @deprecated use `ctx.timeout()` instead */
+    setTimeout(callback, delay) {
+        return this.timeout(callback, delay);
+    }
+    /** @deprecated use `ctx.interval()` instead */
+    setInterval(callback, delay) {
+        return this.interval(callback, delay);
+    }
+    timeout(...args) {
+        const callback = typeof args[0] === 'function' ? args.shift() : undefined;
+        const delay = args[0];
+        if (callback) {
+            const dispose = this.ctx.effect(() => {
+                const timer = setTimeout(() => {
+                    dispose();
+                    callback();
+                }, delay);
+                return () => clearTimeout(timer);
+            }, 'ctx.timeout()');
+            return dispose;
+        }
+        else {
+            const { promise, resolve, reject } = Promise.withResolvers();
+            const dispose = this.ctx.effect(() => {
+                const timer = setTimeout(resolve, delay);
+                return () => {
+                    clearTimeout(timer);
+                    reject(new Error('Context has been disposed'));
+                };
+            }, 'ctx.timeout()');
+            return promise.finally(dispose);
+        }
+    }
+    interval(...args) {
+        const callback = typeof args[0] === 'function' ? args.shift() : undefined;
+        const delay = args[0];
+        if (callback) {
+            return this.ctx.effect(() => {
+                const timer = setInterval(callback, delay);
+                return () => clearInterval(timer);
+            }, 'ctx.interval()');
+        }
+        else {
+            let done;
+            let nextTask;
+            const dispose = this.ctx.effect(() => {
+                const timer = setInterval(() => {
+                    nextTask?.resolve({ done: false, value: undefined });
+                }, delay);
+                return () => {
+                    clearInterval(timer);
+                    if (done)
+                        return;
+                    done = { kind: 'throw', reason: new Error('Context has been disposed') };
+                    nextTask?.reject(done.reason);
+                };
+            }, 'ctx.interval()');
+            return {
+                next: () => {
+                    if (!done)
+                        return (nextTask = Promise.withResolvers()).promise;
+                    if (done.kind === 'return')
+                        return Promise.resolve({ done: true, value: done.value });
+                    return Promise.reject(done.reason);
+                },
+                return: (value) => {
+                    if (!done)
+                        done = { kind: 'return', value };
+                    nextTask?.resolve({ done: true, value });
+                    dispose();
+                    return Promise.resolve({ done: true, value });
+                },
+                throw: (reason) => {
+                    if (!done)
+                        done = { kind: 'throw', reason };
+                    nextTask?.reject(reason);
+                    dispose();
+                    return Promise.resolve({ done: true, value: undefined });
+                },
+                [Symbol.asyncIterator]() {
+                    return this;
+                },
+            };
+        }
+    }
+    _schedule(label, trigger, isDisposed = false) {
+        let timer;
+        const dispose = this.ctx.effect(() => () => {
+            isDisposed = true;
+            clearTimeout(timer);
+        }, label);
+        const wrapper = (...args) => {
+            clearTimeout(timer);
+            timer = trigger(args, isDisposed);
+        };
+        wrapper.dispose = dispose;
+        return wrapper;
+    }
+    /** Return a throttled function whose timer is disposed with the current fiber. */
+    throttle(callback, delay, noTrailing) {
+        let lastCall = -Infinity;
+        const execute = (...args) => {
+            lastCall = Date.now();
+            callback(...args);
+        };
+        return this._schedule('ctx.throttle()', (args, isDisposed) => {
+            const now = Date.now();
+            const remaining = delay - now + lastCall;
+            if (remaining <= 0) {
+                execute(...args);
+            }
+            else if (!isDisposed) {
+                return setTimeout(execute, remaining, ...args);
+            }
+        }, noTrailing);
+    }
+    /** Return a debounced function whose timer is disposed with the current fiber. */
+    debounce(callback, delay) {
+        return this._schedule('ctx.debounce()', (args, isDisposed) => {
+            if (isDisposed)
+                return;
+            return setTimeout(callback, delay, ...args);
+        });
+    }
+}
+export default TimerService;
+//# sourceMappingURL=index.js.map

package/dist/kernel/cordis-plugin-timer/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@nomix-ai/cordis-plugin-timer",
+  "description": "Timer service for cordis",
+  "version": "1.1.3",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ditgaldev/nomix-harness.git",
+    "directory": "vendor/timer"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/types/**/*.d.ts",
+    "lib/types/**/*.d.ts.map",
+    "src"
+  ],
+  "author": "Shigma <shigma10826@gmail.com>",
+  "license": "MIT",
+  "peerDependencies": {
+    "@nomix-ai/cordis": "workspace:^"
+  },
+  "dependencies": {
+    "@nomix-ai/cosmokit": "workspace:^"
+  }
+}

package/dist/kernel/cosmokit/lib/index.js

@@ -0,0 +1,325 @@
+//#region lib/types/misc.js
+/** No-op callback returning `undefined` at runtime and `any` at type level. */
+function noop() {}
+/** Return true when a value is `null` or `undefined`. */
+function isNullable(value) {
+	return value === null || value === void 0;
+}
+/** Return true when a value is neither `null` nor `undefined`. */
+function isNonNullable(value) {
+	return !isNullable(value);
+}
+/** Return true for non-array object values. */
+function isPlainObject(data) {
+	return data && typeof data === "object" && !Array.isArray(data);
+}
+/** Filter object entries and return a new object. */
+function filterKeys(object, filter) {
+	return Object.fromEntries(Object.entries(object).filter(([key, value]) => filter(key, value)));
+}
+/** Map object values while preserving the original key set. */
+function mapValues(object, transform) {
+	return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transform(value, key)]));
+}
+/** Pick selected keys from an object, optionally including `undefined` values. */
+function pick(source, keys, forced) {
+	if (!keys) return { ...source };
+	const result = {};
+	for (const key of keys) if (forced || source[key] !== void 0) result[key] = source[key];
+	return result;
+}
+/** Omit selected keys from a shallow object copy. */
+function omit(source, keys) {
+	if (!keys) return { ...source };
+	const result = { ...source };
+	for (const key of keys) Reflect.deleteProperty(result, key);
+	return result;
+}
+/** Define a non-enumerable writable property and return the object. */
+function defineProperty(object, key, value) {
+	return Object.defineProperty(object, key, {
+		writable: true,
+		value,
+		enumerable: false
+	});
+}
+//#endregion
+//#region lib/types/array.js
+/** Return true when every item in `array2` is present in `array1`. */
+function contain(array1, array2) {
+	return array2.every((item) => array1.includes(item));
+}
+/** Return items that appear in both arrays. */
+function intersection(array1, array2) {
+	return array1.filter((item) => array2.includes(item));
+}
+/** Return items from `array1` that do not appear in `array2`. */
+function difference(array1, array2) {
+	return array1.filter((item) => !array2.includes(item));
+}
+/** Return the set-union of two arrays while preserving first occurrence order. */
+function union(array1, array2) {
+	return Array.from(new Set([...array1, ...array2]));
+}
+/** Remove duplicate values while preserving first occurrence order. */
+function deduplicate(array) {
+	return [...new Set(array)];
+}
+/** Remove one item from an array and report whether it was found. */
+function remove(list, item) {
+	const index = list?.indexOf(item);
+	if (index >= 0) {
+		list.splice(index, 1);
+		return true;
+	} else return false;
+}
+/** Normalize nullish, scalar, or array input to an array. */
+function makeArray(source) {
+	return Array.isArray(source) ? source : isNullable(source) ? [] : [source];
+}
+//#endregion
+//#region lib/types/types.js
+/** Test values using `instanceof` with a `toStringTag` fallback. */
+function is(type, value) {
+	if (arguments.length === 1) return (value) => is(type, value);
+	return type in globalThis && value instanceof globalThis[type] || Object.prototype.toString.call(value).slice(8, -1) === type;
+}
+function isArrayBufferLike(value) {
+	return is("ArrayBuffer", value) || is("SharedArrayBuffer", value);
+}
+function isArrayBufferSource(value) {
+	return isArrayBufferLike(value) || ArrayBuffer.isView(value);
+}
+/** Binary source detection and base64/hex conversion helpers. */
+var Binary;
+(function(Binary) {
+	Binary.is = isArrayBufferLike;
+	Binary.isSource = isArrayBufferSource;
+	function fromSource(source) {
+		if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+		else return source;
+	}
+	Binary.fromSource = fromSource;
+	function toBase64(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("base64");
+		let binary = "";
+		const bytes = new Uint8Array(source);
+		for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+		return btoa(binary);
+	}
+	Binary.toBase64 = toBase64;
+	function fromBase64(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "base64"));
+		return Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+	}
+	Binary.fromBase64 = fromBase64;
+	function toHex(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("hex");
+		return Array.from(new Uint8Array(source), (byte) => byte.toString(16).padStart(2, "0")).join("");
+	}
+	Binary.toHex = toHex;
+	function fromHex(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "hex"));
+		const hex = source.length % 2 === 0 ? source : source.slice(0, source.length - 1);
+		const buffer = [];
+		for (let i = 0; i < hex.length; i += 2) buffer.push(parseInt(`${hex[i]}${hex[i + 1]}`, 16));
+		return Uint8Array.from(buffer).buffer;
+	}
+	Binary.fromHex = fromHex;
+})(Binary || (Binary = {}));
+/** Decode a base64 string into binary data. */
+const base64ToArrayBuffer = Binary.fromBase64;
+/** Encode binary data as base64. */
+const arrayBufferToBase64 = Binary.toBase64;
+/** Decode a hex string into binary data. */
+const hexToArrayBuffer = Binary.fromHex;
+/** Encode binary data as hex. */
+const arrayBufferToHex = Binary.toHex;
+/** Deep-clone common JavaScript values while preserving prototypes and cycles. */
+function clone(source, refs = /* @__PURE__ */ new Map()) {
+	if (!source || typeof source !== "object") return source;
+	if (is("Date", source)) return new Date(source.valueOf());
+	if (is("RegExp", source)) return new RegExp(source.source, source.flags);
+	if (isArrayBufferLike(source)) return source.slice(0);
+	if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+	const cached = refs.get(source);
+	if (cached) return cached;
+	if (Array.isArray(source)) {
+		const result = [];
+		refs.set(source, result);
+		source.forEach((value, index) => {
+			result[index] = Reflect.apply(clone, null, [value, refs]);
+		});
+		return result;
+	}
+	const result = Object.create(Object.getPrototypeOf(source));
+	refs.set(source, result);
+	for (const key of Reflect.ownKeys(source)) {
+		const descriptor = { ...Reflect.getOwnPropertyDescriptor(source, key) };
+		if ("value" in descriptor) descriptor.value = Reflect.apply(clone, null, [descriptor.value, refs]);
+		Reflect.defineProperty(result, key, descriptor);
+	}
+	return result;
+}
+/** Deeply compare arrays, dates, regexps, buffers, and plain object fields. */
+function deepEqual(a, b, strict) {
+	if (a === b) return true;
+	if (!strict && isNullable(a) && isNullable(b)) return true;
+	if (typeof a !== typeof b) return false;
+	if (typeof a !== "object") return false;
+	if (!a || !b) return false;
+	function check(test, then) {
+		return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : void 0;
+	}
+	return check(Array.isArray, (a, b) => a.length === b.length && a.every((item, index) => deepEqual(item, b[index]))) ?? check(is("Date"), (a, b) => a.valueOf() === b.valueOf()) ?? check(is("RegExp"), (a, b) => a.source === b.source && a.flags === b.flags) ?? check(isArrayBufferLike, (a, b) => {
+		if (a.byteLength !== b.byteLength) return false;
+		const viewA = new Uint8Array(a);
+		const viewB = new Uint8Array(b);
+		for (let i = 0; i < viewA.length; i++) if (viewA[i] !== viewB[i]) return false;
+		return true;
+	}) ?? Object.keys({
+		...a,
+		...b
+	}).every((key) => deepEqual(a[key], b[key], strict));
+}
+//#endregion
+//#region lib/types/string.js
+/** Uppercase the first character of a string. */
+function capitalize(source) {
+	return source.charAt(0).toUpperCase() + source.slice(1);
+}
+/** Lowercase the first character of a string. */
+function uncapitalize(source) {
+	return source.charAt(0).toLowerCase() + source.slice(1);
+}
+/** Convert dash or underscore delimited text to camelCase. */
+function camelCase(source) {
+	return source.replace(/[_-][a-z]/g, (str) => str.slice(1).toUpperCase());
+}
+function tokenize(source, delimiters, delimiter) {
+	const output = [];
+	let state = 0;
+	for (let i = 0; i < source.length; i++) {
+		const code = source.charCodeAt(i);
+		if (code >= 65 && code <= 90) {
+			if (state === 1) {
+				const next = source.charCodeAt(i + 1);
+				if (next >= 97 && next <= 122) output.push(delimiter);
+				output.push(code + 32);
+			} else {
+				if (state !== 0) output.push(delimiter);
+				output.push(code + 32);
+			}
+			state = 1;
+		} else if (code >= 97 && code <= 122) {
+			output.push(code);
+			state = 2;
+		} else if (delimiters.includes(code)) {
+			if (state !== 0) output.push(delimiter);
+			state = 0;
+		} else output.push(code);
+	}
+	return String.fromCharCode(...output);
+}
+/** Convert text to dash-delimited parameter case. */
+function paramCase(source) {
+	return tokenize(source, [45, 95], 45);
+}
+/** Convert text to underscore-delimited snake case. */
+function snakeCase(source) {
+	return tokenize(source, [45, 95], 95);
+}
+/** Runtime alias for `camelCase`. */
+const camelize = camelCase;
+/** Runtime alias for `paramCase`. */
+const hyphenate = paramCase;
+/** Format a property key as a JavaScript member access suffix. */
+function formatProperty(key) {
+	if (typeof key !== "string") return `[${key.toString()}]`;
+	return /^[a-z_$][\w$]*$/i.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
+}
+/** Remove one trailing slash from a path string. */
+function trimSlash(source) {
+	return source.replace(/\/$/, "");
+}
+/** Ensure a path starts with `/` and has no trailing slash. */
+function sanitize(source) {
+	if (!source.startsWith("/")) source = "/" + source;
+	return trimSlash(source);
+}
+//#endregion
+//#region lib/types/time.js
+/** Time constants plus parsing and formatting helpers. */
+var Time;
+(function(Time) {
+	Time.millisecond = 1;
+	Time.second = 1e3;
+	Time.minute = Time.second * 60;
+	Time.hour = Time.minute * 60;
+	Time.day = Time.hour * 24;
+	Time.week = Time.day * 7;
+	let timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+	function setTimezoneOffset(offset) {
+		timezoneOffset = offset;
+	}
+	Time.setTimezoneOffset = setTimezoneOffset;
+	function getTimezoneOffset() {
+		return timezoneOffset;
+	}
+	Time.getTimezoneOffset = getTimezoneOffset;
+	function getDateNumber(date = /* @__PURE__ */ new Date(), offset) {
+		if (typeof date === "number") date = new Date(date);
+		if (offset === void 0) offset = timezoneOffset;
+		return Math.floor((date.valueOf() / Time.minute - offset) / 1440);
+	}
+	Time.getDateNumber = getDateNumber;
+	function fromDateNumber(value, offset) {
+		const date = new Date(value * Time.day);
+		if (offset === void 0) offset = timezoneOffset;
+		return new Date(+date + offset * Time.minute);
+	}
+	Time.fromDateNumber = fromDateNumber;
+	const numeric = /\d+(?:\.\d+)?/.source;
+	const timeRegExp = new RegExp(`^${[
+		"w(?:eek(?:s)?)?",
+		"d(?:ay(?:s)?)?",
+		"h(?:our(?:s)?)?",
+		"m(?:in(?:ute)?(?:s)?)?",
+		"s(?:ec(?:ond)?(?:s)?)?"
+	].map((unit) => `(${numeric}${unit})?`).join("")}$`);
+	function parseTime(source) {
+		const capture = timeRegExp.exec(source);
+		if (!capture) return 0;
+		return (parseFloat(capture[1]) * Time.week || 0) + (parseFloat(capture[2]) * Time.day || 0) + (parseFloat(capture[3]) * Time.hour || 0) + (parseFloat(capture[4]) * Time.minute || 0) + (parseFloat(capture[5]) * Time.second || 0);
+	}
+	Time.parseTime = parseTime;
+	function parseDate(date) {
+		const parsed = parseTime(date);
+		if (parsed) date = Date.now() + parsed;
+		else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${date}`;
+		else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).getFullYear()}-${date}`;
+		return date ? new Date(date) : /* @__PURE__ */ new Date();
+	}
+	Time.parseDate = parseDate;
+	function format(ms) {
+		const abs = Math.abs(ms);
+		if (abs >= Time.day - Time.hour / 2) return Math.round(ms / Time.day) + "d";
+		else if (abs >= Time.hour - Time.minute / 2) return Math.round(ms / Time.hour) + "h";
+		else if (abs >= Time.minute - Time.second / 2) return Math.round(ms / Time.minute) + "m";
+		else if (abs >= Time.second) return Math.round(ms / Time.second) + "s";
+		return ms + "ms";
+	}
+	Time.format = format;
+	function toDigits(source, length = 2) {
+		return source.toString().padStart(length, "0");
+	}
+	Time.toDigits = toDigits;
+	function template(template, time = /* @__PURE__ */ new Date()) {
+		return template.replace("yyyy", time.getFullYear().toString()).replace("yy", time.getFullYear().toString().slice(2)).replace("MM", toDigits(time.getMonth() + 1)).replace("dd", toDigits(time.getDate())).replace("hh", toDigits(time.getHours())).replace("mm", toDigits(time.getMinutes())).replace("ss", toDigits(time.getSeconds())).replace("SSS", toDigits(time.getMilliseconds(), 3));
+	}
+	Time.template = template;
+})(Time || (Time = {}));
+//#endregion
+export { Binary, Time, arrayBufferToBase64, arrayBufferToHex, base64ToArrayBuffer, camelCase, camelize, capitalize, clone, contain, deduplicate, deepEqual, defineProperty, difference, filterKeys, formatProperty, hexToArrayBuffer, hyphenate, intersection, is, isNonNullable, isNullable, isPlainObject, makeArray, mapValues, mapValues as valueMap, noop, omit, paramCase, pick, remove, sanitize, snakeCase, trimSlash, uncapitalize, union };

package/dist/kernel/cosmokit/lib/types/array.d.ts

@@ -0,0 +1,15 @@
+/** Return true when every item in `array2` is present in `array1`. */
+export declare function contain(array1: readonly any[], array2: readonly any[]): boolean;
+/** Return items that appear in both arrays. */
+export declare function intersection<T>(array1: readonly T[], array2: readonly T[]): T[];
+/** Return items from `array1` that do not appear in `array2`. */
+export declare function difference<S>(array1: readonly S[], array2: readonly any[]): S[];
+/** Return the set-union of two arrays while preserving first occurrence order. */
+export declare function union<T>(array1: readonly T[], array2: readonly T[]): T[];
+/** Remove duplicate values while preserving first occurrence order. */
+export declare function deduplicate<T>(array: readonly T[]): T[];
+/** Remove one item from an array and report whether it was found. */
+export declare function remove<T>(list: T[], item: T): boolean;
+/** Normalize nullish, scalar, or array input to an array. */
+export declare function makeArray<T>(source: null | undefined | T | T[]): T[];
+//# sourceMappingURL=array.d.ts.map

package/dist/kernel/cosmokit/lib/types/array.js

@@ -0,0 +1,37 @@
+import { isNullable } from "./misc.js";
+/** Return true when every item in `array2` is present in `array1`. */
+export function contain(array1, array2) {
+    return array2.every(item => array1.includes(item));
+}
+/** Return items that appear in both arrays. */
+export function intersection(array1, array2) {
+    return array1.filter(item => array2.includes(item));
+}
+/** Return items from `array1` that do not appear in `array2`. */
+export function difference(array1, array2) {
+    return array1.filter(item => !array2.includes(item));
+}
+/** Return the set-union of two arrays while preserving first occurrence order. */
+export function union(array1, array2) {
+    return Array.from(new Set([...array1, ...array2]));
+}
+/** Remove duplicate values while preserving first occurrence order. */
+export function deduplicate(array) {
+    return [...new Set(array)];
+}
+/** Remove one item from an array and report whether it was found. */
+export function remove(list, item) {
+    const index = list?.indexOf(item);
+    if (index >= 0) {
+        list.splice(index, 1);
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+/** Normalize nullish, scalar, or array input to an array. */
+export function makeArray(source) {
+    return Array.isArray(source) ? source : isNullable(source) ? [] : [source];
+}
+//# sourceMappingURL=array.js.map

package/dist/kernel/cosmokit/lib/types/index.d.ts

@@ -0,0 +1,11 @@
+/** Array set and normalization helpers. */
+export * from './array.ts';
+/** Runtime type, binary, clone, and equality helpers. */
+export * from './types.ts';
+/** Shared utility types and object helpers. */
+export * from './misc.ts';
+/** String case, path, and property formatting helpers. */
+export * from './string.ts';
+/** Time constants, parsing, and formatting helpers. */
+export * from './time.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/kernel/cosmokit/lib/types/index.js

@@ -0,0 +1,11 @@
+/** Array set and normalization helpers. */
+export * from "./array.js";
+/** Runtime type, binary, clone, and equality helpers. */
+export * from "./types.js";
+/** Shared utility types and object helpers. */
+export * from "./misc.js";
+/** String case, path, and property formatting helpers. */
+export * from "./string.js";
+/** Time constants, parsing, and formatting helpers. */
+export * from "./time.js";
+//# sourceMappingURL=index.js.map

package/dist/kernel/cosmokit/lib/types/misc.d.ts

@@ -0,0 +1,41 @@
+/** String/symbol keyed dictionary type. */
+export type Dict<T = any, K extends string | symbol = string> = {
+    [key in K]: T;
+};
+/** Safely read `T[K]`, returning `never` when `K` is not a key of `T`. */
+export type Get<T extends {}, K> = K extends keyof T ? T[K] : never;
+/** Conditional extraction helper with a configurable return type. */
+export type Extract<S, T, U = S> = S extends T ? U : never;
+/** Accept a value or an array, unless the value is already an array type. */
+export type MaybeArray<T> = [T] extends [unknown[]] ? T : T | T[];
+/** Wrap a value in `Promise`, preserving the resolved type of existing promises. */
+export type Promisify<T> = Promise<T extends Promise<infer S> ? S : T>;
+/** Accept a value or promise unless the value type is already promise-like. */
+export type Awaitable<T> = [T] extends [Promise<unknown>] ? T : T | Promise<T>;
+/** Convert a union type to an intersection type. */
+export type Intersect<U> = (U extends any ? (arg: U) => void : never) extends ((arg: infer I) => void) ? I : never;
+/** No-op callback returning `undefined` at runtime and `any` at type level. */
+export declare function noop(): any;
+/** Return true when a value is `null` or `undefined`. */
+export declare function isNullable(value: any): value is null | undefined | void;
+/** Return true when a value is neither `null` nor `undefined`. */
+export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
+/** Return true for non-array object values. */
+export declare function isPlainObject(data: any): any;
+/** Filter object entries with a key type guard. */
+export declare function filterKeys<T, K extends string, U extends K>(object: Dict<T, K>, filter: (key: K, value: T) => key is U): Dict<T, U>;
+/** Filter object entries with a boolean predicate. */
+export declare function filterKeys<T, K extends string>(object: Dict<T, K>, filter: (key: K, value: T) => boolean): Dict<T, K>;
+/** Map object values while preserving the original key set. */
+export declare function mapValues<U, T, K extends string>(object: Dict<T, K>, transform: (value: T, key: K) => U): Dict<U, K>;
+/** Alias for `mapValues`. */
+export { mapValues as valueMap };
+/** Pick selected keys from an object, optionally including `undefined` values. */
+export declare function pick<T extends object, K extends keyof T>(source: T, keys?: Iterable<K>, forced?: boolean): Pick<T, K>;
+/** Omit selected keys from a shallow object copy. */
+export declare function omit<T, K extends keyof T>(source: T, keys?: Iterable<K>): Omit<T, K>;
+/** Define a non-enumerable writable property with a typed key. */
+export declare function defineProperty<T, K extends keyof T>(object: T, key: K, value: T[K]): T;
+/** Define a non-enumerable writable property with an arbitrary key. */
+export declare function defineProperty<T, K extends keyof any>(object: T, key: K, value: any): T;
+//# sourceMappingURL=misc.d.ts.map

package/dist/kernel/cosmokit/lib/types/misc.js

@@ -0,0 +1,50 @@
+/** No-op callback returning `undefined` at runtime and `any` at type level. */
+export function noop() { }
+/** Return true when a value is `null` or `undefined`. */
+export function isNullable(value) {
+    return value === null || value === undefined;
+}
+/** Return true when a value is neither `null` nor `undefined`. */
+export function isNonNullable(value) {
+    return !isNullable(value);
+}
+/** Return true for non-array object values. */
+export function isPlainObject(data) {
+    return data && typeof data === 'object' && !Array.isArray(data);
+}
+/** Filter object entries and return a new object. */
+export function filterKeys(object, filter) {
+    return Object.fromEntries(Object.entries(object).filter(([key, value]) => filter(key, value)));
+}
+/** Map object values while preserving the original key set. */
+export function mapValues(object, transform) {
+    return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transform(value, key)]));
+}
+/** Alias for `mapValues`. */
+export { mapValues as valueMap };
+/** Pick selected keys from an object, optionally including `undefined` values. */
+export function pick(source, keys, forced) {
+    if (!keys)
+        return { ...source };
+    const result = {};
+    for (const key of keys) {
+        if (forced || source[key] !== undefined)
+            result[key] = source[key];
+    }
+    return result;
+}
+/** Omit selected keys from a shallow object copy. */
+export function omit(source, keys) {
+    if (!keys)
+        return { ...source };
+    const result = { ...source };
+    for (const key of keys) {
+        Reflect.deleteProperty(result, key);
+    }
+    return result;
+}
+/** Define a non-enumerable writable property and return the object. */
+export function defineProperty(object, key, value) {
+    return Object.defineProperty(object, key, { writable: true, value, enumerable: false });
+}
+//# sourceMappingURL=misc.js.map