@zimic/http 0.0.1-canary.2

package/src/types/strings.d.ts

@@ -0,0 +1,9 @@
+interface String {
+  // Using the original method signature style to correctly apply the overload.
+  // eslint-disable-next-line @typescript-eslint/method-signature-style
+  toLowerCase<Type = string>(): Lowercase<Type>;
+
+  // Using the original method signature style to correctly apply the overload.
+  // eslint-disable-next-line @typescript-eslint/method-signature-style
+  toUpperCase<Type = string>(): Uppercase<Type>;
+}

package/src/types/utils.ts

@@ -0,0 +1,64 @@
+export type Default<Type, IfEmpty = never> = [undefined | void] extends [Type]
+  ? IfEmpty
+  : Exclude<Type, undefined | void>;
+
+export type DefaultNoExclude<Type, IfEmpty = never> = [undefined | void] extends Type ? IfEmpty : Type;
+
+export type IfAny<Type, Yes, No = Type> = 0 extends 1 & Type ? Yes : No;
+
+export type IfNever<Type, Yes, No = Type> = [Type] extends [never] ? Yes : No;
+
+export type PossiblePromise<Type> = Type | PromiseLike<Type>;
+
+export type UnionToIntersection<Union> = (Union extends unknown ? (union: Union) => void : never) extends (
+  intersectedUnion: infer IntersectedUnion,
+) => void
+  ? IntersectedUnion
+  : never;
+
+type LastUnionType<Union> =
+  UnionToIntersection<Union extends unknown ? (union: Union) => void : never> extends (x: infer LastType) => void
+    ? LastType
+    : never;
+
+export type UnionToTuple<Union, LastType = LastUnionType<Union>> = [Union] extends [never]
+  ? []
+  : [...UnionToTuple<Exclude<Union, LastType>>, LastType];
+
+export type UnionHasMoreThanOneType<Union> = [UnionToIntersection<Union>] extends [never] ? true : false;
+
+export type Prettify<Type> = {
+  [Key in keyof Type]: Type[Key];
+};
+
+export type ArrayItemIfArray<Type> = Type extends (infer Item)[] ? Item : Type;
+
+type PickArrayProperties<Type> = {
+  [Key in keyof Type as never[] extends Type[Key] ? Key : never]: Type[Key];
+};
+
+export type ArrayKey<Type> = keyof PickArrayProperties<Type>;
+
+export type NonArrayKey<Type> =
+  string | number extends ArrayKey<Type> ? keyof Type : Exclude<keyof Type, ArrayKey<Type>>;
+
+export type NonEmptyArray<Type> = [Type, ...Type[]];
+
+export type ReplaceBy<Type, Source, Target> = Type extends Source ? Target : Type;
+
+export type Collection<Type> = Type[] | Set<Type>;
+
+export type DeepPartial<Type> = Type extends (...parameters: never[]) => unknown
+  ? Type
+  : Type extends (infer ArrayItem)[]
+    ? DeepPartial<ArrayItem>[]
+    : Type extends object
+      ? { [Key in keyof Type]?: DeepPartial<Type[Key]> }
+      : Type;
+
+export type Override<Type, OverrideType> = Omit<Type, keyof OverrideType> & OverrideType;
+
+export interface Range<Value> {
+  min: Value;
+  max: Value;
+}

package/src/utils/console.ts

@@ -0,0 +1,7 @@
+import chalk from 'chalk';
+
+export function logWithPrefix(message: string, options: { method: 'log' | 'warn' | 'error' }) {
+  const { method } = options;
+
+  console[method](chalk.cyan('[zimic]'), message);
+}

package/src/utils/data.ts

@@ -0,0 +1,13 @@
+export async function blobEquals(blob: Blob, otherBlob: Blob) {
+  return (
+    blob.type === otherBlob.type && blob.size === otherBlob.size && (await blob.text()) === (await otherBlob.text())
+  );
+}
+
+export function isDefined<Value>(value: Value): value is NonNullable<Value> {
+  return value !== undefined && value !== null;
+}
+
+export function isNonEmpty<Value>(value: Value): value is Exclude<NonNullable<Value>, ''> {
+  return isDefined(value) && value !== '';
+}

package/src/utils/files.ts

