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

package/dist/file/writeTextFile.d.ts

@@ -0,0 +1,11 @@
+import { FileSystemEither } from './types';
+import * as DEither from "@duplojs/lang/either";
+import type * as DPath from "@duplojs/lang/path";
+export type WriteTextFileResult = FileSystemEither<DEither.Right<"write-text-file", void> | DEither.Left<"write-text-file-not-found", unknown> | DEither.Left<"write-text-file-permission-denied", unknown> | DEither.Left<"write-text-file-is-directory", unknown> | DEither.Left<"write-text-file-not-directory", unknown> | DEither.Left<"write-text-file-no-space", unknown> | DEither.Left<"write-text-file-read-only", unknown> | DEither.Left<"write-text-file-invalid-argument", unknown> | DEither.Left<"write-text-file-too-many-open-files", unknown> | DEither.Left<"write-text-file-busy", unknown> | DEither.Left<"write-text-file-error", unknown>>;
+declare module '../implementor' {
+    interface ServerFunction {
+        writeTextFile(path: string & DPath.Path, data: string): Promise<WriteTextFileResult>;
+    }
+}
+export declare function writeTextFile(data: string): (path: string & DPath.Path) => Promise<WriteTextFileResult>;
+export declare function writeTextFile(path: string & DPath.Path, data: string): Promise<WriteTextFileResult>;

package/dist/file/writeTextFile.mjs

@@ -0,0 +1,42 @@
+import { implementFunction, nodeFileSystem } from "../implementor.mjs";
+import * as DEither from "@duplojs/lang/either";
+//#region scripts/file/writeTextFile.ts
+function handleNodeWriteTextFileError(error) {
+	if (typeof error === "object" && error !== null && "code" in error) {
+		if (error.code === "ENOENT") return DEither.left("file-system-write-text-file-not-found", error);
+		else if (error.code === "EACCES" || error.code === "EPERM") return DEither.left("file-system-write-text-file-permission-denied", error);
+		else if (error.code === "EISDIR") return DEither.left("file-system-write-text-file-is-directory", error);
+		else if (error.code === "ENOTDIR") return DEither.left("file-system-write-text-file-not-directory", error);
+		else if (error.code === "ENOSPC") return DEither.left("file-system-write-text-file-no-space", error);
+		else if (error.code === "EROFS") return DEither.left("file-system-write-text-file-read-only", error);
+		else if (error.code === "EINVAL") return DEither.left("file-system-write-text-file-invalid-argument", error);
+		else if (error.code === "EMFILE" || error.code === "ENFILE") return DEither.left("file-system-write-text-file-too-many-open-files", error);
+		else if (error.code === "EBUSY") return DEither.left("file-system-write-text-file-busy", error);
+	}
+	return DEither.left("file-system-write-text-file-error", error);
+}
+function handleDenoWriteTextFileError(error) {
+	if (error instanceof Deno.errors.NotFound) return DEither.left("file-system-write-text-file-not-found", error);
+	if (error instanceof Deno.errors.PermissionDenied || error instanceof Deno.errors.NotCapable) return DEither.left("file-system-write-text-file-permission-denied", error);
+	if (error instanceof Deno.errors.IsADirectory) return DEither.left("file-system-write-text-file-is-directory", error);
+	if (error instanceof Deno.errors.NotADirectory) return DEither.left("file-system-write-text-file-not-directory", error);
+	if (error instanceof Deno.errors.InvalidData) return DEither.left("file-system-write-text-file-invalid-argument", error);
+	if (error instanceof Deno.errors.Busy) return DEither.left("file-system-write-text-file-busy", error);
+	return DEither.left("file-system-write-text-file-error", error);
+}
+const writeTextFileImplementation = implementFunction("writeTextFile", {
+	NODE: async (path, data) => {
+		return (await nodeFileSystem.value).writeFile(path, data, { encoding: "utf-8" }).then(() => DEither.right("file-system-write-text-file")).catch(handleNodeWriteTextFileError);
+	},
+	DENO: (path, data) => Deno.writeTextFile(path, data).then(() => DEither.right("file-system-write-text-file")).catch(handleDenoWriteTextFileError),
+	BUN: (path, data) => Bun.file(path).write(data).then(() => DEither.right("file-system-write-text-file")).catch(handleNodeWriteTextFileError)
+});
+function writeTextFile(...args) {
+	if (args.length === 1) {
+		const [data] = args;
+		return (path) => writeTextFileImplementation(path, data);
+	}
+	return writeTextFileImplementation(...args);
+}
+//#endregion
+export { writeTextFile };

