@mnaoumov/typescript-lib 0.0.0 → 1.0.0

package/dist/lib/cjs/function.cjs

@@ -0,0 +1,141 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var function_exports = {};
+__export(function_exports, {
+  cloneFunction: () => cloneFunction,
+  createFunction: () => createFunction,
+  getFunctionExpressionString: () => getFunctionExpressionString,
+  noop: () => noop,
+  noopAsync: () => noopAsync,
+  noopAsyncSingletonPromise: () => noopAsyncSingletonPromise,
+  omitAsyncReturnType: () => omitAsyncReturnType,
+  omitReturnType: () => omitReturnType
+});
+module.exports = __toCommonJS(function_exports);
+function getFunctionExpressionString($function) {
+  const functionString = $function.toString();
+  if (FUNCTION_EXPRESSION_RE.test(functionString)) {
+    return functionString;
+  }
+  const asyncMatch = ASYNC_KEYWORD_RE.exec(functionString);
+  return asyncMatch ? `async function ${functionString.slice(asyncMatch[0].length)}` : `function ${functionString}`;
+}
+function noop() {
+}
+const noopAsyncSingletonPromise = Promise.resolve();
+function noopAsync() {
+  return noopAsyncSingletonPromise;
+}
+function omitAsyncReturnType($function) {
+  return async (...$arguments) => {
+    await $function(...$arguments);
+  };
+}
+const FUNCTION_EXPRESSION_RE = /^(?:function\b|async\b\s*(?:function\b|\()|\()/;
+const ASYNC_KEYWORD_RE = /^async\b\s*/;
+function cloneFunction($function) {
+  return clonedFunction;
+  function clonedFunction(...$arguments) {
+    return $function.apply(this, $arguments);
+  }
+}
+function createFunction(params) {
+  const argumentNames = params.argumentNames ?? [];
+  return new Function(...argumentNames, params.functionBody);
+}
+function omitReturnType($function) {
+  return (...$arguments) => {
+    $function(...$arguments);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cloneFunction,
+  createFunction,
+  getFunctionExpressionString,
+  noop,
+  noopAsync,
+  noopAsyncSingletonPromise,
+  omitAsyncReturnType,
+  omitReturnType
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/function.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions and types for working with functions.\n */\n\nimport type { Promisable } from 'type-fest';\n\n/**\n * Represents a generic async function.\n *\n * @typeParam Arguments - The arguments of the function.\n * @typeParam Return - The awaited return type of the function.\n */\nexport type GenericAsyncFunction<Arguments extends unknown[] = never[], Return = unknown> = GenericFunction<Arguments, Promise<Return>>;\n\n/**\n * Represents a generic async void function.\n *\n * @typeParam Arguments - The arguments of the function.\n */\nexport type GenericAsyncVoidFunction<Arguments extends unknown[] = never[]> = GenericAsyncFunction<Arguments, void>;\n\n/**\n * Represents a generic function.\n *\n * @typeParam Arguments - The arguments of the function.\n * @typeParam Return - The return type of the function.\n */\nexport type GenericFunction<Arguments extends unknown[] = never[], Return = unknown> = (...$arguments: Arguments) => Return;\n\n/**\n * Represents a generic promisable function.\n *\n * @typeParam Arguments - The arguments of the function.\n * @typeParam Return - The awaited return type of the function.\n */\nexport type GenericPromisableFunction<Arguments extends unknown[] = never[], Return = unknown> = GenericFunction<Arguments, Promisable<Return>>;\n\n/**\n * Represents a generic promisable void function.\n *\n * @typeParam Arguments - The arguments of the function.\n */\nexport type GenericPromisableVoidFunction<Arguments extends unknown[] = never[]> = GenericPromisableFunction<Arguments, void>;\n\n/**\n * Represents a generic void function.\n *\n * @typeParam Arguments - The arguments of the function.\n */\nexport type GenericVoidFunction<Arguments extends unknown[] = never[]> = GenericFunction<Arguments, void>;\n\n/**\n * Converts a function into a string that is a valid function expression.\n *\n * `Function.prototype.toString()` on a shorthand method like `{ fn() {} }`\n * returns `\"fn() {}\"`, which is not a valid expression.\n * This helper detects that form and prefixes it with `function `.\n *\n * @param $function - The function to convert.\n * @returns A string that is a valid function expression.\n */\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- We need to use `Function` type.\nexport function getFunctionExpressionString($function: Function): string {\n  const functionString = $function.toString();\n\n  if (FUNCTION_EXPRESSION_RE.test(functionString)) {\n    return functionString;\n  }\n\n  const asyncMatch = ASYNC_KEYWORD_RE.exec(functionString);\n  return asyncMatch ? `async function ${functionString.slice(asyncMatch[0].length)}` : `function ${functionString}`;\n}\n\n/**\n * A function that does nothing.\n */\nexport function noop(): void {\n  // Does nothing.\n}\n\n/**\n * A singleton no-op promise.\n */\n// eslint-disable-next-line obsidian-dev-utils/prefer-noop-async -- Avoid circular reference.\nexport const noopAsyncSingletonPromise = Promise.resolve();\n\n/**\n * A function that does nothing.\n *\n * @returns A promise that resolves when the function is complete.\n */\nexport function noopAsync(): Promise<void> {\n  return noopAsyncSingletonPromise;\n}\n\n/**\n * Makes an async function that calls the original async function with the provided arguments and omits the return value.\n *\n * @typeParam Arguments - Arguments to be passed to the function.\n * @param $function - Function to be called.\n * @returns An async function that calls the original function with the provided arguments and omits the return value.\n */\nexport function omitAsyncReturnType<Arguments extends unknown[]>($function: GenericAsyncFunction<Arguments>): GenericAsyncVoidFunction<Arguments> {\n  return async (...$arguments: Arguments) => {\n    await $function(...$arguments);\n  };\n}\n\n/**\n * Matches strings that are already valid function expressions:\n * - `function ...` (keyword, not identifier like `function1`)\n * - `(` (arrow function)\n * - `async\\b` followed by `function\\b` or `(` (async function/arrow)\n */\nconst FUNCTION_EXPRESSION_RE = /^(?:function\\b|async\\b\\s*(?:function\\b|\\()|\\()/;\n\n/**\n * Matches the `async` keyword (word boundary, not `async1`) followed by optional whitespace.\n * Used to strip the `async` prefix from async shorthand methods before re-adding `async function`.\n */\nconst ASYNC_KEYWORD_RE = /^async\\b\\s*/;\n\ntype ArgumentNamesOf<T extends GenericFunction> = MapToArgumentNames<Parameters<T>>;\n\ninterface CreateFunctionArgumentlessParams {\n  readonly functionBody: string;\n}\n\ninterface CreateFunctionParams<TFunction extends GenericFunction> extends CreateFunctionArgumentlessParams {\n  readonly argumentNames: ArgumentNamesOf<TFunction>;\n}\n\ntype MapToArgumentNames<TArguments extends readonly unknown[]> = {\n  readonly [K in keyof TArguments]: string;\n};\n\n/**\n * Clone a function by creating a new function that calls the original function.\n *\n * This is useful for creating a new instance of a function that has the same behavior but is not strictly equal to the original function.\n *\n * @typeParam TFunction - The type of the function to clone.\n * @param $function - The function to clone.\n * @returns A new function that has the same behavior as the original function.\n */\nexport function cloneFunction<TFunction extends GenericFunction>($function: TFunction): TFunction {\n  return clonedFunction as TFunction;\n\n  function clonedFunction(this: ThisParameterType<TFunction>, ...$arguments: Parameters<TFunction>): ReturnType<TFunction> {\n    return $function.apply(this, $arguments) as ReturnType<TFunction>;\n  }\n}\n/**\n * Creates a function from the provided parameters.\n *\n * Function is argumentless, so `argNames` is not needed.\n *\n * @typeParam TFunction - The type of the function to create.\n * @param params - The parameters to create the function with.\n * @returns A function created from the provided parameters.\n */\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need return type.\nexport function createFunction<TFunction extends () => unknown>(params: CreateFunctionArgumentlessParams): TFunction;\n/**\n * Creates a function from the provided parameters.\n *\n * Function has arguments, so `argNames` is required.\n *\n * @typeParam TFunction - The type of the function to create.\n * @param params - The parameters to create the function with.\n * @returns A function created from the provided parameters.\n */\nexport function createFunction<TFunction extends GenericFunction>(params: CreateFunctionParams<TFunction>): TFunction;\n/**\n * Creates a function from the provided parameters.\n *\n * @typeParam TFunction - The type of the function to create.\n *\n * @param params - The parameters to create the function with.\n * @returns A function created from the provided parameters.\n */\nexport function createFunction<TFunction extends GenericFunction>(\n  params: CreateFunctionArgumentlessParams & Partial<CreateFunctionParams<TFunction>>\n): TFunction {\n  const argumentNames = params.argumentNames ?? [];\n  // eslint-disable-next-line no-new-func, @typescript-eslint/no-implied-eval -- Need function constructor\n  return new Function(...argumentNames, params.functionBody) as TFunction;\n}\n\n/**\n * Makes a function that calls the original function with the provided arguments and omits the return value.\n *\n * @typeParam Arguments - Arguments to be passed to the function.\n * @param $function - Function to be called.\n * @returns A function that calls the original function with the provided arguments and omits the return value.\n */\nexport function omitReturnType<Arguments extends unknown[]>($function: GenericFunction<Arguments>): GenericVoidFunction<Arguments> {\n  return (...$arguments: Arguments) => {\n    $function(...$arguments);\n  };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgEO,SAAS,4BAA4B,WAA6B;AACvE,QAAM,iBAAiB,UAAU,SAAS;AAE1C,MAAI,uBAAuB,KAAK,cAAc,GAAG;AAC/C,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,iBAAiB,KAAK,cAAc;AACvD,SAAO,aAAa,kBAAkB,eAAe,MAAM,WAAW,CAAC,EAAE,MAAM,CAAC,KAAK,YAAY,cAAc;AACjH;AAKO,SAAS,OAAa;AAE7B;AAMO,MAAM,4BAA4B,QAAQ,QAAQ;AAOlD,SAAS,YAA2B;AACzC,SAAO;AACT;AASO,SAAS,oBAAiD,WAAiF;AAChJ,SAAO,UAAU,eAA0B;AACzC,UAAM,UAAU,GAAG,UAAU;AAAA,EAC/B;AACF;AAQA,MAAM,yBAAyB;AAM/B,MAAM,mBAAmB;AAyBlB,SAAS,cAAiD,WAAiC;AAChG,SAAO;AAEP,WAAS,kBAAsD,YAA0D;AACvH,WAAO,UAAU,MAAM,MAAM,UAAU;AAAA,EACzC;AACF;AA8BO,SAAS,eACd,QACW;AACX,QAAM,gBAAgB,OAAO,iBAAiB,CAAC;AAE/C,SAAO,IAAI,SAAS,GAAG,eAAe,OAAO,YAAY;AAC3D;AASO,SAAS,eAA4C,WAAuE;AACjI,SAAO,IAAI,eAA0B;AACnC,cAAU,GAAG,UAAU;AAAA,EACzB;AACF;",
  "names": []
}


package/dist/lib/cjs/function.d.cts

@@ -0,0 +1,128 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * Contains utility functions and types for working with functions.
+ */
+import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
+/**
+ * Represents a generic async function.
+ *
+ * @typeParam Arguments - The arguments of the function.
+ * @typeParam Return - The awaited return type of the function.
+ */
+export type GenericAsyncFunction<Arguments extends unknown[] = never[], Return = unknown> = GenericFunction<Arguments, Promise<Return>>;
+/**
+ * Represents a generic async void function.
+ *
+ * @typeParam Arguments - The arguments of the function.
+ */
+export type GenericAsyncVoidFunction<Arguments extends unknown[] = never[]> = GenericAsyncFunction<Arguments, void>;
+/**
+ * Represents a generic function.
+ *
+ * @typeParam Arguments - The arguments of the function.
+ * @typeParam Return - The return type of the function.
+ */
+export type GenericFunction<Arguments extends unknown[] = never[], Return = unknown> = (...$arguments: Arguments) => Return;
+/**
+ * Represents a generic promisable function.
+ *
+ * @typeParam Arguments - The arguments of the function.
+ * @typeParam Return - The awaited return type of the function.
+ */
+export type GenericPromisableFunction<Arguments extends unknown[] = never[], Return = unknown> = GenericFunction<Arguments, Promisable<Return>>;
+/**
+ * Represents a generic promisable void function.
+ *
+ * @typeParam Arguments - The arguments of the function.
+ */
+export type GenericPromisableVoidFunction<Arguments extends unknown[] = never[]> = GenericPromisableFunction<Arguments, void>;
+/**
+ * Represents a generic void function.
+ *
+ * @typeParam Arguments - The arguments of the function.
+ */
+export type GenericVoidFunction<Arguments extends unknown[] = never[]> = GenericFunction<Arguments, void>;
+/**
+ * Converts a function into a string that is a valid function expression.
+ *
+ * `Function.prototype.toString()` on a shorthand method like `{ fn() {} }`
+ * returns `"fn() {}"`, which is not a valid expression.
+ * This helper detects that form and prefixes it with `function `.
+ *
+ * @param $function - The function to convert.
+ * @returns A string that is a valid function expression.
+ */
+export declare function getFunctionExpressionString($function: Function): string;
+/**
+ * A function that does nothing.
+ */
+export declare function noop(): void;
+/**
+ * A singleton no-op promise.
+ */
+export declare const noopAsyncSingletonPromise: Promise<void>;
+/**
+ * A function that does nothing.
+ *
+ * @returns A promise that resolves when the function is complete.
+ */
+export declare function noopAsync(): Promise<void>;
+/**
+ * Makes an async function that calls the original async function with the provided arguments and omits the return value.
+ *
+ * @typeParam Arguments - Arguments to be passed to the function.
+ * @param $function - Function to be called.
+ * @returns An async function that calls the original function with the provided arguments and omits the return value.
+ */
+export declare function omitAsyncReturnType<Arguments extends unknown[]>($function: GenericAsyncFunction<Arguments>): GenericAsyncVoidFunction<Arguments>;
+type ArgumentNamesOf<T extends GenericFunction> = MapToArgumentNames<Parameters<T>>;
+interface CreateFunctionArgumentlessParams {
+    readonly functionBody: string;
+}
+interface CreateFunctionParams<TFunction extends GenericFunction> extends CreateFunctionArgumentlessParams {
+    readonly argumentNames: ArgumentNamesOf<TFunction>;
+}
+type MapToArgumentNames<TArguments extends readonly unknown[]> = {
+    readonly [K in keyof TArguments]: string;
+};
+/**
+ * Clone a function by creating a new function that calls the original function.
+ *
+ * This is useful for creating a new instance of a function that has the same behavior but is not strictly equal to the original function.
+ *
+ * @typeParam TFunction - The type of the function to clone.
+ * @param $function - The function to clone.
+ * @returns A new function that has the same behavior as the original function.
+ */
+export declare function cloneFunction<TFunction extends GenericFunction>($function: TFunction): TFunction;
+/**
+ * Creates a function from the provided parameters.
+ *
+ * Function is argumentless, so `argNames` is not needed.
+ *
+ * @typeParam TFunction - The type of the function to create.
+ * @param params - The parameters to create the function with.
+ * @returns A function created from the provided parameters.
+ */
+export declare function createFunction<TFunction extends () => unknown>(params: CreateFunctionArgumentlessParams): TFunction;
+/**
+ * Creates a function from the provided parameters.
+ *
+ * Function has arguments, so `argNames` is required.
+ *
+ * @typeParam TFunction - The type of the function to create.
+ * @param params - The parameters to create the function with.
+ * @returns A function created from the provided parameters.
+ */
+export declare function createFunction<TFunction extends GenericFunction>(params: CreateFunctionParams<TFunction>): TFunction;
+/**
+ * Makes a function that calls the original function with the provided arguments and omits the return value.
+ *
+ * @typeParam Arguments - Arguments to be passed to the function.
+ * @param $function - Function to be called.
+ * @returns A function that calls the original function with the provided arguments and omits the return value.
+ */
+export declare function omitReturnType<Arguments extends unknown[]>($function: GenericFunction<Arguments>): GenericVoidFunction<Arguments>;
+export {};