@edvisor/product-language 0.11.112 → 0.11.113

package/lib/foundations/typography/text-aspect-flags.d.ts

@@ -1,30 +1,30 @@
-import { MappedEnum, PropsWithChildren, RequireOnlyOne } from '@helpers';
-export declare const enum TextAspects {
-    default = 1,
-    subdued = 2,
-    light = 4,
-    critical = 8,
-    success = 16,
-    onPrimary = 32,
-    onCritical = 64
-}
-declare type TextOptions<T> = MappedEnum<typeof TextAspects, T>;
-export declare const TextAspectColors: {
-    1: "#1F2937";
-    2: "#6B7280";
-    4: "#9CA3AF";
-    32: "#FFFFFF";
-    64: "#FFFFFF";
-    16: "#059669";
-    8: "#DC2626";
-};
-export declare type ITextAspectProps = Partial<RequireOnlyOne<TextOptions<boolean>>> & PropsWithChildren;
-export declare type TransientTextOptions = Omit<TextOptions<boolean>, 'onCritical' | 'onPrimary'> & {
-    $onCritical?: boolean;
-    $onPrimary?: boolean;
-};
-export declare type ITransientTextAspectProps = Partial<RequireOnlyOne<TransientTextOptions>> & {
-    $underlined?: boolean;
-} & PropsWithChildren;
-export declare function getTextAspect(props: ITextAspectProps & ITransientTextAspectProps): "#9CA3AF" | "#6B7280" | "#1F2937" | "#DC2626" | "#059669" | "#FFFFFF";
-export {};
+import { MappedEnum, PropsWithChildren, RequireOnlyOne } from '@helpers';
+export declare const enum TextAspects {
+    default = 1,
+    subdued = 2,
+    light = 4,
+    critical = 8,
+    success = 16,
+    onPrimary = 32,
+    onCritical = 64
+}
+type TextOptions<T> = MappedEnum<typeof TextAspects, T>;
+export declare const TextAspectColors: {
+    1: "#1F2937";
+    2: "#6B7280";
+    4: "#9CA3AF";
+    32: "#FFFFFF";
+    64: "#FFFFFF";
+    16: "#059669";
+    8: "#DC2626";
+};
+export type ITextAspectProps = Partial<RequireOnlyOne<TextOptions<boolean>>> & PropsWithChildren;
+export type TransientTextOptions = Omit<TextOptions<boolean>, 'onCritical' | 'onPrimary'> & {
+    $onCritical?: boolean;
+    $onPrimary?: boolean;
+};
+export type ITransientTextAspectProps = Partial<RequireOnlyOne<TransientTextOptions>> & {
+    $underlined?: boolean;
+} & PropsWithChildren;
+export declare function getTextAspect(props: ITextAspectProps & ITransientTextAspectProps): "#9CA3AF" | "#6B7280" | "#1F2937" | "#DC2626" | "#059669" | "#FFFFFF";
+export {};

package/lib/foundations/typography/typography.d.ts

@@ -1,24 +1,24 @@
-import { ITransientTextAspectProps } from './text-aspect-flags';
-export declare type ILabelProps = ITransientTextAspectProps & {
-    default?: boolean;
-    subtle?: boolean;
-    strong?: boolean;
-};
-export declare type IBodyProps = ITransientTextAspectProps & {
-    default?: boolean;
-    strong?: boolean;
-};
-export declare const Typography: {
-    Display: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<ITransientTextAspectProps, any>>;
-    Heading1: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<ITransientTextAspectProps, any>>;
-    Heading2: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<ITransientTextAspectProps, any>>;
-    Heading3: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<ITransientTextAspectProps, any>>;
-    Heading4: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<ITransientTextAspectProps, any>>;
-    Body: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<IBodyProps, any>>;
-    BodyLarge: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<IBodyProps, any>>;
-    Caption: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<ITransientTextAspectProps, any>>;
-    Label: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<ILabelProps, any>>;
-};
-export declare const _Typography: {
-    LightText: import("styled-components").FlattenSimpleInterpolation;
-};
+import { ITransientTextAspectProps } from './text-aspect-flags';
+export type ILabelProps = ITransientTextAspectProps & {
+    default?: boolean;
+    subtle?: boolean;
+    strong?: boolean;
+};
+export type IBodyProps = ITransientTextAspectProps & {
+    default?: boolean;
+    strong?: boolean;
+};
+export declare const Typography: {
+    Display: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<ITransientTextAspectProps, any>>;
+    Heading1: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<ITransientTextAspectProps, any>>;
+    Heading2: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<ITransientTextAspectProps, any>>;
+    Heading3: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<ITransientTextAspectProps, any>>;
+    Heading4: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<ITransientTextAspectProps, any>>;
+    Body: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<IBodyProps, any>>;
+    BodyLarge: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<IBodyProps, any>>;
+    Caption: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<ITransientTextAspectProps, any>>;
+    Label: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<ILabelProps, any>>;
+};
+export declare const _Typography: {
+    LightText: import("styled-components").FlattenSimpleInterpolation;
+};

