@duplojs/lang 0.0.0

package/dist/common/instanceOf.mjs

@@ -0,0 +1,14 @@
+import { coalescing } from "../array/coalescing.mjs";
+//#region scripts/common/instanceOf.ts
+function instanceOf(...args) {
+	if (args.length === 1) {
+		const [valueConstructor] = args;
+		return (input) => instanceOf(input, valueConstructor);
+	}
+	const [input, valueConstructor] = args;
+	const valueConstructors = coalescing(valueConstructor);
+	for (const currentConstructor of valueConstructors) if (input instanceof currentConstructor) return true;
+	return false;
+}
+//#endregion
+export { instanceOf };

package/dist/common/interpolation.cjs

@@ -0,0 +1,6 @@
+//#region scripts/common/interpolation.ts
+function createInterpolation(template, _strict) {
+	return (interpolationValues) => interpolationValues ? template.replace(/\{([^}]*)\}/g, (_match, interpolationId) => interpolationValues[interpolationId]) : template;
+}
+//#endregion
+exports.createInterpolation = createInterpolation;

package/dist/common/interpolation.d.ts

@@ -0,0 +1,5 @@
+import { IsEqual } from './types';
+export type ExtractInterpolationId<GenericInput extends string> = GenericInput extends `${string}{${infer InferredInterpolationId}}${infer InferredEndValue}` ? InferredInterpolationId | ExtractInterpolationId<InferredEndValue> : never;
+export type ReplaceInterpolationIdByValues<GenericInput extends string, GenericInterpolationValues extends Record<string, string>> = GenericInput extends `${infer InferredStartValue}{${infer InferredInterpolationId}}${infer InferredEndValue}` ? InferredInterpolationId extends keyof GenericInterpolationValues ? `${InferredStartValue}${GenericInterpolationValues[InferredInterpolationId]}${ReplaceInterpolationIdByValues<InferredEndValue, GenericInterpolationValues>}` : `${InferredStartValue}${string}${ReplaceInterpolationIdByValues<InferredEndValue, GenericInterpolationValues>}` : GenericInput;
+export type CreateInterpolationContract<GenericInterpolationFunction extends (interpolationValues: Record<string, string>) => string> = ReplaceInterpolationIdByValues<ReturnType<GenericInterpolationFunction>, {}>;
+export declare function createInterpolation<GenericTemplate extends string, GenericInterpolationId extends ExtractInterpolationId<GenericTemplate>, GenericStrict extends boolean>(template: GenericTemplate, strict?: GenericStrict): <GenericInterpolationMapperValue extends string, GenericInterpolationValues extends Record<GenericInterpolationId, GenericInterpolationMapperValue>>(...[interpolationValues]: IsEqual<GenericInterpolationId, never> extends true ? [] : [interpolationValues: GenericInterpolationValues]) => IsEqual<GenericStrict, true> extends true ? ReplaceInterpolationIdByValues<GenericTemplate, GenericInterpolationValues> : string;

package/dist/common/interpolation.mjs

@@ -0,0 +1,6 @@
+//#region scripts/common/interpolation.ts
+function createInterpolation(template, _strict) {
+	return (interpolationValues) => interpolationValues ? template.replace(/\{([^}]*)\}/g, (_match, interpolationId) => interpolationValues[interpolationId]) : template;
+}
+//#endregion
+export { createInterpolation };

package/dist/common/isType.cjs

@@ -0,0 +1,25 @@
+//#region scripts/common/isType.ts
+const testTypeWrapper = {
+	string: (input) => typeof input === "string",
+	number: (input) => typeof input === "number",
+	bigint: (input) => typeof input === "bigint",
+	boolean: (input) => typeof input === "boolean",
+	function: (input) => typeof input === "function",
+	symbol: (input) => typeof input === "symbol",
+	undefined: (input) => typeof input === "undefined",
+	null: (input) => input === null,
+	array: (input) => input instanceof Array,
+	object: (input) => !!input && typeof input === "object" && !(input instanceof Array) && !(Symbol.iterator in input),
+	iterable: (input) => !!input && typeof input === "object" && Symbol.iterator in input && typeof input[Symbol.iterator] === "function",
+	asyncIterable: (input) => !!input && typeof input === "object" && Symbol.asyncIterator in input && typeof input[Symbol.asyncIterator] === "function"
+};
+function isType(...args) {
+	if (args.length === 1) {
+		const [type] = args;
+		return (input) => isType(input, type);
+	}
+	const [input, type] = args;
+	return testTypeWrapper[type](input);
+}
+//#endregion
+exports.isType = isType;