@@ -0,0 +1,28 @@
+import { blobEquals } from './data';
+import { createCachedDynamicImport } from './imports';
+
+export const importBuffer = createCachedDynamicImport(
+  /* istanbul ignore next -- @preserve
+   * Ignoring as Node.js >=20 provides a global file and the buffer import won't run. */
+  () => import('buffer'),
+);
+
+let FileSingleton: typeof File | undefined;
+
+export async function importFile() {
+  /* istanbul ignore if -- @preserve
+   * Ignoring as this will only run if this function is called more than once. */
+  if (FileSingleton) {
+    return FileSingleton;
+  }
+
+  /* istanbul ignore next -- @preserve
+   * Ignoring as Node.js >=20 provides a global File and the import fallback won't run. */
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  FileSingleton = globalThis.File ?? (await importBuffer()).File;
+  return FileSingleton;
+}
+
+export async function fileEquals(file: File, otherFile: File) {
+  return file.name === otherFile.name && (await blobEquals(file, otherFile));
+}

package/src/utils/imports.ts

@@ -0,0 +1,12 @@
+export function createCachedDynamicImport<ImportType>(
+  importModuleDynamically: () => Promise<ImportType>,
+): () => Promise<ImportType> {
+  let cachedImportResult: ImportType | undefined;
+
+  return async function importModuleDynamicallyWithCache() {
+    if (cachedImportResult === undefined) {
+      cachedImportResult = await importModuleDynamically();
+    }
+    return cachedImportResult;
+  };
+}

package/src/utils/prettier.ts

@@ -0,0 +1,13 @@
+import prettier, { Options } from 'prettier'; // eslint-disable-line import/no-extraneous-dependencies
+
+export async function resolvedPrettierConfig(fileName: string): Promise<Options> {
+  const config = await prettier.resolveConfig(fileName);
+
+  /* istanbul ignore if -- @preserve
+   * This function is used in tests and they will fail if no config is found. */
+  if (config === null) {
+    throw new Error('Prettier config not found.');
+  }
+
+  return config;
+}

package/src/utils/strings.ts

@@ -0,0 +1,3 @@
+export function convertToPascalCase(value: string) {
+  return value.replace(/(?:^|[^A-Za-z\d])([A-Za-z\d])/g, (_match, letter: string) => letter.toUpperCase());
+}

package/src/utils/time.ts

@@ -0,0 +1,25 @@
+import { PossiblePromise } from '@/types/utils';
+
+export async function usingElapsedTime<ReturnType>(callback: () => PossiblePromise<ReturnType>) {
+  const startTimeInMilliseconds = performance.now();
+
+  const result = await callback();
+
+  const endTimeInMilliseconds = performance.now();
+  const elapsedTimeInMilliseconds = endTimeInMilliseconds - startTimeInMilliseconds;
+
+  return {
+    startTime: startTimeInMilliseconds,
+    elapsedTime: elapsedTimeInMilliseconds,
+    endTime: endTimeInMilliseconds,
+    result,
+  };
+}
+
+export function formatElapsedTime(elapsedTimeInMilliseconds: number) {
+  if (elapsedTimeInMilliseconds < 1000) {
+    return `${elapsedTimeInMilliseconds.toFixed(0)}ms`;
+  } else {
+    return `${(elapsedTimeInMilliseconds / 1000).toFixed(2)}s`;
+  }
+}

package/src/utils/urls.ts

@@ -0,0 +1,52 @@
+export class InvalidURLError extends TypeError {
+  constructor(url: unknown) {
+    super(`Invalid URL: '${url}'`);
+    this.name = 'InvalidURL';
+  }
+}
+
+export interface ExtendedURL extends URL {
+  raw: string;
+}
+
+function createURLOrThrow(rawURL: string | URL) {
+  try {
+    const url = new URL(rawURL) as ExtendedURL;
+
+    Object.defineProperty(url, 'raw', {
+      value: rawURL.toString(),
+      writable: false,
+      enumerable: true,
+      configurable: false,
+    });
+
+    return url;
+  } catch {
+    throw new InvalidURLError(rawURL);
+  }
+}
+
+export function createURL(rawURL: string | URL): ExtendedURL {
+  const url = createURLOrThrow(rawURL);
+  return url;
+}
+
+export function createFileURL(filePath: string) {
+  return createURL(`file://${filePath}`);
+}
+
+function prepareURLForRegex(url: string) {
+  const encodedURL = encodeURI(url);
+  return encodedURL.replace(/([.()*?+$\\])/g, '\\$1');
+}
+
+export function createRegexFromWildcardPath(path: string, options: { prefix: string }) {
+  const pathWithReplacedWildcards = prepareURLForRegex(path)
+    .replace(/^\/+|\/+$/g, '')
+    .replace(/\\\*/g, '*')
+    .replace(/\*\*\/\*/g, '**')
+    .replace(/(^|[^*])\*([^*]|$)/g, '$1[^/]*$2')
+    .replace(/\*\*/g, '.*');
+
+  return new RegExp(`^${options.prefix}/*${pathWithReplacedWildcards}/*$`);
+}

package/typegen.d.ts

@@ -0,0 +1 @@
+export * from './dist/typegen';