package/lib/helpers/generic-types.d.ts

@@ -1,21 +1,21 @@
-import { FC as FunctionComponent, ForwardRefExoticComponent, ForwardRefRenderFunction, PropsWithChildren as PWC, PropsWithoutRef, RefAttributes } from 'react';
-import { Slot } from './slots';
-/** @see https://stackoverflow.com/a/49725198/29182 */
-export declare type RequireOnlyOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
-    [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
-}[Keys];
-export declare type MappedEnum<E, T> = {
-    [key in keyof E]: T;
-};
-export declare type Values<T> = T[keyof T];
-export declare type PropsWithChildren<T = unknown> = PWC<T>;
-export declare type FC<P = {}, E extends {
-    [x: symbol]: FunctionComponent<PropsWithChildren> | typeof Slot;
-} = {}> = FunctionComponent<P> & {
-    [key in keyof E]: E[key];
-};
-declare type ExtensibleForwardRef<T, P = {}, E = {}> = ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>> & {
-    [key in keyof E]: E[key];
-};
-export declare function forwardRef<T, P = {}, E = {}>(render: ForwardRefRenderFunction<T, P>): ExtensibleForwardRef<T, P, E>;
-export {};
+import { FC as FunctionComponent, ForwardRefExoticComponent, ForwardRefRenderFunction, PropsWithChildren as PWC, PropsWithoutRef, RefAttributes } from 'react';
+import { Slot } from './slots';
+/** @see https://stackoverflow.com/a/49725198/29182 */
+export type RequireOnlyOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
+}[Keys];
+export type MappedEnum<E, T> = {
+    [key in keyof E]: T;
+};
+export type Values<T> = T[keyof T];
+export type PropsWithChildren<T = unknown> = PWC<T>;
+export type FC<P = {}, E extends {
+    [x: symbol]: FunctionComponent<PropsWithChildren> | typeof Slot;
+} = {}> = FunctionComponent<P> & {
+    [key in keyof E]: E[key];
+};
+type ExtensibleForwardRef<T, P = {}, E = {}> = ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>> & {
+    [key in keyof E]: E[key];
+};
+export declare function forwardRef<T, P = {}, E = {}>(render: ForwardRefRenderFunction<T, P>): ExtensibleForwardRef<T, P, E>;
+export {};

package/lib/helpers/index.d.ts

@@ -1,10 +1,10 @@
-export * from './safe-navigation';
-export * from './slots';
-export * from './generic-types';
-export * from './numbers';
-export * from './nothing';
-export * from './strings';
-export * from './isReactElementOfType';
-export * from './useInputElementState';
-export * from './useIsMobile';
-export * from './useClickOutside';
+export * from './safe-navigation';
+export * from './slots';
+export * from './generic-types';
+export * from './numbers';
+export * from './nothing';
+export * from './strings';
+export * from './isReactElementOfType';
+export * from './useInputElementState';
+export * from './useIsMobile';
+export * from './useClickOutside';

package/lib/helpers/isReactElementOfType.d.ts

@@ -1,8 +1,6 @@
-import { PureComponent, ReactElement } from 'react';
-import { StyledComponent } from 'styled-components';
-import { FC } from './generic-types';
-export declare const isReactElementOfType: <P extends {
-    children?: import("react").ReactNode;
-}>(component: (FC<P, {}> | typeof PureComponent | StyledComponent<FC<P, {}>, any, {}, never>) & {
-    target?: any;
-}) => (element?: any) => element is ReactElement<P, string | import("react").JSXElementConstructor<any>>;
+import { PureComponent, ReactElement } from 'react';
+import { StyledComponent } from 'styled-components';
+import { FC, PropsWithChildren } from './generic-types';
+export declare const isReactElementOfType: <P extends PropsWithChildren>(component: (StyledComponent<FC<P>, any> | FC<P> | typeof PureComponent) & {
+    target?: any;
+}) => (element?: any) => element is ReactElement<P>;

package/lib/helpers/nothing.d.ts

