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

package/.eslintrc.json

@@ -0,0 +1,4 @@
+{
+    "extends": "../../.eslintrc.js",
+    "ignorePatterns": ["src/type-utils/*"]
+}

package/lib/cjs/iconNames.js

@@ -19,7 +19,6 @@ exports.IconNames = void 0;
 var tslib_1 = require("tslib");
 /* eslint-disable camelcase */
 var change_case_1 = require("change-case");
-// icon sets are identical aside from SVG paths, so we just import the info for the 16px set
 var blueprint_icons_16_1 = require("./generated/16px/blueprint-icons-16");
 var IconNamesNew = {};
 var IconNamesLegacy = {};

package/lib/cjs/iconNames.js.map

@@ -1 +1 @@
-{"version":3,"file":"iconNames.js","sourceRoot":"","sources":["../../src/iconNames.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;;AAEH,8BAA8B;AAE9B,2CAAoD;AAGpD,4FAA4F;AAC5F,0EAAyG;AAIzG,IAAM,YAAY,GAAG,EAA4C,CAAC;AAClE,IAAM,eAAe,GAAG,EAAoD,CAAC;AAE7E,KAAmB,UAA8C,EAA9C,KAAA,MAAM,CAAC,MAAM,CAAC,sCAAiB,CAAe,EAA9C,cAA8C,EAA9C,IAA8C,EAAE;IAA9D,IAAM,MAAI,SAAA;IACX,YAAY,CAAC,wBAAU,CAAC,MAAI,CAAyB,CAAC,GAAG,MAAI,CAAC;IAC9D,eAAe,CAAC,uBAAS,CAAC,MAAI,CAAC,CAAC,WAAW,EAAkC,CAAC,GAAG,MAAI,CAAC;CACzF;AAEY,QAAA,SAAS,yCACf,YAAY,GACZ,eAAe,EACpB"}
+{"version":3,"file":"iconNames.js","sourceRoot":"","sources":["../../src/iconNames.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;;AAEH,8BAA8B;AAE9B,2CAAoD;AAEpD,0EAAyG;AAOzG,IAAM,YAAY,GAAG,EAA4C,CAAC;AAClE,IAAM,eAAe,GAAG,EAAoD,CAAC;AAE7E,KAAmB,UAA8C,EAA9C,KAAA,MAAM,CAAC,MAAM,CAAC,sCAAiB,CAAe,EAA9C,cAA8C,EAA9C,IAA8C,EAAE;IAA9D,IAAM,MAAI,SAAA;IACX,YAAY,CAAC,wBAAU,CAAC,MAAI,CAAyB,CAAC,GAAG,MAAI,CAAC;IAC9D,eAAe,CAAC,uBAAS,CAAC,MAAI,CAAC,CAAC,WAAW,EAAkC,CAAC,GAAG,MAAI,CAAC;CACzF;AAEY,QAAA,SAAS,yCACf,YAAY,GACZ,eAAe,EACpB"}

package/lib/cjs/iconSvgPaths.d.ts

@@ -1,5 +1,5 @@
-import type { PascalCase } from "type-fest";
 import type { IconName } from "./iconNames";
+import type { PascalCase } from "./type-utils";
 export declare const IconSvgPaths16: Record<import("./generated/16px/blueprint-icons-16").BlueprintIcons_16Key, string[]>;
 export declare const IconSvgPaths20: Record<import("./generated/16px/blueprint-icons-16").BlueprintIcons_16Key, string[]>;
 /**

package/lib/cjs/type-utils/camel-case.d.ts

@@ -0,0 +1,63 @@
+import { WordSeparators } from "./sourceUtilities";
+import { Split } from "./utilities";
+/**
+Step by step takes the first item in an array literal, formats it and adds it to a string literal, and then recursively appends the remainder.
+
+Only to be used by `CamelCaseStringArray<>`.
+
+@see CamelCaseStringArray
+*/
+declare type InnerCamelCaseStringArray<Parts extends any[], PreviousPart> = Parts extends [
+    `${infer FirstPart}`,
+    ...infer RemainingParts
+] ? FirstPart extends undefined ? "" : FirstPart extends "" ? InnerCamelCaseStringArray<RemainingParts, PreviousPart> : `${PreviousPart extends "" ? FirstPart : Capitalize<FirstPart>}${InnerCamelCaseStringArray<RemainingParts, FirstPart>}` : "";
+/**
+Starts fusing the output of `Split<>`, an array literal of strings, into a camel-cased string literal.
+
+It's separate from `InnerCamelCaseStringArray<>` to keep a clean API outwards to the rest of the code.
+
+@see Split
+*/
+declare type CamelCaseStringArray<Parts extends string[]> = Parts extends [`${infer FirstPart}`, ...infer RemainingParts] ? Uncapitalize<`${FirstPart}${InnerCamelCaseStringArray<RemainingParts, FirstPart>}`> : never;
+/**
+Convert a string literal to camel-case.
+
+This can be useful when, for example, converting some kebab-cased command-line flags or a snake-cased database result.
+
+@example
+```
+import {CamelCase} from 'type-fest';
+
+// Simple
+
+const someVariable: CamelCase<'foo-bar'> = 'fooBar';
+
+// Advanced
+
+type CamelCasedProperties<T> = {
+    [K in keyof T as CamelCase<K>]: T[K]
+};
+
+interface RawOptions {
+    'dry-run': boolean;
+    'full_family_name': string;
+    foo: number;
+    BAR: string;
+    QUZ_QUX: number;
+    'OTHER-FIELD': boolean;
+}
+
+const dbResult: CamelCasedProperties<ModelProps> = {
+    dryRun: true,
+    fullFamilyName: 'bar.js',
+    foo: 123,
+    bar: 'foo',
+    quzQux: 6,
+    otherField: false
+};
+```
+
+@category Template Literals
+*/
+export declare type CamelCase<K> = K extends string ? K extends Uppercase<K> ? CamelCaseStringArray<Split<Lowercase<K>, WordSeparators>> : CamelCaseStringArray<Split<K, WordSeparators>> : K;
+export {};

package/lib/cjs/type-utils/camel-case.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=camel-case.js.map

package/lib/cjs/type-utils/camel-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"camel-case.js","sourceRoot":"","sources":["../../../src/type-utils/camel-case.ts"],"names":[],"mappings":""}

package/lib/cjs/type-utils/delimiter-case.d.ts

@@ -0,0 +1,64 @@
+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 declare 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
+*/
+declare 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
+*/
+declare 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 declare type DelimiterCase<Value, Delimiter extends string> = Value extends string ? StringArrayToDelimiterCase<SplitIncludingDelimiters<Value, WordSeparators | UpperCaseCharacters>, WordSeparators, UpperCaseCharacters, Delimiter> : Value;
+export {};

package/lib/cjs/type-utils/delimiter-case.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=delimiter-case.js.map

package/lib/cjs/type-utils/delimiter-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delimiter-case.js","sourceRoot":"","sources":["../../../src/type-utils/delimiter-case.ts"],"names":[],"mappings":""}

package/lib/cjs/type-utils/includes.d.ts

@@ -0,0 +1,22 @@
+/**
+Returns a boolean for whether given two types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+*/
+declare 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 declare type Includes<Value extends any[], Item> = IsEqual<Value[0], Item> extends true ? true : Value extends [Value[0], ...infer rest] ? Includes<rest, Item> : false;
+export {};

package/lib/cjs/type-utils/includes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=includes.js.map

package/lib/cjs/type-utils/includes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"includes.js","sourceRoot":"","sources":["../../../src/type-utils/includes.ts"],"names":[],"mappings":""}

