@blueprintjs/icons 4.0.0-beta.5 → 4.0.0-beta.6

package/src/type-utils/delimiter-case.ts

@@ -0,0 +1,105 @@
+import { UpperCaseCharacters, WordSeparators } from "./sourceUtilities";
+
+/**
+Unlike a simpler split, this one includes the delimiter splitted on in the resulting array literal. This is to enable splitting on, for example, upper-case characters.
+
+@category Template Literals
+*/
+export type SplitIncludingDelimiters<Source extends string, Delimiter extends string> = Source extends ""
+    ? []
+    : Source extends `${infer FirstPart}${Delimiter}${infer SecondPart}`
+    ? Source extends `${FirstPart}${infer UsedDelimiter}${SecondPart}`
+        ? UsedDelimiter extends Delimiter
+            ? Source extends `${infer FirstPart}${UsedDelimiter}${infer SecondPart}`
+                ? [
+                      ...SplitIncludingDelimiters<FirstPart, Delimiter>,
+                      UsedDelimiter,
+                      ...SplitIncludingDelimiters<SecondPart, Delimiter>
+                  ]
+                : never
+            : never
+        : never
+    : [Source];
+
+/**
+Format a specific part of the splitted string literal that `StringArrayToDelimiterCase<>` fuses together, ensuring desired casing.
+
+@see StringArrayToDelimiterCase
+*/
+type StringPartToDelimiterCase<
+    StringPart extends string,
+    UsedWordSeparators extends string,
+    UsedUpperCaseCharacters extends string,
+    Delimiter extends string
+> = StringPart extends UsedWordSeparators
+    ? Delimiter
+    : StringPart extends UsedUpperCaseCharacters
+    ? `${Delimiter}${Lowercase<StringPart>}`
+    : StringPart;
+
+/**
+Takes the result of a splitted string literal and recursively concatenates it together into the desired casing.
+
+It receives `UsedWordSeparators` and `UsedUpperCaseCharacters` as input to ensure it's fully encapsulated.
+
+@see SplitIncludingDelimiters
+*/
+type StringArrayToDelimiterCase<
+    Parts extends any[],
+    UsedWordSeparators extends string,
+    UsedUpperCaseCharacters extends string,
+    Delimiter extends string
+> = Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
+    ? `${StringPartToDelimiterCase<
+          FirstPart,
+          UsedWordSeparators,
+          UsedUpperCaseCharacters,
+          Delimiter
+      >}${StringArrayToDelimiterCase<RemainingParts, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}`
+    : "";
+
+/**
+Convert a string literal to a custom string delimiter casing.
+
+This can be useful when, for example, converting a camel-cased object property to an oddly cased one.
+
+@see KebabCase
+@see SnakeCase
+
+@example
+```
+import {DelimiterCase} from 'type-fest';
+
+// Simple
+
+const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
+
+// Advanced
+
+type OddlyCasedProperties<T> = {
+	[K in keyof T as DelimiterCase<K, '#'>]: T[K]
+};
+
+interface SomeOptions {
+	dryRun: boolean;
+	includeFile: string;
+	foo: number;
+}
+
+const rawCliOptions: OddlyCasedProperties<SomeOptions> = {
+	'dry#run': true,
+	'include#file': 'bar.js',
+	foo: 123
+};
+```
+
+@category Template Literals
+*/
+export type DelimiterCase<Value, Delimiter extends string> = Value extends string
+    ? StringArrayToDelimiterCase<
+          SplitIncludingDelimiters<Value, WordSeparators | UpperCaseCharacters>,
+          WordSeparators,
+          UpperCaseCharacters,
+          Delimiter
+      >
+    : Value;

package/src/type-utils/includes.ts

@@ -0,0 +1,26 @@
+/**
+Returns a boolean for whether given two types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+*/
+type IsEqual<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;
+
+/**
+Returns a boolean for whether the given array includes the given item.
+
+This can be useful if another type wants to make a decision based on whether the array includes that item.
+
+@example
+```
+import {Includes} from 'type-fest';
+
+type hasRed<array extends any[]> = Includes<array, 'red'>;
+```
+
+@category Utilities
+*/
+export type Includes<Value extends any[], Item> = IsEqual<Value[0], Item> extends true
+    ? true
+    : Value extends [Value[0], ...infer rest]
+    ? Includes<rest, Item>
+    : false;

