@blueprintjs/icons 4.0.0-beta.3 → 4.0.0-beta.7

package/lib/esnext/iconNames.js

@@ -14,16 +14,16 @@
  * limitations under the License.
  */
 /* eslint-disable camelcase */
-import { 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";
+import { pascalCase, snakeCase } from "change-case";
+import { BlueprintIcons_16 } from "./generated/16px/blueprint-icons-16";
+const IconNamesNew = {};
 const IconNamesLegacy = {};
-for (const [pascalCaseKey, iconName] of Object.entries(BlueprintIcons_16)) {
-    const screamingSnakeCaseKey = snakeCase(pascalCaseKey).toUpperCase();
-    IconNamesLegacy[screamingSnakeCaseKey] = iconName;
+for (const name of Object.values(BlueprintIcons_16)) {
+    IconNamesNew[pascalCase(name)] = name;
+    IconNamesLegacy[snakeCase(name).toUpperCase()] = name;
 }
 export const IconNames = {
-    ...BlueprintIcons_16,
+    ...IconNamesNew,
     ...IconNamesLegacy,
 };
 //# sourceMappingURL=iconNames.js.map

package/lib/esnext/iconNames.js.map

@@ -1 +1 @@
-{"version":3,"file":"iconNames.js","sourceRoot":"","sources":["../../src/iconNames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,8BAA8B;AAE9B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,4FAA4F;AAC5F,OAAO,EACH,iBAAiB,GAGpB,MAAM,qCAAqC,CAAC;AAI7C,MAAM,eAAe,GAA6B,EAAE,CAAC;AAErD,KAAK,MAAM,CAAC,aAAa,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC,EAAE;IACvE,MAAM,qBAAqB,GAAG,SAAS,CAAC,aAAa,CAAC,CAAC,WAAW,EAAE,CAAC;IACrE,eAAe,CAAC,qBAAqB,CAAC,GAAG,QAAQ,CAAC;CACrD;AAED,MAAM,CAAC,MAAM,SAAS,GAAG;IACrB,GAAG,iBAAiB;IACpB,GAAI,eAAiE;CACxE,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,MAAM,YAAY,GAAG,EAA4C,CAAC;AAClE,MAAM,eAAe,GAAG,EAAoD,CAAC;AAE7E,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAe,EAAE;IAC/D,YAAY,CAAC,UAAU,CAAC,IAAI,CAAyB,CAAC,GAAG,IAAI,CAAC;IAC9D,eAAe,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,WAAW,EAAkC,CAAC,GAAG,IAAI,CAAC;CACzF;AAED,MAAM,CAAC,MAAM,SAAS,GAAG;IACrB,GAAG,YAAY;IACf,GAAG,eAAe;CACrB,CAAC"}

package/lib/esnext/iconSvgPaths.d.ts

@@ -1,12 +1,9 @@
-import * as IconSvgPaths16 from "./generated/16px/paths";
-import * as IconSvgPaths20 from "./generated/20px/paths";
 import type { IconName } from "./iconNames";
-export { IconSvgPaths16, IconSvgPaths20 };
+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[]>;
 /**
- * Type safe string literal conversion of snake-case icon names to camelCase icon names,
+ * Type safe string literal conversion of snake-case icon names to PascalCase icon names,
  * useful for indexing into the SVG paths record to extract a single icon's SVG path definition.
- *
- * N.B. `IconSvgPaths16` and `IconSvgPaths20` are assignable to each other, so it doesn't matter
- * which one is used in the return type definition here.
  */
-export declare function iconNameToPathsRecordKey(name: IconName): keyof typeof IconSvgPaths16;
+export declare function iconNameToPathsRecordKey(name: IconName): PascalCase<IconName>;

package/lib/esnext/iconSvgPaths.js

@@ -13,30 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as IconSvgPaths16 from "./generated/16px/paths";
-import * as IconSvgPaths20 from "./generated/20px/paths";
-export { IconSvgPaths16, IconSvgPaths20 };
+import { pascalCase } from "change-case";
+/* eslint-disable @typescript-eslint/no-var-requires */
+export const IconSvgPaths16 = require("./generated/16px/paths");
+export const IconSvgPaths20 = require("./generated/20px/paths");
+/* eslint-enable @typescript-eslint/no-var-requires */
 /**
- * Type safe string literal conversion of snake-case icon names to camelCase icon names,
+ * Type safe string literal conversion of snake-case icon names to PascalCase icon names,
  * useful for indexing into the SVG paths record to extract a single icon's SVG path definition.
- *
- * N.B. `IconSvgPaths16` and `IconSvgPaths20` are assignable to each other, so it doesn't matter
- * which one is used in the return type definition here.
  */
 export function iconNameToPathsRecordKey(name) {
-    return kebabCaseToCamelCase(name);
-}
-/**
- * Type safe string literal conversion of snake-case strings to camelCase strings.
- * Note that this requires TypeScript 4.1+.
- *
- * Implementation and template literal mapped types borrowed from
- * https://davidtimms.github.io/programming-languages/typescript/2020/11/20/exploring-template-literal-types-in-typescript-4.1.html
- */
-function kebabCaseToCamelCase(snakeCaseString) {
-    return snakeCaseString
-        .split("-")
-        .map((word, i) => (i === 0 ? word.toLowerCase() : word && word[0].toUpperCase() + word.slice(1).toLowerCase()))
-        .join("");
+    return pascalCase(name);
 }
 //# sourceMappingURL=iconSvgPaths.js.map

package/lib/esnext/iconSvgPaths.js.map

@@ -1 +1 @@
-{"version":3,"file":"iconSvgPaths.js","sourceRoot":"","sources":["../../src/iconSvgPaths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,cAAc,MAAM,wBAAwB,CAAC;AACzD,OAAO,KAAK,cAAc,MAAM,wBAAwB,CAAC;AAGzD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CAAC,IAAc;IACnD,OAAO,oBAAoB,CAAC,IAAI,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;GAMG;AACH,SAAS,oBAAoB,CAAmB,eAAkB;IAC9D,OAAO,eAAe;SACjB,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;SAC9G,IAAI,CAAC,EAAE,CAA4B,CAAC;AAC7C,CAAC"}
+{"version":3,"file":"iconSvgPaths.js","sourceRoot":"","sources":["../../src/iconSvgPaths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAKzC,uDAAuD;AACvD,MAAM,CAAC,MAAM,cAAc,GAAG,OAAO,CAAC,wBAAwB,CAA2C,CAAC;AAC1G,MAAM,CAAC,MAAM,cAAc,GAAG,OAAO,CAAC,wBAAwB,CAA2C,CAAC;AAC1G,sDAAsD;AAEtD;;;GAGG;AACH,MAAM,UAAU,wBAAwB,CAAC,IAAc;IACnD,OAAO,UAAU,CAAC,IAAI,CAAyB,CAAC;AACpD,CAAC"}

package/lib/esnext/index.d.ts

@@ -1,3 +1,3 @@
 export { IconSvgPaths16, IconSvgPaths20, iconNameToPathsRecordKey } from "./iconSvgPaths";
-export { IconCodepoints } from "./iconCodepoints";
+export { getIconContentString, IconCodepoints } from "./iconCodepoints";
 export { IconName, IconNames } from "./iconNames";

package/lib/esnext/index.js

@@ -14,6 +14,6 @@
  * limitations under the License.
  */
 export { IconSvgPaths16, IconSvgPaths20, iconNameToPathsRecordKey } from "./iconSvgPaths";
-export { IconCodepoints } from "./iconCodepoints";
+export { getIconContentString, IconCodepoints } from "./iconCodepoints";
 export { IconNames } from "./iconNames";
 //# sourceMappingURL=index.js.map

package/lib/esnext/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAC1F,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAY,SAAS,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAC1F,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,EAAY,SAAS,EAAE,MAAM,aAAa,CAAC"}

package/lib/esnext/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/esnext/type-utils/camel-case.js

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

package/lib/esnext/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/esnext/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/esnext/type-utils/delimiter-case.js

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

package/lib/esnext/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/esnext/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/esnext/type-utils/includes.js

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

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

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

package/lib/esnext/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/esnext/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/esnext/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/esnext/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/esnext/type-utils/pascal-case.js

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

package/lib/esnext/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/esnext/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/esnext/type-utils/screaming-snake-case.js

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

package/lib/esnext/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/esnext/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/esnext/type-utils/snake-case.js

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

package/lib/esnext/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/esnext/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/esnext/type-utils/sourceUtilities.js

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

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

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

package/lib/esnext/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/esnext/type-utils/utilities.js

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

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

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