package/lib/cjs/type-utils/index.d.ts

@@ -0,0 +1,3 @@
+/** @fileoverview Mapped type utils copied from the "type-fest" package */
+export { PascalCase } from "./pascal-case";
+export { ScreamingSnakeCase } from "./screaming-snake-case";

package/lib/cjs/type-utils/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/lib/cjs/type-utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/type-utils/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG"}

package/lib/cjs/type-utils/pascal-case.d.ts

@@ -0,0 +1,34 @@
+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 declare type PascalCase<Value> = CamelCase<Value> extends string ? Capitalize<CamelCase<Value>> : CamelCase<Value>;

package/lib/cjs/type-utils/pascal-case.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=pascal-case.js.map

package/lib/cjs/type-utils/pascal-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pascal-case.js","sourceRoot":"","sources":["../../../src/type-utils/pascal-case.ts"],"names":[],"mappings":""}

package/lib/cjs/type-utils/screaming-snake-case.d.ts

@@ -0,0 +1,23 @@
+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.
+*/
+declare 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 declare type ScreamingSnakeCase<Value> = Value extends string ? IsScreamingSnakeCase<Value> extends true ? Value : Uppercase<SnakeCase<Value>> : Value;
+export {};

package/lib/cjs/type-utils/screaming-snake-case.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=screaming-snake-case.js.map

package/lib/cjs/type-utils/screaming-snake-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"screaming-snake-case.js","sourceRoot":"","sources":["../../../src/type-utils/screaming-snake-case.ts"],"names":[],"mappings":""}

package/lib/cjs/type-utils/snake-case.d.ts

