@goast/core 0.4.1-springwebclient1 → 0.4.2

package/src/src/utils/string.utils.types.ts

@@ -0,0 +1,179 @@
+/**
+ * Represents a casing for a word.
+ * @example
+ * toCasing('fooBar', 'unchanged') // => 'fooBar'
+ * toCasing('fooBar', 'all-lower') // => 'foobar'
+ * toCasing('fooBar', 'all-upper') // => 'FOOBAR'
+ * toCasing('fooBar', 'first-upper') // => 'FooBar'
+ * toCasing('FooBar', 'first-lower') // => 'fooBar'
+ * toCasing('fooBar', 'first-upper-then-lower') // => 'Foobar'
+ * toCasing('FooBar', 'first-lower-then-upper') // => 'fOOBAR'
+ * toCasing('fooBar', 'first-upper-alternating') // => 'FoObAr'
+ * toCasing('FooBar', 'first-lower-alternating') // => 'fOoBaR'
+ */
+export type WordCasing =
+  | 'unchanged'
+  | 'all-lower'
+  | 'all-upper'
+  | 'first-upper'
+  | 'first-lower'
+  | 'first-upper-then-lower'
+  | 'first-lower-then-upper'
+  | 'first-upper-alternating'
+  | 'first-lower-alternating';
+
+/**
+ * Represents a casing for a string.
+ * @example
+ * toCase('fooBar', 'unchanged') // => 'fooBar'
+ * toCase('fooBar', 'all-lower') // => 'foobar'
+ * toCase('fooBar', 'all-upper') // => 'FOOBAR'
+ * toCase('fooBar', 'first-upper') // => 'FooBar'
+ * toCase('FooBar', 'first-lower') // => 'fooBar'
+ * toCase('fooBar', 'first-upper-then-lower') // => 'Foobar'
+ * toCase('FooBar', 'first-lower-then-upper') // => 'fOOBAR'
+ * toCase('fooBar', 'first-upper-alternating') // => 'FoObAr'
+ * toCase('FooBar', 'first-lower-alternating') // => 'fOoBaR'
+ * toCase('fooBar', 'camel') // => 'fooBar'
+ * toCase('fooBar', 'pascal') // => 'FooBar'
+ * toCase('fooBar', 'kebab') // => 'foo-bar'
+ * toCase('fooBar', 'snake') // => 'foo_bar'
+ */
+export type StringCasing = WordCasing | 'camel' | 'pascal' | 'kebab' | 'snake' | 'custom';
+
+export type StringCasingWithOptions<T extends StringCasing = StringCasing> = {
+  casing: T;
+} & CaseOptions<T>;
+
+export type ExtendedStringCasing = StringCasing | StringCasingWithOptions;
+
+export type CaseOptions<T extends StringCasing> = T extends 'camel' ? Partial<CamelCaseOptions>
+  : T extends 'pascal' ? Partial<PascalCaseOptions>
+  : T extends 'kebab' ? Partial<KebabCaseOptions>
+  : T extends 'snake' ? Partial<SnakeCaseOptions>
+  : T extends 'custom' ? CustomCaseOptions
+  : never;
+
+export type BaseCaseOptions = {
+  /**
+   * Specifies a prefix to add to the string.
+   * @default undefined
+   * @example
+   * toCase('foo', { prefix: 'bar' }) // => 'barfoo'
+   */
+  prefix?: string;
+  /**
+   * Specifies a suffix to add to the string.
+   * @default undefined
+   * @example
+   * toCase('foo', { suffix: 'bar' }) // => 'foobar'
+   */
+  suffix?: string;
+};
+
+export type CamelCaseOptions = BaseCaseOptions & {
+  /**
+   * Controls the casing of all characters except the first one for each word.
+   *
+   * If true, all characters except the first one will remain unchanged; otherwise, all characters except the first one will be converted to lowercase.
+   *
+   * @default false
+   * @example
+   * toCamelCase('fooBAR') // => 'fooBar'
+   * toCamelCase('fooBAR', { keepOriginalCase: false }) // => 'fooBar'
+   * toCamelCase('fooBAR', { keepOriginalCase: true }) // => 'fooBAR'
+   */
+  keepOriginalCase: boolean;
+};
+
+export type PascalCaseOptions = BaseCaseOptions & {
+  /**
+   * Controls the casing of all characters except the first one for each word.
+   *
+   * If true, all characters except the first one will remain unchanged; otherwise, all characters except the first one will be converted to lowercase.
+   *
+   * @default false
+   * @example
+   * toCamelCase('FooBAR') // => 'FooBar'
+   * toCamelCase('FooBAR', { keepOriginalCase: false }) // => 'FooBar'
+   * toCamelCase('FooBAR', { keepOriginalCase: true }) // => 'FooBAR'
+   */
+  keepOriginalCase: boolean;
+};
+
+export type KebabCaseOptions = BaseCaseOptions & {
+  /**
+   * Specifies the casing of words.
+   * @default 'all-lower'
+   * @example
+   * toKebabCase('Foo bAR') // => 'foo-bar'
+   * toKebabCase('Foo bAR', { wordCasing: 'all-upper' }) // => 'FOO-BAR'
+   */
+  wordCasing: WordCasing;
+  /**
+   * Specifies the casing of the first word. If undefined uses the casing option.
+   * @default undefined
+   * @example
+   * toKebabCase('Foo bAR') // => 'foo-bar'
+   * toKebabCase('Foo bAR', { firstWordCasing: 'all-upper' }) // => 'FOO-bar'
+   * toKebabCase('Foo bAR', { wordCasing: 'all-upper', firstWordCasing: 'all-lower' }) // => 'foo-BAR'
+   */
+  firstWordCasing?: WordCasing;
+};
+
+export type SnakeCaseOptions = BaseCaseOptions & {
+  /**
+   * Specifies the casing of words.
+   * @default 'all-upper'
+   * @example
+   * toSnakeCase('Foo bAR') // => 'FOO_BAR'
+   * toSnakeCase('Foo bAR', { wordCasing: 'all-lower' }) // => 'foo_bar'
+   */
+  wordCasing: WordCasing;
+  /**
+   * Specifies the casing of the first word. If undefined uses the casing option.
+   * @default undefined
+   * @example
+   * toSnakeCase('Foo bAR') // => 'FOO_BAR'
+   * toSnakeCase('Foo bAR', { firstWordCasing: 'all-lower' }) // => 'foo_BAR'
+   * toSnakeCase('Foo bAR', { wordCasing: 'all-lower', firstWordCasing: 'all-upper' }) // => 'FOO_bar'
+   */
+  firstWordCasing?: WordCasing;
+};
+
+export type CustomCaseOptions =
+  & BaseCaseOptions
+  & {
+    /**
+     * Specifies the separator between words.
+     * @default undefined
+     * @example
+     * toCustomCase('Foo bAR', { wordCasing: 'first-upper-then-lower', wordSeparator: '~' }) // => 'Foo~Bar'
+     */
+    wordSeparator?: string;
+  }
+  & (
+    | {
+      /**
+       * Specifies the casing of words.
+       * @example
+       * toCustomCase('Foo bAR', { wordCasing: 'first-upper-then-lower' }) // => 'FooBar'
+       */
+      wordCasing: WordCasing;
+      /**
+       * Specifies the casing of the first word. If undefined uses the casing option.
+       * @default undefined
+       * @example
+       * toCustomCase('Foo bAR', { wordCasing: 'first-upper-then-lower', firstWordCasing: 'all-upper' }) // => 'FOOBar'
+       */
+      firstWordCasing?: WordCasing;
+    }
+    | {
+      /**
+       * Specifies the casing of words.
+       * @example
+       * toCustomCase('Foo bAR baz', { wordCasing: (wordIndex) => (wordIndex % 2 === 0 ? 'all-upper' : 'all-lower') }) // => 'FOObarBAZ'
+       */
+      wordCasing: (wordIndex: number) => WordCasing;
+    }
+  );