package/dist/implementor.cjs

@@ -0,0 +1,64 @@
+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);
+_duplojs_lang_common.createEnum([
+	"BUN",
+	"DENO",
+	"NODE",
+	"TEST"
+]);
+const SymbolEnvironmentStore = Symbol("environmentStore");
+const environmentStoreHandler = _duplojs_lang_common.createGlobalStore(SymbolEnvironmentStore, (() => {
+	if (typeof Deno !== "undefined") return "DENO";
+	if (typeof Bun !== "undefined") return "BUN";
+	if (typeof process !== "undefined" && process.versions?.node) return "NODE";
+	return "NODE";
+})());
+function setEnvironment(environment) {
+	environmentStoreHandler.set(environment);
+}
+let TESTImplementation;
+(function(_TESTImplementation) {
+	const store = /* @__PURE__ */ new Map();
+	function clear() {
+		store.clear();
+	}
+	_TESTImplementation.clear = clear;
+	function set(functionName, theFunction) {
+		store.set(functionName, theFunction);
+		return theFunction;
+	}
+	_TESTImplementation.set = set;
+	function get(functionName) {
+		return store.get(functionName);
+	}
+	_TESTImplementation.get = get;
+})(TESTImplementation || (TESTImplementation = {}));
+function implementFunction(functionName, theFunctions) {
+	const environmentFunctions = {
+		NODE: theFunctions.NODE,
+		BUN: theFunctions.BUN ||= theFunctions.NODE,
+		DENO: theFunctions.DENO ||= theFunctions.NODE,
+		get TEST() {
+			const theFunction = TESTImplementation.get(functionName);
+			if (!theFunction) throw new Error(`Missing function implementation "${functionName}" in TEST environment.`);
+			return theFunction;
+		}
+	};
+	return (...args) => environmentFunctions[environmentStoreHandler.value](...args);
+}
+const nodeFileSystem = _duplojs_lang_common.memoPromise(() => import("node:fs/promises"));
+const nodeCrypto = _duplojs_lang_common.memoPromise(() => import("node:crypto"));
+const nodeOs = _duplojs_lang_common.memoPromise(() => import("node:os"));
+//#endregion
+Object.defineProperty(exports, "TESTImplementation", {
+	enumerable: true,
+	get: function() {
+		return TESTImplementation;
+	}
+});
+exports.implementFunction = implementFunction;
+exports.nodeCrypto = nodeCrypto;
+exports.nodeFileSystem = nodeFileSystem;
+exports.nodeOs = nodeOs;
+exports.setEnvironment = setEnvironment;

package/dist/implementor.d.ts