package/dist/common/isType.d.ts

@@ -0,0 +1,22 @@
+import { IsEqual, AnyFunction, AnyValue, BreakGenericLink } from './types';
+interface Type {
+    string: [string, never];
+    number: [number, never];
+    boolean: [boolean, never];
+    function: [AnyFunction, never];
+    bigint: [bigint, never];
+    undefined: [undefined, never];
+    null: [null, never];
+    symbol: [symbol, never];
+    object: [object, readonly any[] | AnyFunction | null];
+    iterable: [Iterable<any>, never];
+    asyncIterable: [AsyncIterable<any>, never];
+    array: [readonly any[], never];
+}
+type ComputeResult<GenericInput extends unknown, GenericTypeEntry extends Type[keyof Type]> = Exclude<Extract<GenericInput, GenericTypeEntry[0]>, GenericTypeEntry[1]>;
+type EligibleType<GenericInput extends unknown> = {
+    [Prop in keyof Type]: IsEqual<ComputeResult<GenericInput, Type[Prop]>, never> extends true ? never : Prop;
+}[keyof Type];
+export declare function isType<GenericInput extends AnyValue, GenericType extends EligibleType<GenericInput>>(type: GenericType): (input: GenericInput) => input is ComputeResult<BreakGenericLink<GenericInput>, Type[GenericType]>;
+export declare function isType<GenericInput extends AnyValue, GenericType extends EligibleType<GenericInput>>(input: GenericInput, type: GenericType): input is ComputeResult<GenericInput, Type[GenericType]>;
+export {};

package/dist/common/isType.mjs

@@ -0,0 +1,25 @@
+//#region scripts/common/isType.ts
+const testTypeWrapper = {
+	string: (input) => typeof input === "string",
+	number: (input) => typeof input === "number",
+	bigint: (input) => typeof input === "bigint",
+	boolean: (input) => typeof input === "boolean",
+	function: (input) => typeof input === "function",
+	symbol: (input) => typeof input === "symbol",
+	undefined: (input) => typeof input === "undefined",
+	null: (input) => input === null,
+	array: (input) => input instanceof Array,
+	object: (input) => !!input && typeof input === "object" && !(input instanceof Array) && !(Symbol.iterator in input),
+	iterable: (input) => !!input && typeof input === "object" && Symbol.iterator in input && typeof input[Symbol.iterator] === "function",
+	asyncIterable: (input) => !!input && typeof input === "object" && Symbol.asyncIterator in input && typeof input[Symbol.asyncIterator] === "function"
+};
+function isType(...args) {
+	if (args.length === 1) {
+		const [type] = args;
+		return (input) => isType(input, type);
+	}
+	const [input, type] = args;
+	return testTypeWrapper[type](input);
+}
+//#endregion
+export { isType };

package/dist/common/justExec.cjs

@@ -0,0 +1,6 @@
+//#region scripts/common/justExec.ts
+function justExec(theFunction) {
+	return theFunction();
+}
+//#endregion
+exports.justExec = justExec;

package/dist/common/justExec.d.ts

@@ -0,0 +1 @@
+export declare function justExec<GenericOutput extends unknown>(theFunction: () => GenericOutput): GenericOutput;

package/dist/common/justExec.mjs

@@ -0,0 +1,6 @@
+//#region scripts/common/justExec.ts
+function justExec(theFunction) {
+	return theFunction();
+}
+//#endregion
+export { justExec };

package/dist/common/justReturn.cjs

@@ -0,0 +1,11 @@
+//#region scripts/common/justReturn.ts
+function justReturn(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return () => justReturn(void 0, value);
+	}
+	const [, value] = args;
+	return value;
+}
+//#endregion
+exports.justReturn = justReturn;

package/dist/common/justReturn.d.ts

@@ -0,0 +1,3 @@
+import { AnyValue } from './types';
+export declare function justReturn<GenericInput extends unknown, GenericValue extends AnyValue>(value: GenericValue): (input: GenericInput) => GenericValue;
+export declare function justReturn<GenericInput extends unknown, GenericValue extends AnyValue>(input: GenericInput, value: GenericValue): GenericValue;