package/src/src/utils/type.utils.ts

@@ -0,0 +1,93 @@
+// deno-lint-ignore-file no-explicit-any ban-types
+export type Merge<U extends unknown[]> = U extends [infer A, ...infer R] ? A & Merge<R> : {};
+
+export type OptionalProperties<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type RequiredProperties<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+
+export type ArrayItem<T> = T extends (infer U)[] ? U : never;
+export type SingleOrMultiple<T> = T | T[];
+export type Single<T> = T extends (infer U)[] ? U : T;
+export type Multiple<T> = T extends (infer U)[] ? U[] : T[];
+
+export type Nullable<T> = T | null | undefined;
+
+export interface Constructor<T, TArgs extends any[] = any[]> extends Function {
+  new (...args: TArgs): T;
+}
+
+export type EmptyConstructor<T> = Constructor<T, []>;
+
+export type FunctionNames<T> = {
+  [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T];
+
+export type Prettify<T> =
+  & {
+    [K in keyof T]: T[K];
+  }
+  & {};
+
+export type ValueOf<T> = T[keyof T];
+
+export type NonEmptyArray<T> = [T, ...T[]];
+
+type MustInclude<T, U extends T[]> = [T] extends [ValueOf<U>] ? U : never;
+export function stringUnionToArray<T>(): <U extends NonEmptyArray<T>>(
+  ...elements: MustInclude<T, U>
+) => MustInclude<T, U> {
+  return (...elements) => elements;
+}
+
+export type StringSuggestions<T extends string> = T | Omit<string, T>;
+export function suggestionsAsString<T>(
+  value: T,
+): T extends StringSuggestions<infer U> ? Exclude<T, StringSuggestions<U>> | string : T {
+  return value as any;
+}
+
+export type ParametersWithOverloads<T extends (...args: any[]) => any> = T extends {
+  (...args: infer A1): any;
+  (...args: infer A2): any;
+  (...args: infer A3): any;
+  (...args: infer A4): any;
+  (...args: infer A5): any;
+  (...args: infer A6): any;
+} ? A1 | A2 | A3 | A4 | A5 | A6
+  : T extends {
+    (...args: infer A1): any;
+    (...args: infer A2): any;
+    (...args: infer A3): any;
+    (...args: infer A4): any;
+    (...args: infer A5): any;
+  } ? A1 | A2 | A3 | A4 | A5
+  : T extends {
+    (...args: infer A1): any;
+    (...args: infer A2): any;
+    (...args: infer A3): any;
+    (...args: infer A4): any;
+  } ? A1 | A2 | A3 | A4
+  : T extends {
+    (...args: infer A1): any;
+    (...args: infer A2): any;
+    (...args: infer A3): any;
+  } ? A1 | A2 | A3
+  : T extends {
+    (...args: infer A1): any;
+    (...args: infer A2): any;
+  } ? A1 | A2
+  : T extends {
+    (...args: infer A1): any;
+  } ? A1
+  : never;
+
+type _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N ? R : _TupleOf<T, N, [T, ...R]>;
+export type TupleWithCount<T, N extends number | number[]> = N extends number ? number extends N ? T[]
+  : _TupleOf<T, N, []>
+  : N extends [infer A, ...infer R]
+    ? A extends number ? R extends number[] ? TupleWithCount<T, A> | TupleWithCount<T, R>
+      : never
+    : never
+  : N extends [] ? never
+  : T[];
+
+export type MaybePromise<T> = T | Promise<T>;