@@ -0,0 +1,35 @@
+import * as DCommon from "@duplojs/lang/common";
+export interface ServerFunction {
+}
+export declare const SupportedEnvironment: {
+    BUN: "BUN";
+    DENO: "DENO";
+    NODE: "NODE";
+    TEST: "TEST";
+    toTuple: () => readonly ["BUN", "DENO", "NODE", "TEST"];
+    has: (value: string) => value is "BUN" | "DENO" | "NODE" | "TEST";
+    contract: <GenericContractValue extends string = "BUN" | "DENO" | "NODE" | "TEST">(...args: (Exclude<"BUN", GenericContractValue> | Exclude<"DENO", GenericContractValue> | Exclude<"NODE", GenericContractValue> | Exclude<"TEST", GenericContractValue> extends infer InferredMissingValue extends string ? DCommon.IsNever<InferredMissingValue> extends true ? unknown : DCommon.ComputedTypeError<`Enum contract is missing value "${InferredMissingValue}".`> : never) & (Exclude<GenericContractValue, "BUN" | "DENO" | "NODE" | "TEST"> extends infer InferredUnknownValue extends string ? DCommon.IsNever<InferredUnknownValue> extends true ? unknown : DCommon.ComputedTypeError<`Enum contract contains unknown value "${InferredUnknownValue}".`> : never) extends infer InferredRequirement ? DCommon.IsEqual<InferredRequirement, unknown> extends true ? [] : [] & InferredRequirement : never) => /*elided*/ any;
+};
+export type SupportedEnvironment = DCommon.GetEnumValue<typeof SupportedEnvironment>;
+declare const SymbolEnvironmentStore: unique symbol;
+type SymbolEnvironmentStore = typeof SymbolEnvironmentStore;
+declare module "@duplojs/lang" {
+    interface GlobalStore {
+        [SymbolEnvironmentStore]: SupportedEnvironment;
+    }
+}
+export declare function setEnvironment(environment: SupportedEnvironment): void;
+export declare namespace TESTImplementation {
+    function clear(): void;
+    function set<GenericFunctionName extends keyof ServerFunction>(functionName: GenericFunctionName, theFunction: ServerFunction[GenericFunctionName]): ServerFunction[GenericFunctionName];
+    function get<GenericFunctionName extends keyof ServerFunction>(functionName: GenericFunctionName): ServerFunction[GenericFunctionName] | undefined;
+}
+export declare function implementFunction<GenericFunctionName extends keyof ServerFunction>(functionName: GenericFunctionName, theFunctions: {
+    NODE: ServerFunction[GenericFunctionName];
+    BUN?: ServerFunction[GenericFunctionName];
+    DENO?: ServerFunction[GenericFunctionName];
+}): ServerFunction[GenericFunctionName];
+export declare const nodeFileSystem: DCommon.MemoizedPromise<typeof import("node:fs/promises")>;
+export declare const nodeCrypto: DCommon.MemoizedPromise<typeof import("node:crypto")>;
+export declare const nodeOs: DCommon.MemoizedPromise<typeof import("node:os")>;
+export {};

package/dist/implementor.mjs

@@ -0,0 +1,52 @@
+import * as DCommon from "@duplojs/lang/common";
+DCommon.createEnum([
+	"BUN",
+	"DENO",
+	"NODE",
+	"TEST"
+]);
+const SymbolEnvironmentStore = Symbol("environmentStore");
+const environmentStoreHandler = DCommon.createGlobalStore(SymbolEnvironmentStore, (() => {
+	if (typeof Deno !== "undefined") return "DENO";
+	if (typeof Bun !== "undefined") return "BUN";
+	if (typeof process !== "undefined" && process.versions?.node) return "NODE";
+	return "NODE";
+})());
+function setEnvironment(environment) {
+	environmentStoreHandler.set(environment);
+}
+let TESTImplementation;
+(function(_TESTImplementation) {
+	const store = /* @__PURE__ */ new Map();
+	function clear() {
+		store.clear();
+	}
+	_TESTImplementation.clear = clear;
+	function set(functionName, theFunction) {
+		store.set(functionName, theFunction);
+		return theFunction;
+	}
+	_TESTImplementation.set = set;
+	function get(functionName) {
+		return store.get(functionName);
+	}
+	_TESTImplementation.get = get;
+})(TESTImplementation || (TESTImplementation = {}));
+function implementFunction(functionName, theFunctions) {
+	const environmentFunctions = {
+		NODE: theFunctions.NODE,
+		BUN: theFunctions.BUN ||= theFunctions.NODE,
+		DENO: theFunctions.DENO ||= theFunctions.NODE,
+		get TEST() {
+			const theFunction = TESTImplementation.get(functionName);
+			if (!theFunction) throw new Error(`Missing function implementation "${functionName}" in TEST environment.`);
+			return theFunction;
+		}
+	};
+	return (...args) => environmentFunctions[environmentStoreHandler.value](...args);
+}
+const nodeFileSystem = DCommon.memoPromise(() => import("node:fs/promises"));
+const nodeCrypto = DCommon.memoPromise(() => import("node:crypto"));
+const nodeOs = DCommon.memoPromise(() => import("node:os"));
+//#endregion
+export { TESTImplementation, implementFunction, nodeCrypto, nodeFileSystem, nodeOs, setEnvironment };

package/dist/index.cjs