package/src/type-utils/index.ts

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2021 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** @fileoverview Mapped type utils copied from the "type-fest" package */
+
+export { PascalCase } from "./pascal-case";
+export { ScreamingSnakeCase } from "./screaming-snake-case";

package/src/type-utils/pascal-case.ts

@@ -0,0 +1,35 @@
+import { CamelCase } from "./camel-case";
+
+/**
+Converts a string literal to pascal-case.
+
+@example
+```
+import {PascalCase} from 'type-fest';
+
+// Simple
+
+const someVariable: PascalCase<'foo-bar'> = 'FooBar';
+
+// Advanced
+
+type PascalCaseProps<T> = {
+	[K in keyof T as PascalCase<K>]: T[K]
+};
+
+interface RawOptions {
+	'dry-run': boolean;
+	'full_family_name': string;
+	foo: number;
+}
+
+const dbResult: CamelCasedProperties<ModelProps> = {
+	DryRun: true,
+	FullFamilyName: 'bar.js',
+	Foo: 123
+};
+```
+
+@category Template Literals
+*/
+export type PascalCase<Value> = CamelCase<Value> extends string ? Capitalize<CamelCase<Value>> : CamelCase<Value>;

package/src/type-utils/screaming-snake-case.ts

@@ -0,0 +1,32 @@
+import { SplitIncludingDelimiters } from "./delimiter-case";
+import { SnakeCase } from "./snake-case";
+import { Includes } from "./includes";
+
+/**
+Returns a boolean for whether the string is screaming snake case.
+*/
+type IsScreamingSnakeCase<Value extends string> = Value extends Uppercase<Value>
+    ? Includes<SplitIncludingDelimiters<Lowercase<Value>, "_">, "_"> extends true
+        ? true
+        : false
+    : false;
+
+/**
+Convert a string literal to screaming-snake-case.
+
+This can be useful when, for example, converting a camel-cased object property to a screaming-snake-cased SQL column name.
+
+@example
+```
+import {ScreamingSnakeCase} from 'type-fest';
+
+const someVariable: ScreamingSnakeCase<'fooBar'> = 'FOO_BAR';
+```
+
+@category Template Literals
+*/
+export type ScreamingSnakeCase<Value> = Value extends string
+    ? IsScreamingSnakeCase<Value> extends true
+        ? Value
+        : Uppercase<SnakeCase<Value>>
+    : Value;

package/src/type-utils/snake-case.ts

@@ -0,0 +1,37 @@
+import { DelimiterCase } from "./delimiter-case";
+
+/**
+Convert a string literal to snake-case.
+
+This can be useful when, for example, converting a camel-cased object property to a snake-cased SQL column name.
+
+@example
+```
+import {SnakeCase} from 'type-fest';
+
+// Simple
+
+const someVariable: SnakeCase<'fooBar'> = 'foo_bar';
+
+// Advanced
+
+type SnakeCasedProperties<T> = {
+	[K in keyof T as SnakeCase<K>]: T[K]
+};
+
+interface ModelProps {
+	isHappy: boolean;
+	fullFamilyName: string;
+	foo: number;
+}
+
+const dbResult: SnakeCasedProperties<ModelProps> = {
+	'is_happy': true,
+	'full_family_name': 'Carla Smith',
+	foo: 123
+};
+```
+
+@category Template Literals
+*/
+export type SnakeCase<Value> = DelimiterCase<Value, "_">;

package/src/type-utils/sourceUtilities.ts

@@ -0,0 +1,31 @@
+export type UpperCaseCharacters =
+    | "A"
+    | "B"
+    | "C"
+    | "D"
+    | "E"
+    | "F"
+    | "G"
+    | "H"
+    | "I"
+    | "J"
+    | "K"
+    | "L"
+    | "M"
+    | "N"
+    | "O"
+    | "P"
+    | "Q"
+    | "R"
+    | "S"
+    | "T"
+    | "U"
+    | "V"
+    | "W"
+    | "X"
+    | "Y"
+    | "Z";
+
+export type WordSeparators = "-" | "_" | " ";
+
+export type StringDigit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";

package/src/type-utils/utilities.ts

@@ -0,0 +1,10 @@
+/**
+Recursively split a string literal into two parts on the first occurence of the given string, returning an array literal of all the separate parts.
+*/
+export type Split<S extends string, D extends string> = string extends S
+    ? string[]
+    : S extends ""
+    ? []
+    : S extends `${infer T}${D}${infer U}`
+    ? [T, ...Split<U, D>]
+    : [S];