ts-utility-kit 1.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shion Terunaga
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,202 @@
+# ts-utility-kit
+
+Shared TypeScript utilities packaged.
+
+[日本語 README](./README.ja.md)
+
+## Install From npm
+
+```bash
+npm i ts-utility-kit
+```
+
+Use this when you want to install the latest published version from the npm registry.
+
+## Install From GitHub
+
+```bash
+npm i github:ShionTerunaga/ts-utility-kit#release
+```
+
+Use this when you want to install directly from the built `release` branch on GitHub.
+
+To pin a specific version, install from a version tag instead of `release`.
+
+```bash
+npm i github:ShionTerunaga/ts-utility-kit#v1.5.1
+```
+
+## Usage
+
+```ts
+import { envParse, optionUtility, resultUtility } from "ts-utility-kit";
+
+const env = envParse(process.env.API_TOKEN);
+
+if (env.isSome) {
+  console.log("token exists:", env.value);
+}
+```
+
+The built files are committed to the `release` branch, so the package can be installed directly from this GitHub repository without running build scripts.
+Version tags are created in the `vxx.yy.zz` format, for example `v2.0.0`.
+
+## Included Utilities
+
+All public APIs are exported from the package root.
+
+### `optionUtility` and `envParse`
+
+Use `optionUtility` when you want to represent nullable values as an explicit `Some | None` union.
+Use `envParse` when you want to convert `process.env` style values into an `Option<string>`.
+
+```ts
+import { envParse, optionUtility } from "ts-utility-kit";
+
+const token = envParse(process.env.API_TOKEN);
+const nickname = optionUtility.optionConversion(user.nickname);
+
+if (token.isSome) {
+  console.log(token.value);
+}
+
+const fallback = nickname.isSome ? nickname.value : "guest";
+```
+
+Available helpers:
+
+- `optionUtility.createSome(value)`
+- `optionUtility.createNone()`
+- `optionUtility.optionConversion(value)`
+
+### `resultUtility`
+
+Use `resultUtility` when you want functions to return `Ok | Err` values instead of throwing directly.
+
+```ts
+import { resultUtility } from "ts-utility-kit";
+
+const result = await resultUtility.checkPromiseReturn({
+  fn: async () => {
+    return await fetchUser();
+  },
+  err: (error) => {
+    return resultUtility.createNg(error);
+  },
+});
+
+if (result.isOk) {
+  console.log(result.value);
+} else {
+  console.error(result.err);
+}
+```
+
+Available helpers:
+
+- `resultUtility.createOk(value)`
+- `resultUtility.createNg(error)`
+- `resultUtility.checkResultReturn({ fn, err, finalFn? })`
+- `resultUtility.checkResultVoid({ fn, err, finalFn? })`
+- `resultUtility.checkPromiseReturn({ fn, err, finalFn? })`
+- `resultUtility.checkPromiseVoid({ fn, err, finalFn? })`
+- `resultUtility.UNIT`
+
+### Error classes
+
+Use the custom error classes when you want consistent error names, codes, and metadata.
+
+```ts
+import { BadRequestError, SchemeError, ValidationError } from "ts-utility-kit";
+
+throw new ValidationError({
+  field: "email",
+  issues: [{ path: "email", message: "Invalid format" }],
+});
+
+throw new SchemeError({
+  allowedSchemes: ["https"],
+  receivedScheme: "http",
+});
+
+throw new BadRequestError({
+  details: { reason: "Missing query parameter" },
+});
+```
+
+Included error exports:
+
+- `BaseError`
+- `BaseHttpError` and HTTP subclasses such as `BadRequestError`, `UnauthorizedError`, `NotFoundError`, `ConflictError`, `TooManyRequestsError`, and `InternalServerError`
+- `SchemeError`
+- `ValidationError`
+
+### `classMerger`
+
+Use `classMerger` to deduplicate class names while preserving order.
+
+```ts
+import { classMerger } from "ts-utility-kit";
+
+const className = classMerger(["button", "", "button", "primary"]);
+// "button primary"
+```
+
+### `omitElementObject`
+
+Use `omitElementObject` to create a new object without specific keys.
+
+```ts
+import { omitElementObject } from "ts-utility-kit";
+
+const user = {
+  id: 1,
+  name: "Shion",
+  password: "secret",
+};
+
+const safeUser = omitElementObject(user, ["password"]);
+```
+
+### `isNull` and `isUndefined`
+
+Use the type guards when narrowing unknown values.
+
+```ts
+import { isNull, isUndefined } from "ts-utility-kit";
+
+function normalize(value: unknown) {
+  if (isNull(value) || isUndefined(value)) {
+    return "empty";
+  }
+
+  return String(value);
+}
+```
+
+### Utility types
+
+The package also exports these TypeScript-only utility types:
+
+- `Dict<T>`
+- `Without<T, K>`
+
+## Development
+
+```bash
+vp install
+vp check
+vp test
+vp build
+```
+
+## Release Flow
+
+Create a changeset for user-facing changes before opening or merging a PR.
+
+```bash
+vp run changeset
+```
+
+The `Release PR` workflow opens or updates the Changesets release PR into `main`. When that release PR branch (`changeset-release/main`) is merged into `main`, the `Sync Release` workflow reflects the merged commit to `release`. After `release` is updated, the `Publish Release` workflow generates release notes from the latest `CHANGELOG.md` entry and then creates or updates the Git tag and GitHub Release.
+Each generated changelog item will also include the source PR and the contributor's GitHub username.

