@mephisto5558/better-types 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mephisto5558
+
+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/eslint.d.ts

@@ -0,0 +1,2 @@
+/* eslint-disable-next-line import-x/prefer-default-export */
+export declare const globals: Record<string, 'readonly'>;

package/eslint.js

@@ -0,0 +1,25 @@
+/* eslint-disable-next-line import-x/prefer-default-export */
+export const globals = Object.freeze({
+  GenericFunction: 'readonly',
+  OmitFirstParameters: 'readonly',
+  StrictOmit: 'readonly',
+  ReplaceMethod: 'readonly',
+  Snowflake: 'readonly',
+
+
+  // better-typescript-lib
+  JSONPrimitive: 'readonly',
+  JSONComposite: 'readonly',
+  JSONValueF: 'readonly',
+  JSONValue: 'readonly',
+  JSONObject: 'readonly',
+  JSONHolder: 'readonly',
+  ToJSON: 'readonly',
+  SomeExtends: 'readonly',
+
+  // SomeFunction: 'readonly', // use GenericFunction instead
+  SomeConstructor: 'readonly',
+  UndefinedDomain: 'readonly',
+  StringifyResultT: 'readonly',
+  StringifyResult: 'readonly'
+});

package/index.d.ts

@@ -0,0 +1,95 @@
+/* eslint-disable sonarjs/no-built-in-override */
+
+/* eslint-disable-next-line unicorn/require-module-specifiers -- required */
+export {};
+
+type ISODate = `${number}${number}${number}${number}-${number}${number}-${number}${number}`;
+type ISOTime = `${number}${number}:${number}${number}:${number}${number}.${number}${number}${number}`;
+type ISODateTime = `${ISODate}T${ISOTime}Z`;
+
+type KeyToString<K extends PropertyKey> = K extends string ? K : K extends number ? `${K}` : never;
+
+type Split<S extends string, SEP extends string | undefined, L extends number = number, Acc extends string[] = []> = SEP extends unknown
+  ? [L] extends [Acc['length']] ? Acc
+    : SEP extends undefined ? [S]
+    : string extends S | SEP ? string[]
+    : SEP extends ''
+      ? S extends `${infer Head}${infer Tail}`
+        ? Split<Tail, SEP, L, [...Acc, Head]>
+        : Acc
+      : S extends `${infer Head}${SEP}${infer Tail}`
+        ? Split<Tail, SEP, L, [...Acc, Head]>
+        : [...Acc, S]
+  : never;
+
+declare global {
+  // #region Buildins
+  /* eslint-disable @typescript-eslint/consistent-type-definitions */
+  namespace NodeJS {
+    interface Require {
+      /* eslint-disable-next-line @typescript-eslint/prefer-function-type -- overwriting only the function signature */
+      (id: string): unknown;
+    }
+  }
+
+  interface String {
+    split(separator?: string, limit: 0): [];
+    split<T extends string>(this: T, separator?: undefined, limit?: number): [T];
+    split<T extends string, SEP extends string | undefined, L extends number = number>(
+      this: T, separator: SEP, limit?: L
+    ): Split<T, SEP, L>;
+
+    toLowerCase<T extends string>(this: T): Lowercase<T>;
+    toUpperCase<T extends string>(this: T): Uppercase<T>;
+  }
+
+  interface BigInt {
+    toString(radix?: 10): `${bigint}`;
+  }
+
+  interface ObjectConstructor {
+    keys<K extends PropertyKey, V>(o: [K, V] extends [never, never] ? never : Record<K, V>): KeyToString<K>[]; // handles things like enums
+    keys<T>(o: T): KeyToString<keyof T>[];
+
+    values<K extends PropertyKey, V>(o: [K, V] extends [never, never] ? never : Record<K, V>): V[]; // handles things like enums
+    values<T>(o: T): ({
+      [K in keyof T]: undefined extends T[K] ? T[K] : Required<T>[K]
+    } extends { [_ in keyof T]: infer V } ? V : never)[];
+
+    entries<K extends PropertyKey, V>(o: [K, V] extends [never, never] ? never : Record<K, V>): [KeyToString<K>, V][]; // handles things like enums
+    entries<T>(o: T): ({
+      [K in keyof T]: undefined extends T[K] ? T[K] : Required<T>[K]
+    } extends { [_ in keyof T]: infer V } ? [KeyToString<keyof T>, V] : never)[];
+  }
+
+  interface Date {
+    /**
+     * Give a more precise return type to the method `toISOString()`:
+     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString */
+    toISOString(): ISODateTime;
+  }
+
+  // #endregion Buildins
+
+  type Snowflake = `${bigint}`;
+
+  /* eslint-enable @typescript-eslint/consistent-type-definitions */
+
+  // #region useful Generics
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any -- used only as generic constraint */
+  type GenericFunction<Ret = any> = (...args: any) => Ret;
+
+  type OmitFirstParameters<
+    T extends GenericFunction, N extends number = 1, Acc extends unknown[] = []
+  > = Acc['length'] extends N ? Parameters<T> extends [...Acc, ...infer Rest] ? Rest : never : OmitFirstParameters<T, N, [...Acc, unknown]>;
+
+  /**
+   * A stricter version of `Omit` that preserves modifiers better by using a mapped type.
+   *
+   * {@link https://github.com/microsoft/TypeScript/issues/54451#issue-1732749888 More info} */
+  type StrictOmit<T, K extends keyof T> = { [P in keyof T as P extends K ? never : P]: T[P] };
+
+  type ReplaceMethod<T, K extends keyof T, This, Args extends unknown[] = Parameters<T[K]>> = StrictOmit<T, K> & {
+    [P in K]: Exclude<T[P], GenericFunction> | ((this: This, ...args: Args) => ReturnType<Extract<T[P], GenericFunction>>);
+  };
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@mephisto5558/better-types",
+  "version": "1.0.0",
+  "description": "A collection of useful TypeScript types and augmentations to improve developer experience.",
+  "keywords": [
+    "typing",
+    "typescript"
+  ],
+  "homepage": "https://github.com/Mephisto5558/Better-Types#readme",
+  "bugs": {
+    "url": "https://github.com/Mephisto5558/Better-Types/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Mephisto5558/Better-Types.git"
+  },
+  "license": "MIT",
+  "author": "Mephisto5558",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts"
+    },
+    "./eslint": "./eslint.js"
+  },
+  "types": "index.d.ts",
+  "files": [
+    "index.d.ts",
+    "eslint.js",
+    "eslint.d.ts"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "devDependencies": {
+    "@mephisto5558/eslint-config": "latest",
+    "@types/node": "20.x",
+    "better-typescript-lib": "latest"
+  },
+  "peerDependencies": {
+    "@types/node": ">=20",
+    "better-typescript-lib": "latest"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}