package/dist/common/justReturn.mjs

@@ -0,0 +1,11 @@
+//#region scripts/common/justReturn.ts
+function justReturn(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return () => justReturn(void 0, value);
+	}
+	const [, value] = args;
+	return value;
+}
+//#endregion
+export { justReturn };

package/dist/common/kind.cjs

@@ -0,0 +1,4 @@
+//#region scripts/common/kind.ts
+const createKind = require("../kind/namespace.cjs").createNamespace("DuplojsLangCommon");
+//#endregion
+exports.createKind = createKind;

package/dist/common/kind.d.ts

@@ -0,0 +1,2 @@
+import * as DKind from '../kind';
+export declare const createKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import('../string').ForbiddenContain<GenericName, DKind.ForbiddenKindNameCharacter>) => DKind.Handler<DKind.Definition<`@DuplojsLangCommon/${GenericName}`, GenericKindValue>>;

package/dist/common/kind.mjs

@@ -0,0 +1,5 @@
+import { createNamespace } from "../kind/namespace.mjs";
+//#region scripts/common/kind.ts
+const createKind = createNamespace("DuplojsLangCommon");
+//#endregion
+export { createKind };

package/dist/common/loop.cjs

@@ -0,0 +1,16 @@
+//#region scripts/common/loop.ts
+function loop(callback) {
+	let previousOutput = void 0;
+	for (let count = 0;; count++) {
+		const result = callback({
+			previousOutput,
+			count,
+			next: (data) => ({ "-nextData": data }),
+			exit: (data) => ({ "-exitData": data })
+		});
+		if ("-exitData" in result) return result["-exitData"];
+		previousOutput = result["-nextData"];
+	}
+}
+//#endregion
+exports.loop = loop;

package/dist/common/loop.d.ts

@@ -0,0 +1,15 @@
+import { AnyValue } from './types';
+interface LoopOutputExitResult<GenericOutput extends AnyValue> {
+    "-exitData": GenericOutput;
+}
+interface LoopOutputNextResult<GenericOutput extends AnyValue> {
+    "-nextData": GenericOutput;
+}
+export interface LoopParams<GenericNextOutput extends AnyValue> {
+    count: number;
+    previousOutput: GenericNextOutput | undefined;
+    next<GenericValue extends GenericNextOutput | undefined = undefined>(output?: GenericValue): LoopOutputNextResult<GenericValue>;
+    exit<GenericOutput extends AnyValue = undefined>(output?: GenericOutput): LoopOutputExitResult<GenericOutput>;
+}
+export declare function loop<GenericExitOutput extends AnyValue = undefined, GenericNextOutput extends AnyValue = undefined>(callback: (params: LoopParams<GenericNextOutput>) => LoopOutputNextResult<GenericNextOutput> | LoopOutputExitResult<GenericExitOutput>): GenericExitOutput;
+export {};

package/dist/common/loop.mjs

@@ -0,0 +1,16 @@
+//#region scripts/common/loop.ts
+function loop(callback) {
+	let previousOutput = void 0;
+	for (let count = 0;; count++) {
+		const result = callback({
+			previousOutput,
+			count,
+			next: (data) => ({ "-nextData": data }),
+			exit: (data) => ({ "-exitData": data })
+		});
+		if ("-exitData" in result) return result["-exitData"];
+		previousOutput = result["-nextData"];
+	}
+}
+//#endregion
+export { loop };

package/dist/common/memo.cjs

@@ -0,0 +1,10 @@
+//#region scripts/common/memo.ts
+function memo(theFunction) {
+	return { get value() {
+		const value = theFunction();
+		Object.defineProperty(this, "value", { value });
+		return value;
+	} };
+}
+//#endregion
+exports.memo = memo;

package/dist/common/memo.d.ts

@@ -0,0 +1,4 @@
+export interface Memoized<GenericValue extends unknown> {
+    readonly value: GenericValue;
+}
+export declare function memo<GenericOutput extends unknown>(theFunction: () => GenericOutput): Memoized<GenericOutput>;

package/dist/common/memo.mjs

@@ -0,0 +1,10 @@
+//#region scripts/common/memo.ts
+function memo(theFunction) {
+	return { get value() {
+		const value = theFunction();
+		Object.defineProperty(this, "value", { value });
+		return value;
+	} };
+}
+//#endregion
+export { memo };