@@ -0,0 +1,36 @@
+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 declare type SnakeCase<Value> = DelimiterCase<Value, "_">;

package/lib/cjs/type-utils/snake-case.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=snake-case.js.map

package/lib/cjs/type-utils/snake-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snake-case.js","sourceRoot":"","sources":["../../../src/type-utils/snake-case.ts"],"names":[],"mappings":""}

package/lib/cjs/type-utils/sourceUtilities.d.ts

@@ -0,0 +1,3 @@
+export declare 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 declare type WordSeparators = "-" | "_" | " ";
+export declare type StringDigit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";

package/lib/cjs/type-utils/sourceUtilities.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=sourceUtilities.js.map

package/lib/cjs/type-utils/sourceUtilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sourceUtilities.js","sourceRoot":"","sources":["../../../src/type-utils/sourceUtilities.ts"],"names":[],"mappings":""}

package/lib/cjs/type-utils/utilities.d.ts

@@ -0,0 +1,4 @@
+/**
+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 declare 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];

package/lib/cjs/type-utils/utilities.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=utilities.js.map

package/lib/cjs/type-utils/utilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.js","sourceRoot":"","sources":["../../../src/type-utils/utilities.ts"],"names":[],"mappings":""}

package/lib/esm/iconNames.js

@@ -16,7 +16,6 @@
 import { __assign } from "tslib";
 /* eslint-disable camelcase */
 import { pascalCase, snakeCase } from "change-case";
-// icon sets are identical aside from SVG paths, so we just import the info for the 16px set
 import { BlueprintIcons_16 } from "./generated/16px/blueprint-icons-16";
 var IconNamesNew = {};
 var IconNamesLegacy = {};

package/lib/esm/iconNames.js.map