@@ -0,0 +1,74 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_implementor = require("./implementor.cjs");
+const require_getCurrentWorkDirectory = require("./common/getCurrentWorkDirectory.cjs");
+const require_getCurrentWorkDirectoryOrThrow = require("./common/getCurrentWorkDirectoryOrThrow.cjs");
+const require_setCurrentWorkingDirectory = require("./common/setCurrentWorkingDirectory.cjs");
+const require_setCurrentWorkingDirectoryOrThrow = require("./common/setCurrentWorkingDirectoryOrThrow.cjs");
+const require_index = require("./file/index.cjs");
+const require_index$1 = require("./dataStructure/index.cjs");
+const require_index$2 = require("./common/environmentVariable/index.cjs");
+const require_environmentVariableOrThrow = require("./common/environmentVariableOrThrow.cjs");
+const require_exitProcess = require("./common/exitProcess.cjs");
+const require_getProcessArguments = require("./common/getProcessArguments.cjs");
+const require_index$3 = require("./common/index.cjs");
+const require_index$4 = require("./command/index.cjs");
+Object.defineProperty(exports, "DSCommand", {
+	enumerable: true,
+	get: function() {
+		return require_index$4.command_exports;
+	}
+});
+Object.defineProperty(exports, "DSCommon", {
+	enumerable: true,
+	get: function() {
+		return require_index$3.common_exports;
+	}
+});
+Object.defineProperty(exports, "DSDataStructure", {
+	enumerable: true,
+	get: function() {
+		return require_index$1.dataStructure_exports;
+	}
+});
+Object.defineProperty(exports, "DSFile", {
+	enumerable: true,
+	get: function() {
+		return require_index.file_exports;
+	}
+});
+exports.EnvironmentVariableError = require_environmentVariableOrThrow.EnvironmentVariableError;
+exports.GetCurrentWorkDirectoryError = require_getCurrentWorkDirectoryOrThrow.GetCurrentWorkDirectoryError;
+Object.defineProperty(exports, "SC", {
+	enumerable: true,
+	get: function() {
+		return require_index$4.command_exports;
+	}
+});
+Object.defineProperty(exports, "SDS", {
+	enumerable: true,
+	get: function() {
+		return require_index$1.dataStructure_exports;
+	}
+});
+Object.defineProperty(exports, "SF", {
+	enumerable: true,
+	get: function() {
+		return require_index.file_exports;
+	}
+});
+exports.SetCurrentWorkingDirectoryError = require_setCurrentWorkingDirectoryOrThrow.SetCurrentWorkingDirectoryError;
+Object.defineProperty(exports, "TESTImplementation", {
+	enumerable: true,
+	get: function() {
+		return require_implementor.TESTImplementation;
+	}
+});
+exports.environmentVariable = require_index$2.environmentVariable;
+exports.environmentVariableOrThrow = require_environmentVariableOrThrow.environmentVariableOrThrow;
+exports.exitProcess = require_exitProcess.exitProcess;
+exports.getCurrentWorkDirectory = require_getCurrentWorkDirectory.getCurrentWorkDirectory;
+exports.getCurrentWorkDirectoryOrThrow = require_getCurrentWorkDirectoryOrThrow.getCurrentWorkDirectoryOrThrow;
+exports.getProcessArguments = require_getProcessArguments.getProcessArguments;
+exports.setCurrentWorkingDirectory = require_setCurrentWorkingDirectory.setCurrentWorkingDirectory;
+exports.setCurrentWorkingDirectoryOrThrow = require_setCurrentWorkingDirectoryOrThrow.setCurrentWorkingDirectoryOrThrow;
+exports.setEnvironment = require_implementor.setEnvironment;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { setEnvironment, TESTImplementation } from './implementor';
+export * from './common';
+export * as DSCommon from './common';
+export * as SF from './file';
+export * as DSFile from './file';
+export * as SDS from './dataStructure';
+export * as DSDataStructure from './dataStructure';
+export * as SC from './command';
+export * as DSCommand from './command';

package/dist/index.mjs

