@contember/utilities 0.0.0

package/src/string-utilities/capitalize.ts

@@ -0,0 +1,3 @@
+export function capitalize(str: string) {
+  return str.charAt(0).toUpperCase() + str.slice(1)
+}

package/src/string-utilities/index.ts

@@ -0,0 +1,3 @@
+export * from './capitalize'
+export * from './kebabCase'
+export * from './trimString'

package/src/string-utilities/kebabCase.ts

@@ -0,0 +1,5 @@
+const UPPER_CASE_REG_EXP = /([A-Z])/g
+
+export function toKebabCase(value: string) {
+	return value.replace(UPPER_CASE_REG_EXP, '-$1').toLowerCase()
+}

package/src/string-utilities/trimString.ts

@@ -0,0 +1,12 @@
+/**
+ * Trims the provided string of any characters in the provided set.
+ *
+ * @param value - The string to trim.
+ * @param characters - The characters to remove.
+ * @returns	The trimmed string.
+ */
+export function trimString(value: string, characters: string) {
+	const regExp = new RegExp(`^[${characters}]*|[${characters}]*$`, 'g')
+
+	return value.replace(regExp, '')
+}

package/src/tsconfig.json

@@ -0,0 +1,6 @@
+{
+	"extends": "../../../tsconfig.settings.json",
+	"compilerOptions": {
+		"outDir": "../dist/types"
+	}
+}

package/src/types/Any.ts

@@ -0,0 +1,3 @@
+export type KeyofBase = keyof any;
+export type AnyArray<Type = any> = Array<Type> | ReadonlyArray<Type>;
+export type AnyRecord<T = any> = Record<KeyofBase, T>;

package/src/types/DeepPartial.ts

@@ -0,0 +1,7 @@
+export type DeepPartial<T> = T extends Function
+	? T
+	: T extends Array<infer InferredArrayMember>
+	? Array<DeepPartial<InferredArrayMember>>
+	: T extends object
+	? { [Key in keyof T]?: DeepPartial<T[Key]> }
+	: T | undefined;

package/src/types/Narrow.ts

@@ -0,0 +1,21 @@
+import { Try } from './Try'
+
+/**
+ * Describes types that can be narrowed
+ */
+export type Narrowable =
+	| string
+	| number
+	| bigint
+	| boolean
+
+
+type NarrowRaw<A> =
+	| (A extends [] ? [] : never)
+	| (A extends Narrowable ? A : never)
+	| ({ [K in keyof A]: A[K] extends Function
+		? A[K]
+		: NarrowRaw<A[K]> })
+
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-constraint
+export type Narrow<A extends any> = Try<A, [], NarrowRaw<A>>

package/src/types/NonNullableRequired.ts

@@ -0,0 +1 @@
+export type NonNullableRequired<T> = { [P in keyof T]-?: NonNullable<T[P]> };

package/src/types/NonOptional.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns new type where all the properties are required
+ * and previously optional properties will accept undefined.
+ */
+export type NonOptional<T> = {
+	[P in keyof Required<T>]: Pick<T, P> extends Required<Pick<T, P>> ? T[P] : (T[P] | undefined);
+}

package/src/types/ObjectKeyValue.ts

@@ -0,0 +1 @@
+export type ObjectKeyValue<T, K extends keyof T> = T extends { [P in K]: T[P] } ? T[K] : never

package/src/types/PolymorphicRefs.ts

