@duplojs/server 0.0.0-stage → 0.1.0-beta.1

package/dist/command/options/defaults/array.mjs

@@ -0,0 +1,29 @@
+import { codecsString } from "../../../dataStructure/common/codec/defaults/string.mjs";
+import { createKind } from "../../kind.mjs";
+import { constructOption } from "../base.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DString from "@duplojs/lang/string";
+//#region scripts/command/options/defaults/array.ts
+const defaultSeparator = ",";
+const arrayOptionKind = createKind("command-array-option");
+const createArrayOption = constructOption(arrayOptionKind, ({ init }) => (name, dataStructure, params) => init(name, async (self, value, error) => {
+	if (value === null && self.required === true) return error.addRequiredOptionIssue(self.name);
+	if (value === null) return;
+	if (value === void 0) return error.addRequiredOptionValueIssue(self.name);
+	const result = await self.dataStructure.asyncDecode(codecsString, DString.split(value, self.separator));
+	if (DEither.isLeft(result)) return error.addDataStructureOptionIssue(self.name, value, DEither.unwrapLeft(result));
+	return DEither.unwrapRight(result);
+}, {
+	description: params?.description ?? null,
+	aliases: params?.aliases ?? []
+}, {
+	dataStructure: DCommon.justExec(() => DCommon.pipe(dataStructure, DDataStructure.array, (dataStructure) => params?.min !== void 0 ? dataStructure.addConstraint(DDataStructure.minElements(params.min)) : dataStructure, (dataStructure) => params?.max !== void 0 ? dataStructure.addConstraint(DDataStructure.maxElements(params.max)) : dataStructure)),
+	required: params?.required ?? false,
+	min: params?.min,
+	max: params?.max,
+	separator: params?.separator ?? defaultSeparator
+}));
+//#endregion
+export { arrayOptionKind, createArrayOption };

package/dist/command/options/defaults/boolean.cjs

@@ -0,0 +1,14 @@
+const require_kind = require("../../kind.cjs");
+const require_base = require("../base.cjs");
+//#region scripts/command/options/defaults/boolean.ts
+const booleanOptionKind = require_kind.createKind("command-boolean-option");
+const createBooleanOption = require_base.constructOption(booleanOptionKind, ({ init }) => (name, params) => init(name, (self, value, error) => {
+	if (typeof value === "string") return error.addUnexpectedOptionValueIssue(self.name, value);
+	return value !== null;
+}, {
+	description: params?.description ?? null,
+	aliases: params?.aliases ?? []
+}));
+//#endregion
+exports.booleanOptionKind = booleanOptionKind;
+exports.createBooleanOption = createBooleanOption;

package/dist/command/options/defaults/boolean.d.ts

@@ -0,0 +1,11 @@
+import { Option } from '../base';
+import type * as DCommon from "@duplojs/lang/common";
+import type * as DKind from "@duplojs/lang/kind";
+export declare const booleanOptionKind: DKind.Handler<DKind.Definition<"@DuplojsServerCommand/command-boolean-option", unknown>>;
+export interface BooleanOption<GenericName extends string = string> extends DCommon.Forward<Option<GenericName, boolean> & DKind.Kind<typeof booleanOptionKind>> {
+}
+export interface CreateBooleanOptionParams {
+    description?: string;
+    aliases?: readonly string[];
+}
+export declare const createBooleanOption: <GenericName extends string>(name: GenericName, params?: CreateBooleanOptionParams) => NoInfer<BooleanOption<GenericName>>;

package/dist/command/options/defaults/boolean.mjs

@@ -0,0 +1,13 @@
+import { createKind } from "../../kind.mjs";
+import { constructOption } from "../base.mjs";
+//#region scripts/command/options/defaults/boolean.ts
+const booleanOptionKind = createKind("command-boolean-option");
+const createBooleanOption = constructOption(booleanOptionKind, ({ init }) => (name, params) => init(name, (self, value, error) => {
+	if (typeof value === "string") return error.addUnexpectedOptionValueIssue(self.name, value);
+	return value !== null;
+}, {
+	description: params?.description ?? null,
+	aliases: params?.aliases ?? []
+}));
+//#endregion
+export { booleanOptionKind, createBooleanOption };

package/dist/command/options/defaults/index.d.ts

@@ -0,0 +1,3 @@
+export * from './array';
+export * from './boolean';
+export * from './simple';

package/dist/command/options/defaults/simple.cjs