@@ -0,0 +1,14 @@
+import { TESTImplementation, setEnvironment } from "./implementor.mjs";
+import { getCurrentWorkDirectory } from "./common/getCurrentWorkDirectory.mjs";
+import { GetCurrentWorkDirectoryError, getCurrentWorkDirectoryOrThrow } from "./common/getCurrentWorkDirectoryOrThrow.mjs";
+import { setCurrentWorkingDirectory } from "./common/setCurrentWorkingDirectory.mjs";
+import { SetCurrentWorkingDirectoryError, setCurrentWorkingDirectoryOrThrow } from "./common/setCurrentWorkingDirectoryOrThrow.mjs";
+import { file_exports } from "./file/index.mjs";
+import { dataStructure_exports } from "./dataStructure/index.mjs";
+import { environmentVariable } from "./common/environmentVariable/index.mjs";
+import { EnvironmentVariableError, environmentVariableOrThrow } from "./common/environmentVariableOrThrow.mjs";
+import { exitProcess } from "./common/exitProcess.mjs";
+import { getProcessArguments } from "./common/getProcessArguments.mjs";
+import { common_exports } from "./common/index.mjs";
+import { command_exports } from "./command/index.mjs";
+export { command_exports as DSCommand, common_exports as DSCommon, dataStructure_exports as DSDataStructure, file_exports as DSFile, EnvironmentVariableError, GetCurrentWorkDirectoryError, command_exports as SC, dataStructure_exports as SDS, file_exports as SF, SetCurrentWorkingDirectoryError, TESTImplementation, environmentVariable, environmentVariableOrThrow, exitProcess, getCurrentWorkDirectory, getCurrentWorkDirectoryOrThrow, getProcessArguments, setCurrentWorkingDirectory, setCurrentWorkingDirectoryOrThrow, setEnvironment };

package/dist/kind.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/kind.ts
+const createKind = _duplojs_lang_kind.createNamespace("DuplojsServer");
+//#endregion
+exports.createKind = createKind;

package/dist/kind.d.ts

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

package/dist/kind.mjs

@@ -0,0 +1,5 @@
+import * as DKind from "@duplojs/lang/kind";
+//#region scripts/kind.ts
+const createKind = DKind.createNamespace("DuplojsServer");
+//#endregion
+export { createKind };

package/package.json

@@ -1,6 +1,84 @@
 {
   "name": "@duplojs/server",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0-beta.1",
+  "license": "MIT",
+  "author": {
+    "name": "DuploJS",
+    "url": "https://github.com/duplojs"
+  },
+  "description": "Typed helpers to handle files, system operations, and CLI commands.",
+  "homepage": "https://server.duplojs.dev/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/duplojs/ecosystem.git",
+    "directory": "packages/server"
+  },
+  "bugs": {
+    "url": "https://github.com/duplojs/ecosystem/issues"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./file": {
+      "import": "./dist/file/index.mjs",
+      "require": "./dist/file/index.cjs",
+      "types": "./dist/file/index.d.ts"
+    },
+    "./common": {
+      "import": "./dist/common/index.mjs",
+      "require": "./dist/common/index.cjs",
+      "types": "./dist/common/index.d.ts"
+    },
+    "./dataStructure": {
+      "import": "./dist/dataStructure/index.mjs",
+      "require": "./dist/dataStructure/index.cjs",
+      "types": "./dist/dataStructure/index.d.ts"
+    },
+    "./command": {
+      "import": "./dist/command/index.mjs",
+      "require": "./dist/command/index.cjs",
+      "types": "./dist/command/index.d.ts"
+    }
+  },
+  "peerDependencies": {
+    "@duplojs/lang": "0.1.0-beta.1"
+  },
+  "devDependencies": {
+    "@duplojs/code-config": "0.1.0-beta.1",
+    "@types/bun": "1.4.1",
+    "@types/deno": "2.7.0",
+    "@types/node": "24.13.3",
+    "bun": "1.4.2",
+    "deno": "2.9.6"
+  },
+  "files": [
+    "dist",
+    "README"
+  ],
+  "keywords": [
+    "duplojs",
+    "file",
+    "fileSystem",
+    "cli",
+    "command",
+    "dotenv",
+    "env",
+    "server-utils"
+  ],
+  "engines": {
+    "node": ">=24.18.0"
+  },
+  "scripts": {
+    "build": "./.commands/build.sh",
+    "test:types": "./.commands/test-types.sh",
+    "test:types:target": "./.commands/test-types-target.sh",
+    "test:lint": "./.commands/test-lint.sh",
+    "test:lint:fix": "./.commands/test-lint.sh --fix"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.