@@ -1,10 +1,9 @@
-/// <reference types="react" />
-import { FC, PropsWithChildren } from './generic-types';
-export declare const Nothing: FC;
-export declare const isNothing: (element?: any) => element is import("react").ReactElement<{}, string | import("react").JSXElementConstructor<any>>;
-export declare function maybeRender<T>(prop: T, JSX: JSX.Element): JSX.Element;
-interface IIfProps {
-    is: unknown;
-}
-export declare const If: FC<PropsWithChildren<IIfProps>>;
-export {};
+import { FC, PropsWithChildren } from './generic-types';
+export declare const Nothing: FC;
+export declare const isNothing: (element?: any) => element is import("react").ReactElement<{}, string | import("react").JSXElementConstructor<any>>;
+export declare function maybeRender<T>(prop: T, JSX: JSX.Element): JSX.Element;
+interface IIfProps {
+    is: unknown;
+}
+export declare const If: FC<PropsWithChildren<IIfProps>>;
+export {};

package/lib/helpers/numbers.d.ts

@@ -1,51 +1,51 @@
-export declare type Hex = `#${string}`;
-export declare function clamp(a: number, b: number, c: number): number;
-export declare function toHex(n: number, length: number): Hex;
-export declare function concatHex(a: Hex, b: Hex): Hex;
-/** given an array of boolean flags, bitwiseOr interprets them as an unsigned integer
- *
- * ```ts
- * bitwiseOr([false, true, false, true]) => 5 // 0b0101
- * ```
- *
- * This is useful for indexing into an enum:
- *
- * ```ts
- * const enum Level {
- *   default = 0,
- *   info = 0,
- *   danger = 1,
- *   warning = 2
- * }
- *
- * interface IProps {
- *  info?: boolean
- *  danger?: boolean
- *  warning?: boolean
- * }
- *
- * function toLevel(n: number): Level {
- *   switch (n) {
- *     case Level.info: return Level.info
- *     case Level.danger: return Level.danger
- *     case Level.warning: return Level.warning
- *     default: return Level.default
- *   }
- * }
- *
- * const level = bitwiseOr([props.info, props.danger, props.warning])
- *
- * const levelEnum = toLevel(level)
- * ```
-*/
-export declare function bitwiseOr(flags: unknown[]): number;
-/** given a number, it returns the number formed by the rightmost set bit as 1 and the 0s that comes after it
- *
- * ```ts
- * getRightmostSetBitNumber(12) => 4 // 12(1100) => 4(100)
- * getRightmostSetBitNumber(40) => 8 // 40(101000) => 8(1000)
- * ```
- *
- * */
-export declare function getRightmostSetBitNumber(n: number): number;
-export declare function getNumberBetweenMinMax(input: number, min: number, max: number): number;
+export type Hex = `#${string}`;
+export declare function clamp(a: number, b: number, c: number): number;
+export declare function toHex(n: number, length: number): Hex;
+export declare function concatHex(a: Hex, b: Hex): Hex;
+/** given an array of boolean flags, bitwiseOr interprets them as an unsigned integer
+ *
+ * ```ts
+ * bitwiseOr([false, true, false, true]) => 5 // 0b0101
+ * ```
+ *
+ * This is useful for indexing into an enum:
+ *
+ * ```ts
+ * const enum Level {
+ *   default = 0,
+ *   info = 0,
+ *   danger = 1,
+ *   warning = 2
+ * }
+ *
+ * interface IProps {
+ *  info?: boolean
+ *  danger?: boolean
+ *  warning?: boolean
+ * }
+ *
+ * function toLevel(n: number): Level {
+ *   switch (n) {
+ *     case Level.info: return Level.info
+ *     case Level.danger: return Level.danger
+ *     case Level.warning: return Level.warning
+ *     default: return Level.default
+ *   }
+ * }
+ *
+ * const level = bitwiseOr([props.info, props.danger, props.warning])
+ *
+ * const levelEnum = toLevel(level)
+ * ```
+*/
+export declare function bitwiseOr(flags: unknown[]): number;
+/** given a number, it returns the number formed by the rightmost set bit as 1 and the 0s that comes after it
+ *
+ * ```ts
+ * getRightmostSetBitNumber(12) => 4 // 12(1100) => 4(100)
+ * getRightmostSetBitNumber(40) => 8 // 40(101000) => 8(1000)
+ * ```
+ *
+ * */
+export declare function getRightmostSetBitNumber(n: number): number;
+export declare function getNumberBetweenMinMax(input: number, min: number, max: number): number;