@@ -0,0 +1,25 @@
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
+const require_string = require("../../../dataStructure/common/codec/defaults/string.cjs");
+const require_kind = require("../../kind.cjs");
+const require_base = require("../base.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+//#region scripts/command/options/defaults/simple.ts
+const simpleOptionKind = require_kind.createKind("command-simple-option");
+const createOption = require_base.constructOption(simpleOptionKind, ({ init }) => (name, dataStructure, params) => init(name, async (self, value, error) => {
+	if (value === null && self.required === true) return error.addRequiredOptionIssue(self.name);
+	if (value === null) return;
+	if (value === void 0) return error.addRequiredOptionValueIssue(self.name);
+	const result = await self.dataStructure.asyncDecode(require_string.codecsString, value);
+	if (_duplojs_lang_either.isLeft(result)) return error.addDataStructureOptionIssue(self.name, value, _duplojs_lang_either.unwrapLeft(result));
+	return _duplojs_lang_either.unwrapRight(result);
+}, {
+	description: params?.description ?? null,
+	aliases: params?.aliases ?? []
+}, {
+	dataStructure,
+	required: params?.required ?? false
+}));
+//#endregion
+exports.createOption = createOption;
+exports.simpleOptionKind = simpleOptionKind;

package/dist/command/options/defaults/simple.d.ts

@@ -0,0 +1,16 @@
+import { Option } from '../base';
+import { EligibleType } from '../../types';
+import type * as DCommon from "@duplojs/lang/common";
+import type * as DKind from "@duplojs/lang/kind";
+import type * as DDataStructure from "@duplojs/lang/dataStructure";
+export declare const simpleOptionKind: DKind.Handler<DKind.Definition<"@DuplojsServerCommand/command-simple-option", unknown>>;
+export interface SimpleOption<GenericName extends string = string, GenericValue extends EligibleType = EligibleType> extends DCommon.Forward<Option<GenericName, GenericValue> & DKind.Kind<typeof simpleOptionKind>> {
+    readonly dataStructure: DDataStructure.Structure<GenericValue>;
+    readonly required: boolean;
+}
+export interface CreateSimpleOptionParams {
+    description?: string;
+    aliases?: readonly string[];
+    required?: boolean;
+}
+export declare const createOption: <GenericName extends string, GenericStructure extends DDataStructure.Structure<EligibleType>, GenericValue extends DDataStructure.StructureValue<GenericStructure>, const GenericParams extends CreateSimpleOptionParams = {}>(name: GenericName, dataStructure: GenericStructure, params?: GenericParams & CreateSimpleOptionParams) => SimpleOption<GenericName, (GenericValue | (DCommon.IsEqual<GenericParams["required"], true> extends true ? never : undefined))>;

package/dist/command/options/defaults/simple.mjs

@@ -0,0 +1,22 @@
+import { codecsString } from "../../../dataStructure/common/codec/defaults/string.mjs";
+import { createKind } from "../../kind.mjs";
+import { constructOption } from "../base.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/command/options/defaults/simple.ts
+const simpleOptionKind = createKind("command-simple-option");
+const createOption = constructOption(simpleOptionKind, ({ init }) => (name, dataStructure, params) => init(name, async (self, value, error) => {
+	if (value === null && self.required === true) return error.addRequiredOptionIssue(self.name);
+	if (value === null) return;
+	if (value === void 0) return error.addRequiredOptionValueIssue(self.name);
+	const result = await self.dataStructure.asyncDecode(codecsString, value);
+	if (DEither.isLeft(result)) return error.addDataStructureOptionIssue(self.name, value, DEither.unwrapLeft(result));
+	return DEither.unwrapRight(result);
+}, {
+	description: params?.description ?? null,
+	aliases: params?.aliases ?? []
+}, {
+	dataStructure,
+	required: params?.required ?? false
+}));
+//#endregion
+export { createOption, simpleOptionKind };

package/dist/command/options/identifier.cjs

@@ -0,0 +1,7 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+let _duplojs_lang_kind = require("@duplojs/lang/kind");
+_duplojs_lang_kind = require_runtime.__toESM(_duplojs_lang_kind, 1);
+//#region scripts/command/options/identifier.ts
+const optionIdentifier = _duplojs_lang_kind.createKindIdentifier();
+//#endregion
+exports.optionIdentifier = optionIdentifier;

package/dist/command/options/identifier.d.ts

@@ -0,0 +1,4 @@
+import { Option } from './base';
+import { Options } from './types';
+import * as DKind from "@duplojs/lang/kind";
+export declare const optionIdentifier: DKind.KindIdentifier<Option<string, unknown>, Options>;

package/dist/command/options/identifier.mjs

@@ -0,0 +1,5 @@
+import * as DKind from "@duplojs/lang/kind";
+//#region scripts/command/options/identifier.ts
+const optionIdentifier = DKind.createKindIdentifier();
+//#endregion
+export { optionIdentifier };

package/dist/command/options/index.d.ts

@@ -0,0 +1,4 @@
+export * from './base';
+export * from './defaults';
+export * from './identifier';
+export type * from './types';

package/dist/command/options/types/index.d.ts

@@ -0,0 +1 @@
+export type * from './options';

package/dist/command/options/types/options.d.ts

@@ -0,0 +1,9 @@
+import { Option } from '../base';
+import { SimpleOption, BooleanOption, ArrayOption } from '../defaults';
+export interface OptionsStore {
+    base: Option;
+    boolean: BooleanOption;
+    simple: SimpleOption;
+    array: ArrayOption;
+}
+export type Options = Extract<OptionsStore[keyof OptionsStore], Option>;

package/dist/command/types/eligibleType.d.ts

@@ -0,0 +1,4 @@
+import type * as DObject from "@duplojs/lang/object";
+import type * as DSDataStructure from '../../dataStructure';
+import type * as DDataStructure from "@duplojs/lang/dataStructure";
+export type EligibleType = (string | DDataStructure.FundamentalTypeValue<DObject.Values<typeof DSDataStructure.codecsString.definition>["fundamentalType"]>);

package/dist/command/types/forbiddenDuplicateName.d.ts

@@ -0,0 +1,11 @@
+import type * as DCommon from "@duplojs/lang/common";
+export type ForbiddenDuplicateName<GenericItems extends readonly {
+    readonly name: string;
+}[], GenericType extends string, GenericSeenNames extends string = never> = GenericItems extends readonly [
+    infer InferredFirstItem extends {
+        readonly name: string;
+    },
+    ...infer InferredRestItems extends {
+        readonly name: string;
+    }[]
+] ? InferredFirstItem["name"] extends GenericSeenNames ? DCommon.ComputedTypeError<`Duplicate ${GenericType} name "${InferredFirstItem["name"]}"`> : ForbiddenDuplicateName<InferredRestItems, GenericType, GenericSeenNames | InferredFirstItem["name"]> : unknown;

package/dist/command/types/index.d.ts

@@ -0,0 +1,2 @@
+export type * from './eligibleType';
+export type * from './forbiddenDuplicateName';

package/dist/common/environmentVariable/expandEnvironmentVariables.cjs

@@ -0,0 +1,27 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+let _duplojs_lang_object = require("@duplojs/lang/object");
+_duplojs_lang_object = require_runtime.__toESM(_duplojs_lang_object, 1);
+let _duplojs_lang_generator = require("@duplojs/lang/generator");
+_duplojs_lang_generator = require_runtime.__toESM(_duplojs_lang_generator, 1);
+let _duplojs_lang_string = require("@duplojs/lang/string");
+_duplojs_lang_string = require_runtime.__toESM(_duplojs_lang_string, 1);
+//#region scripts/common/environmentVariable/expandEnvironmentVariables.ts
+const envVarRegex = /(?<!\\)\${(?<value>[^{}]+)}/g;
+const escapedDollarRegex = /\\\$/g;
+function expandValue(value, env, stack = /* @__PURE__ */ new Set()) {
+	return _duplojs_lang_string.replace(value, envVarRegex, ({ namedGroups }) => {
+		const value = namedGroups.value;
+		const rawEnvValue = env[value];
+		if (rawEnvValue === void 0 || stack.has(value)) return "";
+		stack.add(value);
+		const resolved = expandValue(rawEnvValue, env, stack);
+		stack.delete(value);
+		return resolved;
+	});
+}
+function expandEnvironmentVariables(env) {
+	return _duplojs_lang_generator.reduce(_duplojs_lang_object.entries(env), _duplojs_lang_generator.reduceFrom(env), ({ item: [key, value], lastValue, nextWithObject }) => nextWithObject(lastValue, { [key]: _duplojs_lang_string.replaceAll(expandValue(value, lastValue), escapedDollarRegex, "$") }));
+}
+//#endregion
+exports.expandEnvironmentVariables = expandEnvironmentVariables;
+exports.expandValue = expandValue;

package/dist/common/environmentVariable/expandEnvironmentVariables.d.ts

@@ -0,0 +1,2 @@
+export declare function expandValue(value: string, env: Record<string, string>, stack?: Set<string>): string;
+export declare function expandEnvironmentVariables(env: Record<string, string>): Record<string, string>;

package/dist/common/environmentVariable/expandEnvironmentVariables.mjs

@@ -0,0 +1,22 @@
+import * as DObject from "@duplojs/lang/object";
+import * as DGenerator from "@duplojs/lang/generator";
+import * as DString from "@duplojs/lang/string";
+//#region scripts/common/environmentVariable/expandEnvironmentVariables.ts
+const envVarRegex = /(?<!\\)\${(?<value>[^{}]+)}/g;
+const escapedDollarRegex = /\\\$/g;
+function expandValue(value, env, stack = /* @__PURE__ */ new Set()) {
+	return DString.replace(value, envVarRegex, ({ namedGroups }) => {
+		const value = namedGroups.value;
+		const rawEnvValue = env[value];
+		if (rawEnvValue === void 0 || stack.has(value)) return "";
+		stack.add(value);
+		const resolved = expandValue(rawEnvValue, env, stack);
+		stack.delete(value);
+		return resolved;
+	});
+}
+function expandEnvironmentVariables(env) {
+	return DGenerator.reduce(DObject.entries(env), DGenerator.reduceFrom(env), ({ item: [key, value], lastValue, nextWithObject }) => nextWithObject(lastValue, { [key]: DString.replaceAll(expandValue(value, lastValue), escapedDollarRegex, "$") }));
+}
+//#endregion
+export { expandEnvironmentVariables, expandValue };

package/dist/common/environmentVariable/index.cjs

@@ -0,0 +1,47 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../../implementor.cjs");
+const require_string = require("../../dataStructure/common/codec/defaults/string.cjs");
+const require_parseEnvironmentFiles = require("./parseEnvironmentFiles.cjs");
+const require_expandEnvironmentVariables = require("./expandEnvironmentVariables.cjs");
+const require_overrideEnvironmentVariables = require("./overrideEnvironmentVariables.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_dataStructure = require("@duplojs/lang/dataStructure");
+_duplojs_lang_dataStructure = require_runtime.__toESM(_duplojs_lang_dataStructure, 1);
+let _duplojs_lang_object = require("@duplojs/lang/object");
+_duplojs_lang_object = require_runtime.__toESM(_duplojs_lang_object, 1);
+let _duplojs_lang_array = require("@duplojs/lang/array");
+_duplojs_lang_array = require_runtime.__toESM(_duplojs_lang_array, 1);
+//#region scripts/common/environmentVariable/index.ts
+const environmentVariable = require_implementor.implementFunction("environmentVariable", {
+	NODE: async (shape, envFileParams) => {
+		const baseEnv = _duplojs_lang_common.pipe(process.env, _duplojs_lang_object.entries, _duplojs_lang_array.filter((entry) => entry[1] !== void 0), _duplojs_lang_object.fromEntries);
+		const parseEnvFileResult = await require_parseEnvironmentFiles.parseEnvironmentFiles(baseEnv, envFileParams?.includedEnvironmentFiles ?? []);
+		if (_duplojs_lang_either.isLeft(parseEnvFileResult)) return parseEnvFileResult;
+		const overrideEnvResult = require_overrideEnvironmentVariables.overrideEnvironmentVariables(parseEnvFileResult, envFileParams?.override ?? false);
+		const expandEnvResult = require_expandEnvironmentVariables.expandEnvironmentVariables(overrideEnvResult);
+		const structure = _duplojs_lang_dataStructure.object(shape);
+		const envResult = _duplojs_lang_object.pick(expandEnvResult, structure.definition.keys);
+		const checkedEnvResult = await structure.asyncDecode(envFileParams?.codecs ?? require_string.codecsString, envResult);
+		if (_duplojs_lang_either.isLeft(checkedEnvResult)) return checkedEnvResult;
+		if (envFileParams?.justRead !== true) process.env = expandEnvResult;
+		return checkedEnvResult;
+	},
+	DENO: async (shape, envFileParams) => {
+		const parseEnvFileResult = await require_parseEnvironmentFiles.parseEnvironmentFiles(Deno.env.toObject(), envFileParams?.includedEnvironmentFiles ?? []);
+		if (_duplojs_lang_either.isLeft(parseEnvFileResult)) return parseEnvFileResult;
+		const overrideEnvResult = require_overrideEnvironmentVariables.overrideEnvironmentVariables(parseEnvFileResult, envFileParams?.override ?? false);
+		const expandEnvResult = require_expandEnvironmentVariables.expandEnvironmentVariables(overrideEnvResult);
+		const structure = _duplojs_lang_dataStructure.object(shape);
+		const envResult = _duplojs_lang_object.pick(expandEnvResult, structure.definition.keys);
+		const checkedEnvResult = await structure.asyncDecode(envFileParams?.codecs ?? _duplojs_lang_dataStructure.codecsString, envResult);
+		if (_duplojs_lang_either.isLeft(checkedEnvResult)) return checkedEnvResult;
+		if (envFileParams?.justRead !== true) for (const [key, value] of _duplojs_lang_object.entries(expandEnvResult)) if (value) Deno.env.set(key, value);
+		else Deno.env.delete(key);
+		return checkedEnvResult;
+	}
+});
+//#endregion
+exports.environmentVariable = environmentVariable;

package/dist/common/environmentVariable/index.d.ts

@@ -0,0 +1,16 @@
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+import type * as DSFile from '../../file';
+export interface EnvironmentVariableFileParams {
+    includedEnvironmentFiles?: (string & DPath.Path)[];
+    override?: boolean;
+    justRead?: boolean;
+    codecs?: DDataStructure.Codecs;
+}
+declare module '../../implementor' {
+    interface ServerFunction {
+        environmentVariable<GenericShape extends DDataStructure.ShapeObjectStructure>(shape: GenericShape, envFileParams?: EnvironmentVariableFileParams): Promise<DEither.Right<"decode-success", DDataStructure.ShapeObjectStructureValue<GenericShape>> | Exclude<DSFile.ReadTextFileResult, DEither.Right> | DEither.Left<"decode-error", DDataStructure.Error>>;
+    }
+}
+export declare const environmentVariable: <GenericShape extends DDataStructure.ShapeObjectStructure>(shape: GenericShape, envFileParams?: EnvironmentVariableFileParams) => Promise<DEither.Right<"decode-success", DDataStructure.ShapeObjectStructureValue<GenericShape>> | Exclude<DSFile.ReadTextFileResult, DEither.Right> | DEither.Left<"decode-error", DDataStructure.Error>>;

package/dist/common/environmentVariable/index.mjs

@@ -0,0 +1,41 @@
+import { implementFunction } from "../../implementor.mjs";
+import { codecsString } from "../../dataStructure/common/codec/defaults/string.mjs";
+import { parseEnvironmentFiles } from "./parseEnvironmentFiles.mjs";
+import { expandEnvironmentVariables } from "./expandEnvironmentVariables.mjs";
+import { overrideEnvironmentVariables } from "./overrideEnvironmentVariables.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DObject from "@duplojs/lang/object";
+import * as DArray from "@duplojs/lang/array";
+//#region scripts/common/environmentVariable/index.ts
+const environmentVariable = implementFunction("environmentVariable", {
+	NODE: async (shape, envFileParams) => {
+		const baseEnv = DCommon.pipe(process.env, DObject.entries, DArray.filter((entry) => entry[1] !== void 0), DObject.fromEntries);
+		const parseEnvFileResult = await parseEnvironmentFiles(baseEnv, envFileParams?.includedEnvironmentFiles ?? []);
+		if (DEither.isLeft(parseEnvFileResult)) return parseEnvFileResult;
+		const overrideEnvResult = overrideEnvironmentVariables(parseEnvFileResult, envFileParams?.override ?? false);
+		const expandEnvResult = expandEnvironmentVariables(overrideEnvResult);
+		const structure = DDataStructure.object(shape);
+		const envResult = DObject.pick(expandEnvResult, structure.definition.keys);
+		const checkedEnvResult = await structure.asyncDecode(envFileParams?.codecs ?? codecsString, envResult);
+		if (DEither.isLeft(checkedEnvResult)) return checkedEnvResult;
+		if (envFileParams?.justRead !== true) process.env = expandEnvResult;
+		return checkedEnvResult;
+	},
+	DENO: async (shape, envFileParams) => {
+		const parseEnvFileResult = await parseEnvironmentFiles(Deno.env.toObject(), envFileParams?.includedEnvironmentFiles ?? []);
+		if (DEither.isLeft(parseEnvFileResult)) return parseEnvFileResult;
+		const overrideEnvResult = overrideEnvironmentVariables(parseEnvFileResult, envFileParams?.override ?? false);
+		const expandEnvResult = expandEnvironmentVariables(overrideEnvResult);
+		const structure = DDataStructure.object(shape);
+		const envResult = DObject.pick(expandEnvResult, structure.definition.keys);
+		const checkedEnvResult = await structure.asyncDecode(envFileParams?.codecs ?? DDataStructure.codecsString, envResult);
+		if (DEither.isLeft(checkedEnvResult)) return checkedEnvResult;
+		if (envFileParams?.justRead !== true) for (const [key, value] of DObject.entries(expandEnvResult)) if (value) Deno.env.set(key, value);
+		else Deno.env.delete(key);
+		return checkedEnvResult;
+	}
+});
+//#endregion
+export { environmentVariable };

package/dist/common/environmentVariable/overrideEnvironmentVariables.cjs

@@ -0,0 +1,13 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_object = require("@duplojs/lang/object");
+_duplojs_lang_object = require_runtime.__toESM(_duplojs_lang_object, 1);
+let _duplojs_lang_array = require("@duplojs/lang/array");
+_duplojs_lang_array = require_runtime.__toESM(_duplojs_lang_array, 1);
+//#region scripts/common/environmentVariable/overrideEnvironmentVariables.ts
+function overrideEnvironmentVariables(arrayEnv, override) {
+	return _duplojs_lang_common.pipe(arrayEnv, _duplojs_lang_array.map(_duplojs_lang_object.entries), _duplojs_lang_array.flat, (entries) => override ? entries : _duplojs_lang_array.reverse(entries), _duplojs_lang_object.fromEntries);
+}
+//#endregion
+exports.overrideEnvironmentVariables = overrideEnvironmentVariables;

package/dist/common/environmentVariable/overrideEnvironmentVariables.d.ts

@@ -0,0 +1,3 @@
+export declare function overrideEnvironmentVariables(arrayEnv: Record<string, string>[], override: boolean): {
+    [x: string]: string;
+};

package/dist/common/environmentVariable/overrideEnvironmentVariables.mjs

@@ -0,0 +1,9 @@
+import * as DCommon from "@duplojs/lang/common";
+import * as DObject from "@duplojs/lang/object";
+import * as DArray from "@duplojs/lang/array";
+//#region scripts/common/environmentVariable/overrideEnvironmentVariables.ts
+function overrideEnvironmentVariables(arrayEnv, override) {
+	return DCommon.pipe(arrayEnv, DArray.map(DObject.entries), DArray.flat, (entries) => override ? entries : DArray.reverse(entries), DObject.fromEntries);
+}
+//#endregion
+export { overrideEnvironmentVariables };

package/dist/common/environmentVariable/parseEnvironmentFiles.cjs

@@ -0,0 +1,32 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_readTextFile = require("../../file/readTextFile.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_generator = require("@duplojs/lang/generator");
+_duplojs_lang_generator = require_runtime.__toESM(_duplojs_lang_generator, 1);
+let _duplojs_lang_string = require("@duplojs/lang/string");
+_duplojs_lang_string = require_runtime.__toESM(_duplojs_lang_string, 1);
+//#region scripts/common/environmentVariable/parseEnvironmentFiles.ts
+const lineRegex = /^(?:export\s+)?(?<key>[A-Z_][A-Z0-9_]*)=(?<value>'(?:\\'|[^'])*'|"(?:\\"|[^"])*"|`(?:\\`|[^`])*`|[^\s#\r\n][^#\r\n]*|)\s*(?:#.*)?$/gm;
+const endLineBreakerRegex = /\r\n?/gm;
+const surroundingQuoteRegex = /^(['"`])([\s\S]*)\1$/gm;
+const backCartRegex = /\\r/g;
+const newLineRegex = /\\n/g;
+function parseEnvironmentLine(line) {
+	return _duplojs_lang_common.pipe(line, _duplojs_lang_string.replace(endLineBreakerRegex, "\n"), _duplojs_lang_string.extractAll(lineRegex), _duplojs_lang_generator.reduce(_duplojs_lang_generator.reduceFrom({}), ({ item, nextWithObject, lastValue, next }) => {
+		if (item.namedGroups?.key && item.namedGroups?.value) return nextWithObject(lastValue, { [item.namedGroups.key]: _duplojs_lang_common.pipe(item.namedGroups.value, (value) => {
+			const surroundingValue = _duplojs_lang_string.replace(value, surroundingQuoteRegex, "$2");
+			if (_duplojs_lang_string.startsWith(value, "\"")) return _duplojs_lang_common.pipe(surroundingValue, _duplojs_lang_string.replace(newLineRegex, "\n"), _duplojs_lang_string.replace(backCartRegex, "\r"));
+			return surroundingValue;
+		}) });
+		return next(lastValue);
+	}));
+}
+function parseEnvironmentFiles(baseEnv, paths) {
+	return _duplojs_lang_generator.asyncReduce(paths, _duplojs_lang_generator.reduceFrom([baseEnv]), ({ lastValue, item, nextPush, exit }) => require_readTextFile.readTextFile(item).then(_duplojs_lang_common.innerPipe(_duplojs_lang_either.whenIsRight(_duplojs_lang_common.innerPipe(parseEnvironmentLine, (value) => nextPush(lastValue, value))), _duplojs_lang_common.when(_duplojs_lang_either.isLeft, exit))));
+}
+//#endregion
+exports.parseEnvironmentFiles = parseEnvironmentFiles;
+exports.parseEnvironmentLine = parseEnvironmentLine;

package/dist/common/environmentVariable/parseEnvironmentFiles.d.ts

@@ -0,0 +1,4 @@
+import type * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+export declare function parseEnvironmentLine(line: string): Record<string, string>;
+export declare function parseEnvironmentFiles(baseEnv: Record<string, string>, paths: (string & DPath.Path)[]): Promise<DEither.Left<"file-system-read-text-file-not-found", unknown> | DEither.Left<"file-system-read-text-file-permission-denied", unknown> | DEither.Left<"file-system-read-text-file-is-directory", unknown> | DEither.Left<"file-system-read-text-file-not-directory", unknown> | DEither.Left<"file-system-read-text-file-too-many-open-files", unknown> | DEither.Left<"file-system-read-text-file-busy", unknown> | DEither.Left<"file-system-read-text-file-error", unknown> | Record<string, string>[]>;

package/dist/common/environmentVariable/parseEnvironmentFiles.mjs

@@ -0,0 +1,26 @@
+import { readTextFile } from "../../file/readTextFile.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import * as DGenerator from "@duplojs/lang/generator";
+import * as DString from "@duplojs/lang/string";
+//#region scripts/common/environmentVariable/parseEnvironmentFiles.ts
+const lineRegex = /^(?:export\s+)?(?<key>[A-Z_][A-Z0-9_]*)=(?<value>'(?:\\'|[^'])*'|"(?:\\"|[^"])*"|`(?:\\`|[^`])*`|[^\s#\r\n][^#\r\n]*|)\s*(?:#.*)?$/gm;
+const endLineBreakerRegex = /\r\n?/gm;
+const surroundingQuoteRegex = /^(['"`])([\s\S]*)\1$/gm;
+const backCartRegex = /\\r/g;
+const newLineRegex = /\\n/g;
+function parseEnvironmentLine(line) {
+	return DCommon.pipe(line, DString.replace(endLineBreakerRegex, "\n"), DString.extractAll(lineRegex), DGenerator.reduce(DGenerator.reduceFrom({}), ({ item, nextWithObject, lastValue, next }) => {
+		if (item.namedGroups?.key && item.namedGroups?.value) return nextWithObject(lastValue, { [item.namedGroups.key]: DCommon.pipe(item.namedGroups.value, (value) => {
+			const surroundingValue = DString.replace(value, surroundingQuoteRegex, "$2");
+			if (DString.startsWith(value, "\"")) return DCommon.pipe(surroundingValue, DString.replace(newLineRegex, "\n"), DString.replace(backCartRegex, "\r"));
+			return surroundingValue;
+		}) });
+		return next(lastValue);
+	}));
+}
+function parseEnvironmentFiles(baseEnv, paths) {
+	return DGenerator.asyncReduce(paths, DGenerator.reduceFrom([baseEnv]), ({ lastValue, item, nextPush, exit }) => readTextFile(item).then(DCommon.innerPipe(DEither.whenIsRight(DCommon.innerPipe(parseEnvironmentLine, (value) => nextPush(lastValue, value))), DCommon.when(DEither.isLeft, exit))));
+}
+//#endregion
+export { parseEnvironmentFiles, parseEnvironmentLine };

package/dist/common/environmentVariableOrThrow.cjs

@@ -0,0 +1,23 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("../kind.cjs");
+const require_index = require("./environmentVariable/index.cjs");
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_kind = require("@duplojs/lang/kind");
+_duplojs_lang_kind = require_runtime.__toESM(_duplojs_lang_kind, 1);
+//#region scripts/common/environmentVariableOrThrow.ts
+var EnvironmentVariableError = class extends _duplojs_lang_kind.parentClass(require_kind.createKind("environment-variable-error"), Error) {
+	error;
+	constructor(error) {
+		super(null, "Failed to load environment variables: one env file could not be read or parsed values do not match the provided structure.");
+		this.error = error;
+	}
+};
+async function environmentVariableOrThrow(shape, envFileParams) {
+	const result = await require_index.environmentVariable(shape, envFileParams);
+	if (_duplojs_lang_either.isLeft(result)) throw new EnvironmentVariableError(result);
+	return _duplojs_lang_either.unwrapRight(result);
+}
+//#endregion
+exports.EnvironmentVariableError = EnvironmentVariableError;
+exports.environmentVariableOrThrow = environmentVariableOrThrow;

package/dist/common/environmentVariableOrThrow.d.ts

@@ -0,0 +1,12 @@
+import { EnvironmentVariableFileParams } from './environmentVariable';
+import * as DEither from "@duplojs/lang/either";
+import type * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DKind from "@duplojs/lang/kind";
+import type * as DSFile from '../file';
+declare const EnvironmentVariableError_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsServer/environment-variable-error", unknown>>, ErrorConstructor>;
+export declare class EnvironmentVariableError extends EnvironmentVariableError_base {
+    error: (Exclude<DSFile.ReadTextFileResult, DEither.Right> | DEither.Left<"decode-error", DDataStructure.Error>);
+    constructor(error: (Exclude<DSFile.ReadTextFileResult, DEither.Right> | DEither.Left<"decode-error", DDataStructure.Error>));
+}
+export declare function environmentVariableOrThrow<GenericShape extends DDataStructure.ShapeObjectStructure>(shape: GenericShape, envFileParams?: EnvironmentVariableFileParams): Promise<DDataStructure.ShapeObjectStructureValue<GenericShape>>;
+export {};

package/dist/common/environmentVariableOrThrow.mjs

@@ -0,0 +1,19 @@
+import { createKind } from "../kind.mjs";
+import { environmentVariable } from "./environmentVariable/index.mjs";
+import * as DEither from "@duplojs/lang/either";
+import * as DKind from "@duplojs/lang/kind";
+//#region scripts/common/environmentVariableOrThrow.ts
+var EnvironmentVariableError = class extends DKind.parentClass(createKind("environment-variable-error"), Error) {
+	error;
+	constructor(error) {
+		super(null, "Failed to load environment variables: one env file could not be read or parsed values do not match the provided structure.");
+		this.error = error;
+	}
+};
+async function environmentVariableOrThrow(shape, envFileParams) {
+	const result = await environmentVariable(shape, envFileParams);
+	if (DEither.isLeft(result)) throw new EnvironmentVariableError(result);
+	return DEither.unwrapRight(result);
+}
+//#endregion
+export { EnvironmentVariableError, environmentVariableOrThrow };

package/dist/common/exitProcess.cjs

@@ -0,0 +1,7 @@
+//#region scripts/common/exitProcess.ts
+const exitProcess = require("../implementor.cjs").implementFunction("exitProcess", {
+	NODE: (code) => process.exit(code),
+	DENO: (code) => Deno.exit(code)
+});
+//#endregion
+exports.exitProcess = exitProcess;

package/dist/common/exitProcess.d.ts

@@ -0,0 +1,6 @@
+declare module '../implementor' {
+    interface ServerFunction {
+        exitProcess(code?: number): void;
+    }
+}
+export declare const exitProcess: (code?: number) => void;

package/dist/common/exitProcess.mjs

@@ -0,0 +1,8 @@
+import { implementFunction } from "../implementor.mjs";
+//#region scripts/common/exitProcess.ts
+const exitProcess = implementFunction("exitProcess", {
+	NODE: (code) => process.exit(code),
+	DENO: (code) => Deno.exit(code)
+});
+//#endregion
+export { exitProcess };

package/dist/common/getCurrentWorkDirectory.cjs

@@ -0,0 +1,15 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_implementor = require("../implementor.cjs");
+let _duplojs_lang_common = require("@duplojs/lang/common");
+_duplojs_lang_common = require_runtime.__toESM(_duplojs_lang_common, 1);
+let _duplojs_lang_either = require("@duplojs/lang/either");
+_duplojs_lang_either = require_runtime.__toESM(_duplojs_lang_either, 1);
+let _duplojs_lang_path = require("@duplojs/lang/path");
+_duplojs_lang_path = require_runtime.__toESM(_duplojs_lang_path, 1);
+//#region scripts/common/getCurrentWorkDirectory.ts
+const getCurrentWorkDirectory = require_implementor.implementFunction("getCurrentWorkDirectory", {
+	NODE: () => _duplojs_lang_common.pipe(_duplojs_lang_either.safeCallback(() => _duplojs_lang_common.whenElse(_duplojs_lang_path.normalize(process.cwd()), (value) => _duplojs_lang_common.isType(value, "string") && _duplojs_lang_path.isAbsolute(value), _duplojs_lang_either.success, _duplojs_lang_either.error)), _duplojs_lang_either.whenIsLeft(_duplojs_lang_either.error)),
+	DENO: () => _duplojs_lang_common.pipe(_duplojs_lang_either.safeCallback(() => _duplojs_lang_common.whenElse(_duplojs_lang_path.normalize(Deno.cwd()), (value) => _duplojs_lang_common.isType(value, "string") && _duplojs_lang_path.isAbsolute(value), _duplojs_lang_either.success, _duplojs_lang_either.error)), _duplojs_lang_either.whenIsLeft(_duplojs_lang_either.error))
+});
+//#endregion
+exports.getCurrentWorkDirectory = getCurrentWorkDirectory;

package/dist/common/getCurrentWorkDirectory.d.ts

@@ -0,0 +1,8 @@
+import * as DEither from "@duplojs/lang/either";
+import * as DPath from "@duplojs/lang/path";
+declare module '../implementor' {
+    interface ServerFunction {
+        getCurrentWorkDirectory(): (DEither.Error<unknown> | DEither.Success<string & DPath.Absolute>);
+    }
+}
+export declare const getCurrentWorkDirectory: () => (DEither.Error<unknown> | DEither.Success<string & DPath.Absolute>);

package/dist/common/getCurrentWorkDirectory.mjs

@@ -0,0 +1,11 @@
+import { implementFunction } from "../implementor.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import * as DPath from "@duplojs/lang/path";
+//#region scripts/common/getCurrentWorkDirectory.ts
+const getCurrentWorkDirectory = implementFunction("getCurrentWorkDirectory", {
+	NODE: () => DCommon.pipe(DEither.safeCallback(() => DCommon.whenElse(DPath.normalize(process.cwd()), (value) => DCommon.isType(value, "string") && DPath.isAbsolute(value), DEither.success, DEither.error)), DEither.whenIsLeft(DEither.error)),
+	DENO: () => DCommon.pipe(DEither.safeCallback(() => DCommon.whenElse(DPath.normalize(Deno.cwd()), (value) => DCommon.isType(value, "string") && DPath.isAbsolute(value), DEither.success, DEither.error)), DEither.whenIsLeft(DEither.error))
+});
+//#endregion
+export { getCurrentWorkDirectory };