@sorrell/utilities 1.2.5 → 1.2.6

package/Distribution/index.js

@@ -0,0 +1,674 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// Source/Array/index.ts
+var Array_exports = {};
+__export(Array_exports, {
+  FilterDefined: () => FilterDefined
+});
+
+// Source/Array/Array.ts
+function FilterDefined(Array) {
+  return Array.filter((Element) => {
+    return Element !== void 0;
+  });
+}
+
+// Source/Async/index.ts
+var Async_exports = {};
+__export(Async_exports, {
+  FPromiseInstantiationError: () => FPromiseInstantiationError,
+  Map: () => Map,
+  TPromise: () => TPromise,
+  TPromiseLike: () => TPromiseLike,
+  Try: () => Try
+});
+
+// Source/Miscellaneous/Utility.Types.ts
+var AbstractMethodCallError = class extends Error {
+  constructor(ClassName) {
+    super(ClassName);
+  }
+};
+
+// Source/Async/Async.ts
+async function Try(Source) {
+  try {
+    const Data2 = typeof Source === "function" ? await Source() : await Source;
+    return {
+      Data: Data2,
+      Error: void 0
+    };
+  } catch (ErrorValue) {
+    return {
+      Data: void 0,
+      Error: ErrorValue
+    };
+  }
+}
+async function Map(Elements, Mapper) {
+  const MapperWrapped = async (Element) => {
+    return Mapper(Element);
+  };
+  const Out = Elements.map(MapperWrapped);
+  return await Promise.all(Out);
+}
+var TPromiseLike = class {
+  then(_OnFulfilled, _OnRejected) {
+    throw new AbstractMethodCallError("TPromiseLike");
+  }
+};
+var FPromiseInstantiationError = class extends TypeError {
+  constructor() {
+    super();
+  }
+};
+var TPromise = class _TPromise extends TPromiseLike {
+  constructor(Argument) {
+    super();
+    if (typeof Argument === "function") {
+      this.Underlying = new Promise(Argument);
+    } else {
+      if (Argument instanceof _TPromise) {
+        this.Underlying = Argument.Raw();
+      } else if (Argument instanceof Promise) {
+        this.Underlying = Argument;
+      }
+    }
+    throw new FPromiseInstantiationError();
+  }
+  /**
+   * This class's extension of {@link Promise!then}.
+   *
+   * @template ResultType - The type to which the value underlying the {@link TPromise} returned by this
+   * will resolve, if the {@link TPromise} resolves.
+   *
+   * @template RejectType - The type to which the value underlying the {@link TPromise} returned by this
+   * will reject, if the {@link TPromise} rejects.
+   *
+   * @param OnFulfilled - The callback that is called when the underlying {@link Promise} resolves,
+   * if it resolves.
+   *
+   * @param OnRejected - The callback that is called when the underlying {@link Promise} rejects,
+   * if it rejects.
+   *
+   * @returns {TPromise<ResultType | RejectType>} A new {@link TPromise} of the result of the
+   * given callbacks.
+   *
+   * @example
+   * ```typescript
+   * const Example: TPromise<string> = new TPromise<string>((Resolve, Reject) =>
+   * {
+   *     if (Math.random() < 0.5)
+   *     {
+   *         Resolve("Success");
+   *     }
+   *     else
+   *     {
+   *         Reject("Error");
+   *     }
+   * });
+   *
+   * Example.then(
+   *     (Value: string): void =>
+   *     {
+   *         // `Value` <- `"Success"`
+   *     },
+   *     (Reason: unknown): void =>
+   *     {
+   *         // `Reason` <- `"Error"`
+   *     }
+   * );
+   * ```
+   */
+  Then(OnFulfilled, OnRejected) {
+    return new _TPromise(this.Underlying.then(OnFulfilled, OnRejected));
+  }
+  then(OnFulfilled, OnRejected) {
+    return new _TPromise(this.Underlying.then(OnFulfilled, OnRejected));
+  }
+  Catch(OnRejected) {
+    return new _TPromise(this.Underlying.catch(OnRejected));
+  }
+  Finally(OnFinally) {
+    return new _TPromise(this.Underlying.finally(OnFinally));
+  }
+  static Resolve(Value) {
+    return new _TPromise(Promise.resolve(Value));
+  }
+  static Reject(Reason) {
+    return new _TPromise(Promise.reject(Reason));
+  }
+  Raw() {
+    return this.Underlying;
+  }
+};
+
+// Source/Math/Complex.ts
+var Complex_exports = {};
+__export(Complex_exports, {
+  FComplex: () => FComplex,
+  i: () => i
+});
+
+// Source/Math/Complex.Internal.ts
+var MathBuiltin = Math;
+
+// Source/Math/Complex.ts
+import { Operator } from "tsover-runtime";
+var _FComplex = class _FComplex {
+  constructor(A, B = 0) {
+    if (typeof A === "number") {
+      this.Re = A;
+      this.Im = B;
+    } else {
+      this.Re = A.Re;
+      this.Im = A.Im;
+    }
+  }
+  /**
+   * Get the modulus of this {@link FComplex} number.
+   *
+   * @returns {number} The modulus of this {@link FComplex} number.
+   */
+  get Mod() {
+    return MathBuiltin.sqrt(this.Re ** 2 + this.Im ** 2);
+  }
+  /**
+   * Get the modulus of this {@link FComplex} number.
+   *
+   * @returns {number} The modulus of this {@link FComplex} number.
+   */
+  get Theta() {
+    const Out = MathBuiltin.atan2(this.Im, this.Re);
+    if (Out < 0) {
+      return Out + 2 * MathBuiltin.PI;
+    }
+    return Out;
+  }
+  [Operator.star](A, B) {
+    if (typeof A === "number") {
+      return new _FComplex(B.Re * A, B.Im * A);
+    } else if (typeof B === "number") {
+      return new _FComplex(A.Re * B, A.Im * B);
+    } else {
+      return new _FComplex(A.Re + B.Re - (A.Im + B.Im), A.Re + B.Im + (B.Re + A.Im));
+    }
+  }
+  [Operator.plus](A, B) {
+    if (typeof A === "number") {
+      return new _FComplex(A + B.Re, B.Im);
+    } else if (typeof B === "number") {
+      return new _FComplex(A.Re + B, A.Im);
+    } else {
+      return new _FComplex(A.Re + B.Re, A.Im + B.Im);
+    }
+  }
+};
+_FComplex.Zero = new _FComplex(0, 0);
+var FComplex = _FComplex;
+var i = new FComplex(0, 1);
+
+// Source/FileSystem/index.ts
+var FileSystem_exports = {};
+__export(FileSystem_exports, {
+  GetSafeNewPath: () => GetSafeNewPath,
+  IsSupportedFileExtension: () => IsSupportedFileExtension,
+  IsValidFileName: () => IsValidFileName,
+  WriteTextFile: () => WriteTextFile
+});
+
+// Source/FileSystem/FileSystem.ts
+import { basename, dirname, extname, join } from "path";
+import { promises as Fs } from "fs";
+import { constants as FsConstants } from "fs";
+import os from "os";
+async function PathExists(Path) {
+  try {
+    await Fs.access(Path, FsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function IsSupportedFileExtension(Extension) {
+  let NormalizedExtension = Extension.slice(1);
+  if (NormalizedExtension.startsWith(".")) {
+    NormalizedExtension = NormalizedExtension.slice(1);
+  }
+  if (NormalizedExtension.length === 0) {
+    return false;
+  }
+  if (NormalizedExtension.includes("/") || NormalizedExtension.includes("\\") || NormalizedExtension.includes("\0")) {
+    return false;
+  }
+  if (os.platform() === "win32") {
+    const HasIllegalCharacters = /[<>:"/\\|?*\x00-\x1F]/u.test(NormalizedExtension);
+    if (HasIllegalCharacters) {
+      return false;
+    }
+    if (/[ .]$/u.test(NormalizedExtension)) {
+      return false;
+    }
+  }
+  return true;
+}
+async function GetSafeNewPath(InPath) {
+  const DirectoryPath = dirname(InPath);
+  const Extension = extname(InPath);
+  const FileName = basename(InPath);
+  const BaseFileName = Extension === "" ? FileName : basename(InPath, Extension);
+  let CandidatePath = InPath;
+  let Index = 1;
+  while (await PathExists(CandidatePath)) {
+    const CandidateFileName = `${BaseFileName} (${Index})${Extension}`;
+    CandidatePath = join(DirectoryPath, CandidateFileName);
+    Index++;
+  }
+  return CandidatePath;
+}
+async function IsValidFileName(DirectoryPath, FileName, PersistNewFile = false, Extension = void 0) {
+  const ExtensionSafe = Extension !== void 0 ? Extension.startsWith(".") && IsSupportedFileExtension(Extension) ? Extension : null : "";
+  const IsExtensionImproper = ExtensionSafe === null || ExtensionSafe === "." || !FileName.endsWith(ExtensionSafe);
+  if (IsExtensionImproper) {
+    return false;
+  }
+  const FilePath = join(DirectoryPath, FileName);
+  try {
+    const ThisFileHandle = await Fs.open(FilePath, "wx");
+    await ThisFileHandle.close();
+    if (!PersistNewFile) {
+      await Fs.unlink(FilePath);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function WriteTextFile(Path, Contents) {
+  await Fs.writeFile(Path, Contents, { encoding: "utf-8" });
+}
+
+// Source/Functional/index.ts
+var Functional_exports = {};
+__export(Functional_exports, {
+  Identity: () => Identity
+});
+
+// Source/Functional/Functional.ts
+function Identity(...Arguments) {
+  return Arguments;
+}
+
+// Source/Math/index.ts
+var Math_exports = {};
+__export(Math_exports, {
+  Complex: () => Index_Complex_exports,
+  Vector: () => Vector_exports,
+  __DummyExport_Number: () => __DummyExport_Number
+});
+
+// Source/Math/Index.Complex.ts
+var Index_Complex_exports = {};
+__export(Index_Complex_exports, {
+  FComplex: () => FComplex,
+  i: () => i
+});
+
+// Source/Math/Vector.ts
+var Vector_exports = {};
+__export(Vector_exports, {
+  FVector: () => FVector,
+  FVector2D: () => FVector2D
+});
+import { Operator as Operator2 } from "tsover-runtime";
+var _FVector2D = class _FVector2D {
+  constructor(X = 0, Y = X) {
+    this.X = X;
+    this.Y = Y;
+  }
+  /**
+   * Get a representation of this vector as a `string`.
+   *
+   * @returns {string} The string representation of this vector.
+   */
+  toString() {
+    return `(${this.X}, ${this.Y})`;
+  }
+  /**
+   * Perform per-component addition of two {@link FVector2D}s.
+   *
+   * @param Left - The left-hand operand.
+   * @param Right - The right-hand operand.
+   *
+   * @returns {FVector2D} The per-component sum of {@link Left} and {@link Right}.
+   *
+   * @example
+   * ```typescript
+   * "use tsover";
+   *
+   * const A: FVector2D = new FVector2D(1, -1);
+   * const B: FVector2D = new FVector2D(-3, 5);
+   *
+   * const C: FVector2D = A + B;
+   * // `C` <- `(-2, 4)`
+   * ```
+   */
+  [Operator2.plus](Left, Right) {
+    return new _FVector2D(Left.X + Right.X, Left.Y + Right.Y);
+  }
+  [Operator2.minus](A, B) {
+    return new _FVector2D(A.X - B.X, A.Y - B.Y);
+  }
+  [Operator2.preMinus](Vector) {
+    return new _FVector2D(-1 * Vector.X, -1 * Vector.Y);
+  }
+  [Operator2.star](Left, Right) {
+    if (typeof Left === "number" && Right instanceof _FVector2D) {
+      return new _FVector2D(Left * Right.X, Left * Right.Y);
+    }
+    if (typeof Right === "number" && Left instanceof _FVector2D) {
+      return new _FVector2D(Left.X * Right, Left.Y * Right);
+    }
+    return Operator2.deferOperation;
+  }
+  get length() {
+    return Math.sqrt(this.X ** 2 + this.Y ** 2);
+  }
+  get Length() {
+    return this.length;
+  }
+};
+/** The identity of $\mathbf{R}^2$ *wrt* addition. */
+_FVector2D.Zero = new _FVector2D(0, 0);
+var FVector2D = _FVector2D;
+var FVector = class _FVector {
+  constructor(X = 0, Y = X, Z = X) {
+    this.X = X;
+    this.Y = Y;
+    this.Z = Z;
+  }
+  [Operator2.plus](Left, Right) {
+    return new _FVector(Left.X + Right.X, Left.Y + Right.Y, Left.Z + Right.Z);
+  }
+  [Operator2.minus](A, B) {
+    return new _FVector(A.X - B.X, A.Y - B.Y, A.Z - B.Z);
+  }
+  [Operator2.preMinus](Vector) {
+    return new _FVector(-1 * Vector.X, -1 * Vector.Y, -1 * Vector.Z);
+  }
+  [Operator2.star](Left, Right) {
+    if (typeof Left === "number" && Right instanceof _FVector) {
+      return new _FVector(Left * Right.X, Left * Right.Y, Left * Right.Z);
+    }
+    if (typeof Right === "number" && Left instanceof _FVector) {
+      return new _FVector(Left.X * Right, Left.Y * Right, Left.Z * Right);
+    }
+    return Operator2.deferOperation;
+  }
+  get length() {
+    return Math.sqrt(this.X ** 2 + this.Y ** 2 + this.Z ** 2);
+  }
+  get Length() {
+    return this.length;
+  }
+};
+
+// Source/Math/Math.ts
+var __DummyExport_Number = "DummyExport";
+
+// Source/Miscellaneous/index.ts
+var Miscellaneous_exports = {};
+__export(Miscellaneous_exports, {
+  AbstractMethodCallError: () => AbstractMethodCallError
+});
+
+// Source/Npm/index.ts
+var Npm_exports = {};
+__export(Npm_exports, {
+  GetPackageJson: () => GetPackageJson,
+  GetPackageRootDirectory: () => GetPackageRootDirectory,
+  PackageJsonParseError: () => PackageJsonParseError,
+  RootDirectoryNotFoundError: () => RootDirectoryNotFoundError
+});
+
+// Source/Npm/Npm.ts
+import { promises as Fs2, constants as FsConstants2 } from "fs";
+
+// Source/Npm/Npm.Error.ts
+import { Data } from "effect";
+var PackageJsonParseError = class extends Data.TaggedError("PackageJsonParseError") {
+};
+var RootDirectoryNotFoundError = class extends Data.TaggedError("RootDirectoryNotFound") {
+};
+
+// Source/Npm/Npm.ts
+import { dirname as dirname2, join as join2 } from "path";
+import Process from "process";
+async function GetPackageJson(Path) {
+  const RootDirectory = await GetPackageRootDirectory(Path);
+  const PackageJsonPath = join2(RootDirectory, "package.json");
+  const FileContents = await Fs2.readFile(PackageJsonPath, "utf-8");
+  const PackageJson = await (async () => {
+    try {
+      return JSON.parse(FileContents);
+    } catch (Cause) {
+      throw new PackageJsonParseError({ Cause, Path: PackageJsonPath });
+    }
+  })();
+  return PackageJson;
+}
+async function GetPackageRootDirectory(Path) {
+  let CurrentDirectory = await Fs2.realpath(Path ?? Process.cwd());
+  while (true) {
+    const PackageJsonPath = join2(CurrentDirectory, "package.json");
+    const PackageJsonExists = await (async () => {
+      try {
+        await Fs2.access(PackageJsonPath, FsConstants2.F_OK);
+        return true;
+      } catch {
+        return false;
+      }
+    })();
+    if (PackageJsonExists) {
+      return CurrentDirectory;
+    }
+    const ParentDirectory = dirname2(CurrentDirectory);
+    if (ParentDirectory === CurrentDirectory) {
+      throw new RootDirectoryNotFoundError({ Path });
+    }
+    CurrentDirectory = ParentDirectory;
+  }
+}
+
+// Source/Path/index.ts
+var Path_exports = {};
+__export(Path_exports, {
+  FPath: () => FPath
+});
+
+// Source/Path/Path.ts
+import { join as join3 } from "path";
+import { Operator as Operator3 } from "tsover-runtime";
+var FPath = class _FPath {
+  toString() {
+    return this.Raw;
+  }
+  constructor(Argument) {
+    if (typeof Argument === "string") {
+      this.Raw = Argument;
+    } else {
+      this.Raw = Argument.Raw;
+    }
+  }
+  [Operator3.slash](A, B) {
+    if (typeof A === "string") {
+      return new _FPath(join3(A, B.Raw));
+    } else if (typeof B === "string") {
+      return new _FPath(join3(A.Raw, B));
+    } else {
+      return new _FPath(join3(A.Raw, B.Raw));
+    }
+  }
+};
+
+// Source/String/index.ts
+var String_exports = {};
+__export(String_exports, {
+  IsAlpha: () => IsAlpha,
+  IsLetters: () => IsLetters,
+  IsNumeric: () => IsNumeric
+});
+
+// Source/String/String.ts
+function IsLetters(In) {
+  return /^[a-zA-Z]*$/.test(In);
+}
+function IsAlpha(In) {
+  return IsLetters(In);
+}
+function IsNumeric(In) {
+  return /^\d+$/.test(In);
+}
+export {
+  Array_exports as Array,
+  Async_exports as Async,
+  Complex_exports as Complex,
+  FileSystem_exports as FileSystem,
+  Functional_exports as Functional,
+  Math_exports as Math,
+  Miscellaneous_exports as Miscellaneous,
+  Npm_exports as Npm,
+  Path_exports as Path,
+  String_exports as String
+};
+/**
+ * @file      Array.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Array.Types.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      index.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Utility.Types.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Async.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Promise.Types.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Complex.Internal.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Complex.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      FileSystem.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      FileSystem.Types.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Functional.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Functional.Types.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Complex.Types.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Index.Complex.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Vector.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Math.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Math.Types.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Npm.Error.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Npm.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      Path.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+/**
+ * @file      String.ts
+ * @author    Gage Sorrell <gage@sorrell.sh>
+ * @copyright (c) 2026 Gage Sorrell
+ * @license   MIT
+ */
+//# sourceMappingURL=index.js.map