package/dist/common/memoObject.cjs

@@ -0,0 +1,28 @@
+const require_memo = require("./memo.cjs");
+//#region scripts/common/memoObject.ts
+function memoObject(getter) {
+	const memoizedValue = require_memo.memo(getter);
+	let memoizedKeys = require_memo.memo(() => Object.keys(memoizedValue.value));
+	return new Proxy({}, {
+		get: (_target, prop) => memoizedValue.value[prop],
+		set: (_target, prop, value) => {
+			memoizedValue.value[prop] = value;
+			memoizedKeys = require_memo.memo(() => Object.keys(memoizedValue.value));
+			return true;
+		},
+		ownKeys() {
+			return memoizedKeys.value;
+		},
+		has(_target, prop) {
+			return memoizedKeys.value.includes(prop);
+		},
+		getOwnPropertyDescriptor() {
+			return {
+				enumerable: true,
+				configurable: true
+			};
+		}
+	});
+}
+//#endregion
+exports.memoObject = memoObject;

package/dist/common/memoObject.d.ts

@@ -0,0 +1 @@
+export declare function memoObject<GenericOutput extends object>(getter: () => GenericOutput): GenericOutput;

package/dist/common/memoObject.mjs

@@ -0,0 +1,28 @@
+import { memo } from "./memo.mjs";
+//#region scripts/common/memoObject.ts
+function memoObject(getter) {
+	const memoizedValue = memo(getter);
+	let memoizedKeys = memo(() => Object.keys(memoizedValue.value));
+	return new Proxy({}, {
+		get: (_target, prop) => memoizedValue.value[prop],
+		set: (_target, prop, value) => {
+			memoizedValue.value[prop] = value;
+			memoizedKeys = memo(() => Object.keys(memoizedValue.value));
+			return true;
+		},
+		ownKeys() {
+			return memoizedKeys.value;
+		},
+		has(_target, prop) {
+			return memoizedKeys.value.includes(prop);
+		},
+		getOwnPropertyDescriptor() {
+			return {
+				enumerable: true,
+				configurable: true
+			};
+		}
+	});
+}
+//#endregion
+export { memoObject };

package/dist/common/memoPromise.cjs

@@ -0,0 +1,19 @@
+const require_externalPromise = require("./externalPromise.cjs");
+const require_forward = require("./forward.cjs");
+//#region scripts/common/memoPromise.ts
+function memoPromise(getter) {
+	let externalPromise = require_forward.forward(void 0);
+	return { get value() {
+		if (externalPromise) return externalPromise.promise;
+		externalPromise = require_externalPromise.createExternalPromise();
+		const { resolve, reject } = externalPromise;
+		const promise = getter();
+		(promise instanceof Promise ? promise : Promise.resolve(promise)).then((result) => {
+			Object.defineProperty(this, "value", { value: result });
+			resolve(result);
+		}).catch(reject);
+		return externalPromise.promise;
+	} };
+}
+//#endregion
+exports.memoPromise = memoPromise;

package/dist/common/memoPromise.d.ts

@@ -0,0 +1,5 @@
+import { MaybePromise } from './types';
+export interface MemoizedPromise<GenericValue extends unknown> {
+    readonly value: MaybePromise<GenericValue>;
+}
+export declare function memoPromise<GenericOutput extends unknown>(getter: () => MaybePromise<GenericOutput>): MemoizedPromise<GenericOutput>;

package/dist/common/memoPromise.mjs

@@ -0,0 +1,19 @@
+import { createExternalPromise } from "./externalPromise.mjs";
+import { forward } from "./forward.mjs";
+//#region scripts/common/memoPromise.ts
+function memoPromise(getter) {
+	let externalPromise = forward(void 0);
+	return { get value() {
+		if (externalPromise) return externalPromise.promise;
+		externalPromise = createExternalPromise();
+		const { resolve, reject } = externalPromise;
+		const promise = getter();
+		(promise instanceof Promise ? promise : Promise.resolve(promise)).then((result) => {
+			Object.defineProperty(this, "value", { value: result });
+			resolve(result);
+		}).catch(reject);
+		return externalPromise.promise;
+	} };
+}
+//#endregion
+export { memoPromise };