@@ -0,0 +1,68 @@
+// Source: https://www.benmvp.com/blog/forwarding-refs-polymorphic-react-component-typescript/
+
+// Source: https://github.com/emotion-js/emotion/blob/master/packages/styled-base/types/helper.d.ts
+// A more precise version of just React.ComponentPropsWithoutRef on its own
+export type PropsOf<
+	C extends keyof JSX.IntrinsicElements | React.JSXElementConstructor<any>
+> = JSX.LibraryManagedAttributes<C, React.ComponentPropsWithoutRef<C>>
+
+export type AsProp<C extends React.ElementType> = {
+	/**
+	 * An override of the default HTML tag.
+	 * Can also be another React component.
+	 */
+	as?: C
+}
+
+/**
+ * Allows for extending a set of props (`ExtendedProps`) by an overriding set of props
+ * (`OverrideProps`), ensuring that any duplicates are overridden by the overriding
+ * set of props.
+ */
+export type ExtendableProps<
+	ExtendedProps = {},
+	OverrideProps = {}
+> = OverrideProps & Omit<ExtendedProps, keyof OverrideProps>
+
+/**
+ * Allows for inheriting the props from the specified element type so that
+ * props like children, className & style work, as well as element-specific
+ * attributes like aria roles. The component (`C`) must be passed in.
+ */
+export type InheritableElementProps<
+	C extends React.ElementType,
+	Props = {}
+> = ExtendableProps<PropsOf<C>, Props>
+
+/**
+ * A more sophisticated version of `InheritableElementProps` where
+ * the passed in `as` prop will determine which props can be included
+ */
+export type PolymorphicComponentProps<
+	C extends React.ElementType,
+	Props = {}
+> = InheritableElementProps<C, Props & AsProp<C>>
+
+/**
+ * Utility type to extract the `ref` prop from a polymorphic component
+ */
+export type PolymorphicRef<C extends React.ElementType> = React.ComponentPropsWithRef<C>['ref']
+
+/**
+ * A wrapper of `PolymorphicComponentProps` that also includes the `ref`
+ * prop for the polymorphic component
+ */
+export type PolymorphicComponentPropsWithRef<
+	C extends React.ElementType,
+	Props = {}
+> = PolymorphicComponentProps<C, Props> & { ref?: PolymorphicRef<C> }
+
+/**
+ * A polymorphic component is a component that can be rendered as different
+ * HTML elements or other React components by specifying the `as` prop.
+ * This type allows for specifying the component (`C`) and the props (`P`)
+ * that the component accepts.
+ */
+export type PolymorphicComponent<T extends React.ElementType, P = {}> =
+	& (<C extends React.ElementType = T>(props: PolymorphicComponentPropsWithRef<C, P>) => React.ReactElement | null)
+	& { displayName?: string | undefined }

package/src/types/Primitive.ts

@@ -0,0 +1 @@
+export type Primitive = string | number | boolean | null | undefined

package/src/types/RequiredDeepPlainObject.ts

@@ -0,0 +1,3 @@
+export type RequiredDeepPlainObject<T extends RequiredDeepPlainObject<Record<string, unknown>> = RequiredDeepPlainObject<Record<string, unknown>>, K extends keyof T & string = keyof T & string> = {
+	[P in K]-?: T[P] extends Record<string, unknown> ? RequiredDeepPlainObject<T[P]> : T[P]
+}

package/src/types/Try.ts

@@ -0,0 +1,4 @@
+export type Try<A1, A2, Catch = never> =
+	A1 extends A2
+	? A1
+	: Catch

package/src/types/TypeofStringLiteral.ts

@@ -0,0 +1 @@
+export type TypeofStringLiteral<T> = string extends T ? never : T

package/src/types/index.ts

@@ -0,0 +1,24 @@
+export type {
+	CamelCase,
+	DelimiterCase,
+	KebabCase,
+	LiteralToPrimitiveDeep,
+	MergeExclusive,
+	Opaque,
+	PascalCase,
+	Replace,
+	Simplify,
+	UnionToIntersection,
+	UnwrapOpaque,
+} from 'type-fest'
+export * from './Any'
+export * from './DeepPartial'
+export * from './Narrow'
+export * from './NonNullableRequired'
+export * from './NonOptional'
+export * from './ObjectKeyValue'
+export * from './PolymorphicRefs'
+export * from './Primitive'
+export * from './RequiredDeepPlainObject'
+export * from './Try'
+export * from './TypeofStringLiteral'