package/dist/index.d.mts

@@ -0,0 +1,232 @@
+//#region src/merger/class-merger.d.ts
+declare function classMerger(classes: ReadonlyArray<string>): string;
+//#endregion
+//#region src/error/base-error.d.ts
+interface BaseErrorOptions {
+  cause?: unknown;
+  code?: string;
+  details?: unknown;
+  message?: string;
+  name?: string;
+}
+declare class BaseError extends Error {
+  cause?: unknown;
+  code?: string;
+  details?: unknown;
+  constructor(options?: BaseErrorOptions);
+}
+//#endregion
+//#region src/error/http-error.d.ts
+interface HttpErrorOptions extends BaseErrorOptions {
+  expose?: boolean;
+  status?: number;
+  statusText?: string;
+}
+declare class BaseHttpError extends BaseError {
+  expose: boolean;
+  status: number;
+  statusText: string;
+  constructor(options?: HttpErrorOptions);
+}
+declare class UnauthorizedError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class BadRequestError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class PaymentRequiredError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class ForbiddenError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class MethodNotAllowedError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class NotAcceptableError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class ProxyAuthenticationRequiredError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class NotFoundError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class ConflictError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class GoneError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class PreconditionFailedError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class PayloadTooLargeError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class UnsupportedMediaTypeError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class UnprocessableEntityError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class TooManyRequestsError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class TimeoutError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class InternalServerError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class NotImplementedError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class BadGatewayError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class ServiceUnavailableError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+declare class GatewayTimeoutError extends BaseHttpError {
+  constructor(options?: HttpErrorOptions);
+}
+//#endregion
+//#region src/error/scheme-error.d.ts
+interface SchemeErrorOptions extends BaseErrorOptions {
+  allowedSchemes?: string[];
+  receivedScheme?: string;
+}
+declare class SchemeError extends BaseError {
+  readonly allowedSchemes: string[];
+  readonly receivedScheme?: string;
+  constructor(options?: SchemeErrorOptions);
+}
+//#endregion
+//#region src/error/validation-error.d.ts
+interface ValidationIssue {
+  message: string;
+  path?: string;
+}
+interface ValidationErrorOptions extends BaseErrorOptions {
+  field?: string;
+  issues?: ValidationIssue[];
+}
+declare class ValidationError extends BaseError {
+  readonly field?: string;
+  readonly issues: ValidationIssue[];
+  constructor(options?: ValidationErrorOptions);
+}
+//#endregion
+//#region src/common/is.d.ts
+declare function isNull(value: unknown): value is null;
+declare function isUndefined(value: unknown): value is undefined;
+//#endregion
+//#region src/object/object.d.ts
+declare function omitElementObject<T extends object, S extends keyof T>(obj: T, keys: S[]): Omit<T, S>;
+//#endregion
+//#region src/non-nullable/option.d.ts
+declare const basic$1: {
+  readonly OPTION_SOME: "some";
+  readonly OPTION_NONE: "none";
+};
+interface Some<T> {
+  readonly kind: typeof basic$1.OPTION_SOME;
+  readonly isSome: true;
+  readonly isNone: false;
+  readonly value: T;
+}
+interface None {
+  readonly kind: typeof basic$1.OPTION_NONE;
+  readonly isSome: false;
+  readonly isNone: true;
+}
+type Option<T> = Some<NonNullable<T>> | None;
+declare const optionUtility: Readonly<{
+  createSome: <T>(value: NonNullable<T>) => Option<T>;
+  createNone: () => Option<never>;
+  optionConversion: <T>(value: T) => Option<T>;
+}>;
+//#endregion
+//#region src/non-nullable/env-parse.d.ts
+declare function envParse(env: string | undefined): Option<string>;
+//#endregion
+//#region src/non-nullable/result.d.ts
+declare const basic: {
+  readonly RESULT_OK: "ok";
+  readonly RESULT_NG: "ng";
+};
+interface OK<T> {
+  readonly kind: typeof basic.RESULT_OK;
+  readonly isOk: true;
+  readonly isErr: false;
+  readonly value: T;
+}
+interface NG<E> {
+  readonly kind: typeof basic.RESULT_NG;
+  readonly isOk: false;
+  readonly isErr: true;
+  readonly err: E;
+}
+interface CheckResultReturn<T, E> {
+  fn: () => NonNullable<T>;
+  err: (e: unknown) => Result<never, NonNullable<E>>;
+  finalFn?: () => void;
+}
+interface CheckResultVoid<E> {
+  fn: () => void;
+  err: (e: unknown) => Result<never, NonNullable<E>>;
+  finalFn?: () => void;
+}
+interface CheckPromiseReturn<T, E> {
+  fn: () => Promise<NonNullable<T>>;
+  err: (e: unknown) => Result<never, NonNullable<E>>;
+  finalFn?: () => void;
+}
+interface CheckPromiseVoid<E> {
+  fn: () => Promise<void>;
+  err: (e: unknown) => Result<never, NonNullable<E>>;
+  finalFn?: () => void;
+}
+declare const UNIT_SYMBOL: unique symbol;
+interface Unit {
+  readonly _unit: typeof UNIT_SYMBOL;
+}
+type Result<T, E> = OK<NonNullable<T>> | NG<NonNullable<E>>;
+declare const resultUtility: Readonly<{
+  UNIT: Unit;
+  checkResultReturn: <T, E>({
+    fn,
+    err,
+    finalFn
+  }: CheckResultReturn<T, E>) => Result<T, E>;
+  checkResultVoid: <E>({
+    fn,
+    err,
+    finalFn
+  }: CheckResultVoid<E>) => Result<Unit, E>;
+  checkPromiseReturn: <T, E>({
+    fn,
+    err,
+    finalFn
+  }: CheckPromiseReturn<T, E>) => Promise<Result<T, E>>;
+  checkPromiseVoid: <E>({
+    fn,
+    err,
+    finalFn
+  }: CheckPromiseVoid<E>) => Promise<Result<Unit, E>>;
+  createOk: <T>(value: NonNullable<T>) => Result<T, never>;
+  createNg: <E>(err: NonNullable<E>) => Result<never, E>;
+}>;
+//#endregion
+//#region src/types/object.d.ts
+/**
+ * 柔軟なオブジェクト
+ */
+type Dict<T> = Record<string, T>;
+/**
+ * Omitよりも厳密に型をチェックする(Omitは余計なプロパティを許容してしまう)
+ */
+type Without<T, K extends keyof T> = { [P in Exclude<keyof T, K>]: T[P] } & { [P in K]?: never };
+//#endregion
+export { BadGatewayError, BadRequestError, BaseError, type BaseErrorOptions, BaseHttpError, ConflictError, type Dict, ForbiddenError, GatewayTimeoutError, GoneError, type HttpErrorOptions, InternalServerError, MethodNotAllowedError, NotAcceptableError, NotFoundError, NotImplementedError, type Option, PayloadTooLargeError, PaymentRequiredError, PreconditionFailedError, ProxyAuthenticationRequiredError, type Result, SchemeError, type SchemeErrorOptions, ServiceUnavailableError, TimeoutError, TooManyRequestsError, UnauthorizedError, type Unit, UnprocessableEntityError, UnsupportedMediaTypeError, ValidationError, type ValidationErrorOptions, type ValidationIssue, type Without, classMerger, envParse, isNull, isUndefined, omitElementObject, optionUtility, resultUtility };