package/lib/helpers/safe-navigation.d.ts

@@ -1,26 +1,26 @@
-import first from 'lodash/first.js';
-import isString from 'lodash/isString.js';
-import isFunction from 'lodash/isFunction.js';
-import uniqueId from 'lodash/uniqueId.js';
-import debounce from 'lodash/debounce.js';
-import isObject from 'lodash/isObject';
-export { first, isString, isFunction, uniqueId, debounce, isObject };
-/** even though we have null disabled in the repo,
- * I still would not want isNil to skip checking null
- * it is for juuuuust in case a third party sends us a null
- * or something, and the types are not correct
- */
-export declare function isNil<T>(value: T | undefined | null): value is undefined | null;
-export declare function isDefined<T>(value: T | undefined | null): value is T;
-export declare function defaultTo<T>(value: T | undefined | null, fallback: T): T;
-export declare function isEmpty<T extends {
-    length: number;
-}>(obj: T): boolean;
-export declare function isNilOrEmpty<T extends {
-    length: number;
-}>(obj?: T): boolean;
-/** used for evaluating tri-state logic (true | false | undefined) */
-export declare function is(pred?: boolean): boolean;
-export declare function toArray<T>(obj: T | T[] | undefined | null): T[];
-export declare function safeArray<T>(arr: T[] | undefined | null): T[];
-export declare function safeCallback<T>(f?: (e: T) => void, e?: T): void;
+import first from 'lodash/first.js';
+import isString from 'lodash/isString.js';
+import isFunction from 'lodash/isFunction.js';
+import uniqueId from 'lodash/uniqueId.js';
+import debounce from 'lodash/debounce.js';
+import isObject from 'lodash/isObject';
+export { first, isString, isFunction, uniqueId, debounce, isObject };
+/** even though we have null disabled in the repo,
+ * I still would not want isNil to skip checking null
+ * it is for juuuuust in case a third party sends us a null
+ * or something, and the types are not correct
+ */
+export declare function isNil<T>(value: T | undefined | null): value is undefined | null;
+export declare function isDefined<T>(value: T | undefined | null): value is T;
+export declare function defaultTo<T>(value: T | undefined | null, fallback: T): T;
+export declare function isEmpty<T extends {
+    length: number;
+}>(obj: T): boolean;
+export declare function isNilOrEmpty<T extends {
+    length: number;
+}>(obj?: T): boolean;
+/** used for evaluating tri-state logic (true | false | undefined) */
+export declare function is(pred?: boolean): boolean;
+export declare function toArray<T>(obj: T | T[] | undefined | null): T[];
+export declare function safeArray<T>(arr: T[] | undefined | null): T[];
+export declare function safeCallback<T>(f?: (e: T) => void, e?: T): void;

package/lib/helpers/slots.d.ts

