@contember/utilities 1.2.0-alpha.1

package/src/functional/pick.ts

@@ -0,0 +1,13 @@
+export function pick<T extends Object, K extends keyof T>(object: T, properties: K[]): Pick<T, K> {
+	const next: Partial<Pick<T, K>> = {}
+
+	for (let key of properties) {
+		if (key in object) {
+			next[key] = object[key]
+		} else {
+			throw new Error(`Key "${String(key)}" does not exist in object ${JSON.stringify(object)}`)
+		}
+	}
+
+	return next as Pick<T, K>
+}

package/src/functional/setHasOneOf.ts

@@ -0,0 +1,3 @@
+export function setHasOneOf<T>(set: Set<T>, values: T[]): boolean {
+  return values.some(value => set.has(value))
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './assert-types'
+export * from './class-name'
+export * from './css-utilities'
+export * from './dom'
+export * from './functional'
+export * from './string-utilities'
+export * from './typescript-utilities'

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,2 @@
+export * from './capitalize'
+export * from './trimString'

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/typescript-utilities/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/typescript-utilities/NonNullableRequired.ts

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

package/src/typescript-utilities/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/typescript-utilities/PolymorphicRefs.ts

@@ -0,0 +1,58 @@
+// 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> }

package/src/typescript-utilities/Try.ts

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

package/src/typescript-utilities/index.ts

@@ -0,0 +1,5 @@
+export * from './DeepPartial'
+export * from './NonNullableRequired'
+export * from './ObjectKeyValue'
+export * from './PolymorphicRefs'
+export * from './Try'