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

package/dist/file/fileInterface.cjs

@@ -0,0 +1,76 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("../kind.cjs");
+const require_stat = require("./stat.cjs");
+const require_rename = require("./rename.cjs");
+const require_exists = require("./exists.cjs");
+const require_move = require("./move.cjs");
+const require_remove = require("./remove.cjs");
+const require_relocate = require("./relocate.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/file/fileInterface.ts
+const fileInterfaceKind = require_kind.createKind("fileInterface");
+function createFileInterface(path) {
+	function getName() {
+		return _duplojs_lang_path.getBaseName(path);
+	}
+	function getExtension(params) {
+		return _duplojs_lang_path.getExtensionName(path, params);
+	}
+	function getMimeType() {
+		const extension = getExtension();
+		if (!extension) return null;
+		return _duplojs_lang_common.mimeType.get(extension) ?? null;
+	}
+	function getParentPath() {
+		return _duplojs_lang_path.getParentFolderPath(path);
+	}
+	function localExists() {
+		return require_exists.exists(path);
+	}
+	function localRename(newName) {
+		return _duplojs_lang_common.asyncPipe(require_rename.rename(path, newName), _duplojs_lang_either.whenIsRight(_duplojs_lang_common.innerPipe(createFileInterface, (value) => _duplojs_lang_either.right("file-system-rename", value))));
+	}
+	function localRelocate(newParentPath) {
+		return _duplojs_lang_common.asyncPipe(require_relocate.relocate(path, newParentPath), _duplojs_lang_either.whenIsRight(_duplojs_lang_common.innerPipe(createFileInterface, (value) => _duplojs_lang_either.right("file-system-relocate", value))));
+	}
+	function localMove(newPath) {
+		return _duplojs_lang_common.asyncPipe(require_move.move(path, newPath), _duplojs_lang_either.whenIsRight(() => _duplojs_lang_either.right("file-system-move", createFileInterface(newPath))));
+	}
+	function localRemove() {
+		return require_remove.remove(path);
+	}
+	function localStat() {
+		return require_stat.stat(path);
+	}
+	function isFile() {
+		return _duplojs_lang_common.asyncPipe(localStat(), _duplojs_lang_either.whenHasInformationOtherwise("file-system-stat", ({ isFile }) => isFile, _duplojs_lang_common.justReturn(false)));
+	}
+	return {
+		path: _duplojs_lang_common.cast(path),
+		getName,
+		getExtension,
+		getMimeType,
+		getParentPath,
+		rename: localRename,
+		exists: localExists,
+		relocate: localRelocate,
+		remove: localRemove,
+		move: localMove,
+		stat: localStat,
+		isFile,
+		[fileInterfaceKind.runTimeKey]: null
+	};
+}
+function isFileInterface(input) {
+	return fileInterfaceKind.has(input);
+}
+const isFileInterfaceFromUnknown = isFileInterface;
+//#endregion
+exports.createFileInterface = createFileInterface;
+exports.isFileInterface = isFileInterface;
+exports.isFileInterfaceFromUnknown = isFileInterfaceFromUnknown;

package/dist/file/fileInterface.d.ts

@@ -0,0 +1,31 @@
+import { RenameResult } from './rename';
+import { ExistsResult } from './exists';
+import { MoveResult } from './move';
+import { RemoveResult } from './remove';
+import { StatResult } from './stat';
+import { RelocateResult } from './relocate';
+import type * as DKind from "@duplojs/lang/kind";
+import * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+declare const fileInterfaceKind: DKind.Handler<DKind.Definition<"@DuplojsServer/fileInterface", unknown>>;
+type FileInterfaceRenameResult = Exclude<RenameResult, DEither.Right> | DEither.Right<"file-system-rename", FileInterface>;
+type FileInterfaceRelocateResult = Exclude<RelocateResult, DEither.Right> | DEither.Right<"file-system-relocate", FileInterface>;
+type FileInterfaceMoveResult = Exclude<MoveResult, DEither.Right> | DEither.Right<"file-system-move", FileInterface>;
+export interface FileInterface<GenericPath extends DPath.AnyPath = DPath.AnyPath> extends DKind.Kind<typeof fileInterfaceKind> {
+    path: GenericPath & DPath.Path;
+    getName(): (string & DPath.Segment & DPath.Path) | null;
+    getMimeType(): string | null;
+    getExtension(params?: DPath.GetExtensionNameParams): (string & DPath.Segment & DPath.Path) | null;
+    getParentPath(): ReturnType<typeof DPath.getParentFolderPath<GenericPath>>;
+    rename(newName: string & DPath.Segment): Promise<FileInterfaceRenameResult>;
+    relocate(parentPath: DPath.AnyPath): Promise<FileInterfaceRelocateResult>;
+    move(newPath: DPath.AnyPath): Promise<FileInterfaceMoveResult>;
+    exists(): Promise<ExistsResult>;
+    remove(): Promise<RemoveResult>;
+    stat(): Promise<StatResult>;
+    isFile(): Promise<boolean>;
+}
+export declare function createFileInterface<GenericPath extends DPath.AnyPath = DPath.AnyPath>(path: GenericPath): FileInterface<GenericPath>;
+export declare function isFileInterface<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, FileInterface>;
+export declare const isFileInterfaceFromUnknown: (input: unknown) => input is FileInterface;
+export {};

package/dist/file/fileInterface.mjs

@@ -0,0 +1,70 @@
+import { createKind } from "../kind.mjs";
+import { stat } from "./stat.mjs";
+import { rename } from "./rename.mjs";
+import { exists } from "./exists.mjs";
+import { move } from "./move.mjs";
+import { remove } from "./remove.mjs";
+import { relocate } from "./relocate.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import * as DPath from "@duplojs/lang/path";
+//#region scripts/file/fileInterface.ts
+const fileInterfaceKind = createKind("fileInterface");
+function createFileInterface(path) {
+	function getName() {
+		return DPath.getBaseName(path);
+	}
+	function getExtension(params) {
+		return DPath.getExtensionName(path, params);
+	}
+	function getMimeType() {
+		const extension = getExtension();
+		if (!extension) return null;
+		return DCommon.mimeType.get(extension) ?? null;
+	}
+	function getParentPath() {
+		return DPath.getParentFolderPath(path);
+	}
+	function localExists() {
+		return exists(path);
+	}
+	function localRename(newName) {
+		return DCommon.asyncPipe(rename(path, newName), DEither.whenIsRight(DCommon.innerPipe(createFileInterface, (value) => DEither.right("file-system-rename", value))));
+	}
+	function localRelocate(newParentPath) {
+		return DCommon.asyncPipe(relocate(path, newParentPath), DEither.whenIsRight(DCommon.innerPipe(createFileInterface, (value) => DEither.right("file-system-relocate", value))));
+	}
+	function localMove(newPath) {
+		return DCommon.asyncPipe(move(path, newPath), DEither.whenIsRight(() => DEither.right("file-system-move", createFileInterface(newPath))));
+	}
+	function localRemove() {
+		return remove(path);
+	}
+	function localStat() {
+		return stat(path);
+	}
+	function isFile() {
+		return DCommon.asyncPipe(localStat(), DEither.whenHasInformationOtherwise("file-system-stat", ({ isFile }) => isFile, DCommon.justReturn(false)));
+	}
+	return {
+		path: DCommon.cast(path),
+		getName,
+		getExtension,
+		getMimeType,
+		getParentPath,
+		rename: localRename,
+		exists: localExists,
+		relocate: localRelocate,
+		remove: localRemove,
+		move: localMove,
+		stat: localStat,
+		isFile,
+		[fileInterfaceKind.runTimeKey]: null
+	};
+}
+function isFileInterface(input) {
+	return fileInterfaceKind.has(input);
+}
+const isFileInterfaceFromUnknown = isFileInterface;
+//#endregion
+export { createFileInterface, isFileInterface, isFileInterfaceFromUnknown };

package/dist/file/folderInterface.cjs

@@ -0,0 +1,76 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_kind = require("../kind.cjs");
+const require_stat = require("./stat.cjs");
+const require_rename = require("./rename.cjs");
+const require_exists = require("./exists.cjs");
+const require_move = require("./move.cjs");
+const require_remove = require("./remove.cjs");
+const require_relocate = require("./relocate.cjs");
+const require_readDirectory = require("./readDirectory.cjs");
+const require_walkDirectory = require("./walkDirectory.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/file/folderInterface.ts
+const folderInterfaceKind = require_kind.createKind("folderInterface");
+function createFolderInterface(path) {
+	function getName() {
+		return _duplojs_lang_path.getBaseName(path);
+	}
+	function getParentPath() {
+		return _duplojs_lang_path.getParentFolderPath(path);
+	}
+	function localRename(newName) {
+		return _duplojs_lang_common.asyncPipe(require_rename.rename(path, newName), _duplojs_lang_either.whenIsRight(_duplojs_lang_common.innerPipe(createFolderInterface, (value) => _duplojs_lang_either.right("file-system-rename", value))));
+	}
+	function localRelocate(newParentPath) {
+		return _duplojs_lang_common.asyncPipe(require_relocate.relocate(path, newParentPath), _duplojs_lang_either.whenIsRight(_duplojs_lang_common.innerPipe(createFolderInterface, (value) => _duplojs_lang_either.right("file-system-relocate", value))));
+	}
+	function localMove(newPath) {
+		return _duplojs_lang_common.asyncPipe(require_move.move(path, newPath), _duplojs_lang_either.whenIsRight(() => _duplojs_lang_either.right("file-system-move", createFolderInterface(newPath))));
+	}
+	function localExists() {
+		return require_exists.exists(path);
+	}
+	function localRemove() {
+		return require_remove.remove(path);
+	}
+	function localStat() {
+		return require_stat.stat(path);
+	}
+	function getChildren() {
+		return require_readDirectory.readDirectory(path);
+	}
+	function walk(params) {
+		return require_walkDirectory.walkDirectory(path, params);
+	}
+	function isFolder() {
+		return _duplojs_lang_common.asyncPipe(localStat(), _duplojs_lang_either.whenHasInformationOtherwise("file-system-stat", ({ isDirectory }) => isDirectory, _duplojs_lang_common.justReturn(false)));
+	}
+	return {
+		path: _duplojs_lang_common.cast(path),
+		getName,
+		getParentPath,
+		move: localMove,
+		rename: localRename,
+		exists: localExists,
+		relocate: localRelocate,
+		remove: localRemove,
+		getChildren,
+		stat: localStat,
+		walk,
+		isFolder,
+		[folderInterfaceKind.runTimeKey]: null
+	};
+}
+function isFolderInterface(input) {
+	return folderInterfaceKind.has(input);
+}
+const isFolderInterfaceFromUnknown = isFolderInterface;
+//#endregion
+exports.createFolderInterface = createFolderInterface;
+exports.isFolderInterface = isFolderInterface;
+exports.isFolderInterfaceFromUnknown = isFolderInterfaceFromUnknown;

package/dist/file/folderInterface.d.ts

@@ -0,0 +1,33 @@
+import { MoveResult } from './move';
+import { ExistsResult } from './exists';
+import { RenameResult } from './rename';
+import { RemoveResult } from './remove';
+import { ReadDirectoryResult } from './readDirectory';
+import { StatResult } from './stat';
+import { WalkDirectoryParams, WalkDirectoryResult } from './walkDirectory';
+import { RelocateResult } from './relocate';
+import type * as DKind from "@duplojs/lang/kind";
+import * as DPath from "@duplojs/lang/path";
+import * as DEither from "@duplojs/lang/either";
+declare const folderInterfaceKind: DKind.Handler<DKind.Definition<"@DuplojsServer/folderInterface", unknown>>;
+type FolderInterfaceRenameResult = Exclude<RenameResult, DEither.Right> | DEither.Right<"file-system-rename", FolderInterface>;
+type FolderInterfaceRelocateResult = Exclude<RelocateResult, DEither.Right> | DEither.Right<"file-system-relocate", FolderInterface>;
+type FolderInterfaceMoveResult = Exclude<MoveResult, DEither.Right> | DEither.Right<"file-system-move", FolderInterface>;
+export interface FolderInterface<GenericPath extends DPath.AnyPath = DPath.AnyPath> extends DKind.Kind<typeof folderInterfaceKind> {
+    path: GenericPath & DPath.Path;
+    getName(): (string & DPath.Segment & DPath.Path) | null;
+    getParentPath(): ReturnType<typeof DPath.getParentFolderPath<GenericPath>>;
+    rename(newName: (string & DPath.Segment)): Promise<FolderInterfaceRenameResult>;
+    exists(): Promise<ExistsResult>;
+    relocate(parentPath: DPath.AnyPath): Promise<FolderInterfaceRelocateResult>;
+    move(newPath: DPath.AnyPath): Promise<FolderInterfaceMoveResult>;
+    remove(): Promise<RemoveResult>;
+    getChildren(): Promise<ReadDirectoryResult>;
+    stat(): Promise<StatResult>;
+    walk(params?: WalkDirectoryParams): Promise<WalkDirectoryResult>;
+    isFolder(): Promise<boolean>;
+}
+export declare function createFolderInterface<GenericPath extends DPath.AnyPath = DPath.AnyPath>(path: GenericPath): FolderInterface<GenericPath>;
+export declare function isFolderInterface<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, FolderInterface>;
+export declare const isFolderInterfaceFromUnknown: (input: unknown) => input is FolderInterface;
+export {};

package/dist/file/folderInterface.mjs

@@ -0,0 +1,70 @@
+import { createKind } from "../kind.mjs";
+import { stat } from "./stat.mjs";
+import { rename } from "./rename.mjs";
+import { exists } from "./exists.mjs";
+import { move } from "./move.mjs";
+import { remove } from "./remove.mjs";
+import { relocate } from "./relocate.mjs";
+import { readDirectory } from "./readDirectory.mjs";
+import { walkDirectory } from "./walkDirectory.mjs";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import * as DPath from "@duplojs/lang/path";
+//#region scripts/file/folderInterface.ts
+const folderInterfaceKind = createKind("folderInterface");
+function createFolderInterface(path) {
+	function getName() {
+		return DPath.getBaseName(path);
+	}
+	function getParentPath() {
+		return DPath.getParentFolderPath(path);
+	}
+	function localRename(newName) {
+		return DCommon.asyncPipe(rename(path, newName), DEither.whenIsRight(DCommon.innerPipe(createFolderInterface, (value) => DEither.right("file-system-rename", value))));
+	}
+	function localRelocate(newParentPath) {
+		return DCommon.asyncPipe(relocate(path, newParentPath), DEither.whenIsRight(DCommon.innerPipe(createFolderInterface, (value) => DEither.right("file-system-relocate", value))));
+	}
+	function localMove(newPath) {
+		return DCommon.asyncPipe(move(path, newPath), DEither.whenIsRight(() => DEither.right("file-system-move", createFolderInterface(newPath))));
+	}
+	function localExists() {
+		return exists(path);
+	}
+	function localRemove() {
+		return remove(path);
+	}
+	function localStat() {
+		return stat(path);
+	}
+	function getChildren() {
+		return readDirectory(path);
+	}
+	function walk(params) {
+		return walkDirectory(path, params);
+	}
+	function isFolder() {
+		return DCommon.asyncPipe(localStat(), DEither.whenHasInformationOtherwise("file-system-stat", ({ isDirectory }) => isDirectory, DCommon.justReturn(false)));
+	}
+	return {
+		path: DCommon.cast(path),
+		getName,
+		getParentPath,
+		move: localMove,
+		rename: localRename,
+		exists: localExists,
+		relocate: localRelocate,
+		remove: localRemove,
+		getChildren,
+		stat: localStat,
+		walk,
+		isFolder,
+		[folderInterfaceKind.runTimeKey]: null
+	};
+}
+function isFolderInterface(input) {
+	return folderInterfaceKind.has(input);
+}
+const isFolderInterfaceFromUnknown = isFolderInterface;
+//#endregion
+export { createFolderInterface, isFolderInterface, isFolderInterfaceFromUnknown };