@@ -1,17 +1,17 @@
-import { CSSProperties, PureComponent, ReactElement, ReactNode } from 'react';
-import { FC, PropsWithChildren } from './generic-types';
-export declare const isSlotOfType: <T extends typeof Slot>(type: T | FC<{}, {}>) => (obj?: any) => obj is T;
-export declare class Slot<T = unknown> extends PureComponent<PropsWithChildren<T>> {
-    render(): PropsWithChildren<T>["children"] | undefined;
-}
-export declare class StylableSlot extends Slot {
-    render(): JSX.Element;
-}
-/** gets children that are _not_ slots */
-export declare function getOtherChildren(children?: ReactNode): ReactNode[];
-export declare function getSlots<T extends typeof Slot>(slot: T, children?: ReactNode): ReactElement[];
-export declare function getSlot<T extends typeof Slot>(slot: T, children?: ReactNode): ReactElement;
-/** given a ReactElement, like a child, apply the given props to it */
-export declare function applyProps<T>(element: ReactElement<T>, props: Partial<T>): ReactElement;
-/** given a ReactElement, like a child, apply the given styles to it, merging with the existing styles */
-export declare function applyStyle(element: ReactElement, style: CSSProperties): ReactElement;
+import { CSSProperties, PureComponent, ReactElement, ReactNode } from 'react';
+import { FC, PropsWithChildren } from './generic-types';
+export declare const isSlotOfType: <T extends typeof Slot>(type: T | FC) => (obj?: any) => obj is T;
+export declare class Slot<T = unknown> extends PureComponent<PropsWithChildren<T>> {
+    render(): PropsWithChildren<T>["children"] | undefined;
+}
+export declare class StylableSlot extends Slot {
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+/** gets children that are _not_ slots */
+export declare function getOtherChildren(children?: ReactNode): ReactNode[];
+export declare function getSlots<T extends typeof Slot>(slot: T, children?: ReactNode): ReactElement[];
+export declare function getSlot<T extends typeof Slot>(slot: T, children?: ReactNode): ReactElement;
+/** given a ReactElement, like a child, apply the given props to it */
+export declare function applyProps<T>(element: ReactElement<T>, props: Partial<T>): ReactElement;
+/** given a ReactElement, like a child, apply the given styles to it, merging with the existing styles */
+export declare function applyStyle(element: ReactElement, style: CSSProperties): ReactElement;

package/lib/helpers/strings.d.ts

@@ -1 +1 @@
-export declare const toKebabCase: (str: string) => string;
+export declare const toKebabCase: (str: string) => string;

package/lib/helpers/useClickOutside.d.ts

@@ -1,2 +1,2 @@
-import * as React from 'react';
-export declare function useOnClickOutside(handler: (event: Event) => void): React.RefObject<HTMLDivElement>;
+import * as React from 'react';
+export declare function useOnClickOutside(handler: (event: Event) => void): React.RefObject<HTMLDivElement>;

package/lib/helpers/useInputElementState.d.ts

@@ -1,30 +1,30 @@
-declare type IInputElementState<T> = [
-    T | undefined,
-    (change: T) => void
-];
-/**
- *
- * This hook is to help implement a common pattern:
- *
- * <input onChange={doSomething} /> // uncontrolled
- * <input value={1} /> // should be marked read only
- * <input value={state} onChange={setState} /> // controlled
- *
- * I've reimplemented this logic a few times, but now I have a nice helper :D
- *
- * const [state, setState] = useInputElementState({
- *   value: props.value,
- *   defaultValue: props.defaultValue, // the value to use if value is undefined
- *   onChange: props.onChange,
- * })
- *
- * if you give it nothing, you get state, setState for internal state management (uncontrolled input)
- * if you give it value only, you get a warning
- * if you give it value and onChange, state management if deferred to the parent (controlled input)
- */
-export declare function useInputElementState<T>(props: {
-    value?: T;
-    defaultValue?: T;
-    onChange?: (change: T) => void;
-}): IInputElementState<T>;
-export {};
+type IInputElementState<T> = [
+    T | undefined,
+    (change: T) => void
+];
+/**
+ *
+ * This hook is to help implement a common pattern:
+ *
+ * <input onChange={doSomething} /> // uncontrolled
+ * <input value={1} /> // should be marked read only
+ * <input value={state} onChange={setState} /> // controlled
+ *
+ * I've reimplemented this logic a few times, but now I have a nice helper :D
+ *
+ * const [state, setState] = useInputElementState({
+ *   value: props.value,
+ *   defaultValue: props.defaultValue, // the value to use if value is undefined
+ *   onChange: props.onChange,
+ * })
+ *
+ * if you give it nothing, you get state, setState for internal state management (uncontrolled input)
+ * if you give it value only, you get a warning
+ * if you give it value and onChange, state management if deferred to the parent (controlled input)
+ */
+export declare function useInputElementState<T>(props: {
+    value?: T;
+    defaultValue?: T;
+    onChange?: (change: T) => void;
+}): IInputElementState<T>;
+export {};

package/lib/helpers/useIsMobile.d.ts

@@ -1 +1 @@
-export declare const useIsMobile: () => boolean;
+export declare const useIsMobile: () => boolean;

package/lib/helpers/useKeyDown.d.ts

@@ -1 +1 @@
-export declare function useKeyDown(targetKey: string, handler: () => void): void;
+export declare function useKeyDown(targetKey: string, handler: () => void): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edvisor/product-language",
-  "version": "0.11.112",
+  "version": "0.11.113",
   "license": "MIT",
   "description": "Edvisor.io product-language components",
   "repository": "https://github.com/edvisor-io/front-end/",
@@ -41,13 +41,13 @@
   },
   "release-it": {
     "git": {
+      "changelog": "git log --pretty=format:'* %s (%h)' ${latestTag}...HEAD -- .",
       "requireCleanWorkingDir": false,
-      "commitMessage": "chore: release ${version}  [skip ci]",
-      "tagName": "v${version}"
+      "commitMessage": "chore: release frontend-v${version} [skip ci]",
+      "tagName": "frontend-v${version}"
     },
     "github": {
-      "release": true,
-      "tokenRef": "BOB"
+      "release": true
     },
     "npm": {
       "publish": false,