package/dist/index.mjs

@@ -0,0 +1,495 @@
+//#region src/merger/class-merger.ts
+function classMerger(classes) {
+	const length = classes.length;
+	if (length === 0) return "";
+	const firstClass = classes[0];
+	if (length === 1) return firstClass;
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (let index = 0; index < length; index += 1) {
+		const cls = classes[index];
+		if (cls === "" || seen.has(cls)) continue;
+		seen.add(cls);
+		out.push(cls);
+	}
+	return out.length === 1 ? out[0] : out.join(" ");
+}
+//#endregion
+//#region src/error/base-error.ts
+var BaseError = class extends Error {
+	constructor(options = {}) {
+		const { cause, code, details, message = "Application Error", name = "BaseError" } = options;
+		super(message, cause === void 0 ? void 0 : { cause });
+		this.name = name;
+		this.code = code;
+		this.details = details;
+		if (cause !== void 0 && !("cause" in this)) Object.defineProperty(this, "cause", {
+			configurable: true,
+			enumerable: false,
+			value: cause,
+			writable: true
+		});
+	}
+};
+//#endregion
+//#region src/error/http-error.ts
+var BaseHttpError = class extends BaseError {
+	expose;
+	status;
+	statusText;
+	constructor(options = {}) {
+		const { cause, code, details, expose, message, name = "BaseHttpError", status, statusText } = options;
+		super({
+			cause,
+			code,
+			details,
+			message,
+			name
+		});
+		this.expose = expose ?? false;
+		this.status = status ?? 500;
+		this.statusText = statusText ?? "Internal Server Error";
+	}
+};
+var UnauthorizedError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "UNAUTHORIZED",
+			expose: true,
+			message: "Unauthorized",
+			name: "UnauthorizedError",
+			status: 401,
+			statusText: "Unauthorized",
+			...options
+		});
+	}
+};
+var BadRequestError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "BAD_REQUEST",
+			expose: true,
+			message: "Bad Request",
+			name: "BadRequestError",
+			status: 400,
+			statusText: "Bad Request",
+			...options
+		});
+	}
+};
+var PaymentRequiredError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "PAYMENT_REQUIRED",
+			expose: true,
+			message: "Payment Required",
+			name: "PaymentRequiredError",
+			status: 402,
+			statusText: "Payment Required",
+			...options
+		});
+	}
+};
+var ForbiddenError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "FORBIDDEN",
+			expose: true,
+			message: "Forbidden",
+			name: "ForbiddenError",
+			status: 403,
+			statusText: "Forbidden",
+			...options
+		});
+	}
+};
+var MethodNotAllowedError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "METHOD_NOT_ALLOWED",
+			expose: true,
+			message: "Method Not Allowed",
+			name: "MethodNotAllowedError",
+			status: 405,
+			statusText: "Method Not Allowed",
+			...options
+		});
+	}
+};
+var NotAcceptableError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "NOT_ACCEPTABLE",
+			expose: true,
+			message: "Not Acceptable",
+			name: "NotAcceptableError",
+			status: 406,
+			statusText: "Not Acceptable",
+			...options
+		});
+	}
+};
+var ProxyAuthenticationRequiredError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "PROXY_AUTHENTICATION_REQUIRED",
+			expose: true,
+			message: "Proxy Authentication Required",
+			name: "ProxyAuthenticationRequiredError",
+			status: 407,
+			statusText: "Proxy Authentication Required",
+			...options
+		});
+	}
+};
+var NotFoundError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "NOT_FOUND",
+			expose: true,
+			message: "Not Found",
+			name: "NotFoundError",
+			status: 404,
+			statusText: "Not Found",
+			...options
+		});
+	}
+};
+var ConflictError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "CONFLICT",
+			expose: true,
+			message: "Conflict",
+			name: "ConflictError",
+			status: 409,
+			statusText: "Conflict",
+			...options
+		});
+	}
+};
+var GoneError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "GONE",
+			expose: true,
+			message: "Gone",
+			name: "GoneError",
+			status: 410,
+			statusText: "Gone",
+			...options
+		});
+	}
+};
+var PreconditionFailedError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "PRECONDITION_FAILED",
+			expose: true,
+			message: "Precondition Failed",
+			name: "PreconditionFailedError",
+			status: 412,
+			statusText: "Precondition Failed",
+			...options
+		});
+	}
+};
+var PayloadTooLargeError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "PAYLOAD_TOO_LARGE",
+			expose: true,
+			message: "Payload Too Large",
+			name: "PayloadTooLargeError",
+			status: 413,
+			statusText: "Payload Too Large",
+			...options
+		});
+	}
+};
+var UnsupportedMediaTypeError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "UNSUPPORTED_MEDIA_TYPE",
+			expose: true,
+			message: "Unsupported Media Type",
+			name: "UnsupportedMediaTypeError",
+			status: 415,
+			statusText: "Unsupported Media Type",
+			...options
+		});
+	}
+};
+var UnprocessableEntityError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "UNPROCESSABLE_ENTITY",
+			expose: true,
+			message: "Unprocessable Entity",
+			name: "UnprocessableEntityError",
+			status: 422,
+			statusText: "Unprocessable Entity",
+			...options
+		});
+	}
+};
+var TooManyRequestsError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "TOO_MANY_REQUESTS",
+			expose: true,
+			message: "Too Many Requests",
+			name: "TooManyRequestsError",
+			status: 429,
+			statusText: "Too Many Requests",
+			...options
+		});
+	}
+};
+var TimeoutError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "REQUEST_TIMEOUT",
+			expose: true,
+			message: "Request Timeout",
+			name: "TimeoutError",
+			status: 408,
+			statusText: "Request Timeout",
+			...options
+		});
+	}
+};
+var InternalServerError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "INTERNAL_SERVER_ERROR",
+			expose: false,
+			message: "Internal Server Error",
+			name: "InternalServerError",
+			status: 500,
+			statusText: "Internal Server Error",
+			...options
+		});
+	}
+};
+var NotImplementedError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "NOT_IMPLEMENTED",
+			expose: false,
+			message: "Not Implemented",
+			name: "NotImplementedError",
+			status: 501,
+			statusText: "Not Implemented",
+			...options
+		});
+	}
+};
+var BadGatewayError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "BAD_GATEWAY",
+			expose: false,
+			message: "Bad Gateway",
+			name: "BadGatewayError",
+			status: 502,
+			statusText: "Bad Gateway",
+			...options
+		});
+	}
+};
+var ServiceUnavailableError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "SERVICE_UNAVAILABLE",
+			expose: false,
+			message: "Service Unavailable",
+			name: "ServiceUnavailableError",
+			status: 503,
+			statusText: "Service Unavailable",
+			...options
+		});
+	}
+};
+var GatewayTimeoutError = class extends BaseHttpError {
+	constructor(options = {}) {
+		super({
+			code: "GATEWAY_TIMEOUT",
+			expose: false,
+			message: "Gateway Timeout",
+			name: "GatewayTimeoutError",
+			status: 504,
+			statusText: "Gateway Timeout",
+			...options
+		});
+	}
+};
+//#endregion
+//#region src/error/scheme-error.ts
+var SchemeError = class extends BaseError {
+	allowedSchemes;
+	receivedScheme;
+	constructor(options = {}) {
+		const { allowedSchemes = [], receivedScheme, ...baseOptions } = options;
+		const allowedText = allowedSchemes.length === 0 ? "none" : allowedSchemes.join(", ");
+		super({
+			code: "INVALID_SCHEME",
+			message: `Invalid scheme: expected one of [${allowedText}], received "${receivedScheme ?? "unknown"}"`,
+			name: "SchemeError",
+			...baseOptions
+		});
+		this.allowedSchemes = allowedSchemes;
+		this.receivedScheme = receivedScheme;
+	}
+};
+//#endregion
+//#region src/error/validation-error.ts
+var ValidationError = class extends BaseError {
+	field;
+	issues;
+	constructor(options = {}) {
+		const { field, issues = [], ...baseOptions } = options;
+		const message = baseOptions.message ?? (field ? `Validation failed for "${field}"` : "Validation failed");
+		super({
+			code: "VALIDATION_ERROR",
+			...baseOptions,
+			message,
+			name: "ValidationError"
+		});
+		this.field = field;
+		this.issues = issues;
+	}
+};
+//#endregion
+//#region src/common/is.ts
+function isNull(value) {
+	return value === null;
+}
+function isUndefined(value) {
+	return value === void 0;
+}
+//#endregion
+//#region src/object/object.ts
+function omitElementObject(obj, keys) {
+	const entries = Object.entries(obj).filter(([k]) => {
+		return !keys.some((key) => String(key) === k);
+	});
+	const typedResult = {};
+	for (const [k, v] of entries) typedResult[k] = v;
+	return typedResult;
+}
+//#endregion
+//#region src/non-nullable/option.ts
+const basic$1 = {
+	OPTION_SOME: "some",
+	OPTION_NONE: "none"
+};
+const optionUtility = (function() {
+	const { OPTION_SOME, OPTION_NONE } = basic$1;
+	const createSome = (value) => {
+		return Object.freeze({
+			kind: OPTION_SOME,
+			isSome: true,
+			isNone: false,
+			value
+		});
+	};
+	const createNone = () => {
+		return Object.freeze({
+			kind: OPTION_NONE,
+			isSome: false,
+			isNone: true
+		});
+	};
+	const optionConversion = (value) => {
+		if (value === null || value === void 0) return createNone();
+		return createSome(value);
+	};
+	return Object.freeze({
+		createSome,
+		createNone,
+		optionConversion
+	});
+})();
+//#endregion
+//#region src/non-nullable/env-parse.ts
+function envParse(env) {
+	const { optionConversion } = optionUtility;
+	return optionConversion(env);
+}
+//#endregion
+//#region src/non-nullable/result.ts
+const basic = {
+	RESULT_OK: "ok",
+	RESULT_NG: "ng"
+};
+const UNIT_SYMBOL = Symbol("UNIT_SYMBOL");
+const resultUtility = (function() {
+	const { RESULT_NG, RESULT_OK } = basic;
+	const UNIT = Object.freeze({ _unit: UNIT_SYMBOL });
+	const checkPromiseReturn = async ({ fn, err, finalFn = () => {} }) => {
+		try {
+			return createOk(await fn());
+		} catch (e) {
+			return err(e);
+		} finally {
+			finalFn();
+		}
+	};
+	const checkPromiseVoid = async ({ fn, err, finalFn = () => {} }) => {
+		try {
+			await fn();
+			return createOk(UNIT);
+		} catch (e) {
+			return err(e);
+		} finally {
+			finalFn();
+		}
+	};
+	const checkResultReturn = ({ fn, err, finalFn = () => {} }) => {
+		try {
+			return createOk(fn());
+		} catch (e) {
+			return err(e);
+		} finally {
+			finalFn();
+		}
+	};
+	const checkResultVoid = ({ fn, err, finalFn = () => {} }) => {
+		try {
+			fn();
+			return createOk(UNIT);
+		} catch (e) {
+			return err(e);
+		} finally {
+			finalFn();
+		}
+	};
+	const createOk = (value) => {
+		return Object.freeze({
+			kind: RESULT_OK,
+			isOk: true,
+			isErr: false,
+			value
+		});
+	};
+	const createNg = (err) => {
+		return Object.freeze({
+			kind: RESULT_NG,
+			isOk: false,
+			isErr: true,
+			err
+		});
+	};
+	return Object.freeze({
+		UNIT,
+		checkResultReturn,
+		checkResultVoid,
+		checkPromiseReturn,
+		checkPromiseVoid,
+		createOk,
+		createNg
+	});
+})();
+//#endregion
+export { BadGatewayError, BadRequestError, BaseError, BaseHttpError, ConflictError, ForbiddenError, GatewayTimeoutError, GoneError, InternalServerError, MethodNotAllowedError, NotAcceptableError, NotFoundError, NotImplementedError, PayloadTooLargeError, PaymentRequiredError, PreconditionFailedError, ProxyAuthenticationRequiredError, SchemeError, ServiceUnavailableError, TimeoutError, TooManyRequestsError, UnauthorizedError, UnprocessableEntityError, UnsupportedMediaTypeError, ValidationError, classMerger, envParse, isNull, isUndefined, omitElementObject, optionUtility, resultUtility };

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "ts-utility-kit",
+  "version": "1.4.0",
+  "description": "Shared TypeScript utilities with generated type definitions.",
+  "homepage": "https://github.com/ShionTerunaga/ts-shared#readme",
+  "bugs": {
+    "url": "https://github.com/ShionTerunaga/ts-shared/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShionTerunaga/ts-shared.git"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "package.json",
+    "README.md"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  }
+}