@@ -1 +1 @@
-{"version":3,"file":"iconNames.js","sourceRoot":"","sources":["../../src/iconNames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;;AAEH,8BAA8B;AAE9B,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGpD,4FAA4F;AAC5F,OAAO,EAAE,iBAAiB,EAAmC,MAAM,qCAAqC,CAAC;AAIzG,IAAM,YAAY,GAAG,EAA4C,CAAC;AAClE,IAAM,eAAe,GAAG,EAAoD,CAAC;AAE7E,KAAmB,UAA8C,EAA9C,KAAA,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAe,EAA9C,cAA8C,EAA9C,IAA8C,EAAE;IAA9D,IAAM,MAAI,SAAA;IACX,YAAY,CAAC,UAAU,CAAC,MAAI,CAAyB,CAAC,GAAG,MAAI,CAAC;IAC9D,eAAe,CAAC,SAAS,CAAC,MAAI,CAAC,CAAC,WAAW,EAAkC,CAAC,GAAG,MAAI,CAAC;CACzF;AAED,MAAM,CAAC,IAAM,SAAS,yBACf,YAAY,GACZ,eAAe,CACrB,CAAC"}
+{"version":3,"file":"iconNames.js","sourceRoot":"","sources":["../../src/iconNames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;;AAEH,8BAA8B;AAE9B,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAEpD,OAAO,EAAE,iBAAiB,EAAmC,MAAM,qCAAqC,CAAC;AAOzG,IAAM,YAAY,GAAG,EAA4C,CAAC;AAClE,IAAM,eAAe,GAAG,EAAoD,CAAC;AAE7E,KAAmB,UAA8C,EAA9C,KAAA,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAe,EAA9C,cAA8C,EAA9C,IAA8C,EAAE;IAA9D,IAAM,MAAI,SAAA;IACX,YAAY,CAAC,UAAU,CAAC,MAAI,CAAyB,CAAC,GAAG,MAAI,CAAC;IAC9D,eAAe,CAAC,SAAS,CAAC,MAAI,CAAC,CAAC,WAAW,EAAkC,CAAC,GAAG,MAAI,CAAC;CACzF;AAED,MAAM,CAAC,IAAM,SAAS,yBACf,YAAY,GACZ,eAAe,CACrB,CAAC"}

package/lib/esm/iconSvgPaths.d.ts

@@ -1,5 +1,5 @@
-import type { PascalCase } from "type-fest";
 import type { IconName } from "./iconNames";
+import type { PascalCase } from "./type-utils";
 export declare const IconSvgPaths16: Record<import("./generated/16px/blueprint-icons-16").BlueprintIcons_16Key, string[]>;
 export declare const IconSvgPaths20: Record<import("./generated/16px/blueprint-icons-16").BlueprintIcons_16Key, string[]>;
 /**

package/lib/esm/type-utils/camel-case.d.ts

@@ -0,0 +1,63 @@
+import { WordSeparators } from "./sourceUtilities";
+import { Split } from "./utilities";
+/**
+Step by step takes the first item in an array literal, formats it and adds it to a string literal, and then recursively appends the remainder.
+
+Only to be used by `CamelCaseStringArray<>`.
+
+@see CamelCaseStringArray
+*/
+declare type InnerCamelCaseStringArray<Parts extends any[], PreviousPart> = Parts extends [
+    `${infer FirstPart}`,
+    ...infer RemainingParts
+] ? FirstPart extends undefined ? "" : FirstPart extends "" ? InnerCamelCaseStringArray<RemainingParts, PreviousPart> : `${PreviousPart extends "" ? FirstPart : Capitalize<FirstPart>}${InnerCamelCaseStringArray<RemainingParts, FirstPart>}` : "";
+/**
+Starts fusing the output of `Split<>`, an array literal of strings, into a camel-cased string literal.
+
+It's separate from `InnerCamelCaseStringArray<>` to keep a clean API outwards to the rest of the code.
+
+@see Split
+*/
+declare type CamelCaseStringArray<Parts extends string[]> = Parts extends [`${infer FirstPart}`, ...infer RemainingParts] ? Uncapitalize<`${FirstPart}${InnerCamelCaseStringArray<RemainingParts, FirstPart>}`> : never;
+/**
+Convert a string literal to camel-case.
+
+This can be useful when, for example, converting some kebab-cased command-line flags or a snake-cased database result.
+
+@example
+```
+import {CamelCase} from 'type-fest';
+
+// Simple
+
+const someVariable: CamelCase<'foo-bar'> = 'fooBar';
+
+// Advanced
+
+type CamelCasedProperties<T> = {
+    [K in keyof T as CamelCase<K>]: T[K]
+};
+
+interface RawOptions {
+    'dry-run': boolean;
+    'full_family_name': string;
+    foo: number;
+    BAR: string;
+    QUZ_QUX: number;
+    'OTHER-FIELD': boolean;
+}
+
+const dbResult: CamelCasedProperties<ModelProps> = {
+    dryRun: true,
+    fullFamilyName: 'bar.js',
+    foo: 123,
+    bar: 'foo',
+    quzQux: 6,
+    otherField: false
+};
+```
+
+@category Template Literals
+*/
+export declare type CamelCase<K> = K extends string ? K extends Uppercase<K> ? CamelCaseStringArray<Split<Lowercase<K>, WordSeparators>> : CamelCaseStringArray<Split<K, WordSeparators>> : K;
+export {};

package/lib/esm/type-utils/camel-case.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=camel-case.js.map

package/lib/esm/type-utils/camel-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"camel-case.js","sourceRoot":"","sources":["../../../src/type-utils/camel-case.ts"],"names":[],"mappings":""}

package/lib/esm/type-utils/delimiter-case.d.ts

@@ -0,0 +1,64 @@
+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 declare 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
+*/
+declare 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
+*/
+declare 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 declare type DelimiterCase<Value, Delimiter extends string> = Value extends string ? StringArrayToDelimiterCase<SplitIncludingDelimiters<Value, WordSeparators | UpperCaseCharacters>, WordSeparators, UpperCaseCharacters, Delimiter> : Value;
+export {};

package/lib/esm/type-utils/delimiter-case.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=delimiter-case.js.map

package/lib/esm/type-utils/delimiter-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delimiter-case.js","sourceRoot":"","sources":["../../../src/type-utils/delimiter-case.ts"],"names":[],"mappings":""}

package/lib/esm/type-utils/includes.d.ts

@@ -0,0 +1,22 @@
+/**
+Returns a boolean for whether given two types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+*/
+declare 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 declare type Includes<Value extends any[], Item> = IsEqual<Value[0], Item> extends true ? true : Value extends [Value[0], ...infer rest] ? Includes<rest, Item> : false;
+export {};

package/lib/esm/type-utils/includes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=includes.js.map

package/lib/esm/type-utils/includes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"includes.js","sourceRoot":"","sources":["../../../src/type-utils/includes.ts"],"names":[],"mappings":""}

package/lib/esm/type-utils/index.d.ts

@@ -0,0 +1,3 @@
+/** @fileoverview Mapped type utils copied from the "type-fest" package */
+export { PascalCase } from "./pascal-case";
+export { ScreamingSnakeCase } from "./screaming-snake-case";

package/lib/esm/type-utils/index.js

@@ -0,0 +1,17 @@
+/*
+ * 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.
+ */
+export {};
+//# sourceMappingURL=index.js.map

package/lib/esm/type-utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/type-utils/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}