@onepercentio/one-ui 0.29.2 → 0.29.5

package/src/type-utils.ts

@@ -1,49 +0,0 @@
-type FieldValues = any;
-type NestedValue = any;
-export declare type Primitive = null | undefined | string | number | boolean | symbol | bigint;
-export declare type EmptyObject = {
-    [K in string | number]: never;
-};
-export declare type NonUndefined<T> = T extends undefined ? never : T;
-export declare type LiteralUnion<T extends U, U extends Primitive> = T | (U & {
-    _?: never;
-});
-export declare type DeepPartial<T> = T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
-    [key in keyof T]: T[key];
-} ? {
-    [K in keyof T]?: DeepPartial<T[K]>;
-} : T;
-export declare type IsAny<T> = boolean extends (T extends never ? true : false) ? true : false;
-export declare type DeepMap<T, TValue> = {
-    [K in keyof T]?: IsAny<T[K]> extends true ? any : NonNullable<T[K]> extends NestedValue | Date | FileList | File ? TValue : NonUndefined<T[K]> extends object | null ? DeepMap<T[K], TValue> : NonUndefined<T[K]> extends Array<infer U> ? IsAny<U> extends true ? Array<any> : U extends NestedValue | Date | FileList ? Array<TValue> : U extends object ? Array<DeepMap<U, TValue>> : Array<TValue> : TValue;
-};
-export declare type IsFlatObject<T extends object> = Extract<Exclude<T[keyof T], NestedValue | Date | FileList>, any[] | object> extends never ? true : false;
-declare type IsTuple<T extends ReadonlyArray<any>> = number extends T['length'] ? false : true;
-declare type TupleKey<T extends ReadonlyArray<any>> = Exclude<keyof T, keyof any[]>;
-declare type ArrayKey = number;
-declare type PathImpl<K extends string | number, V> = V extends Primitive ? `${K}` : `${K}` | `${K}.${Path<V>}`;
-export declare type Path<T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
-    [K in TupleKey<T>]-?: PathImpl<K & string, T[K]>;
-}[TupleKey<T>] : PathImpl<ArrayKey, V> : {
-    [K in keyof T]-?: PathImpl<K & string, T[K]>;
-}[keyof T];
-export declare type FieldPath<TFieldValues extends FieldValues> = Path<TFieldValues>;
-declare type ArrayPathImpl<K extends string | number, V> = V extends Primitive ? never : V extends ReadonlyArray<infer U> ? U extends Primitive ? never : `${K}` | `${K}.${ArrayPath<V>}` : `${K}.${ArrayPath<V>}`;
-export declare type ArrayPath<T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
-    [K in TupleKey<T>]-?: ArrayPathImpl<K & string, T[K]>;
-}[TupleKey<T>] : ArrayPathImpl<ArrayKey, V> : {
-    [K in keyof T]-?: ArrayPathImpl<K & string, T[K]>;
-}[keyof T];
-export declare type FieldArrayPath<TFieldValues extends FieldValues> = ArrayPath<TFieldValues>;
-export declare type PathValue<T, P extends Path<T> | ArrayPath<T>> = P extends `${infer K}.${infer R}` ? K extends keyof T ? R extends Path<T[K]> ? PathValue<T[K], R> : never : K extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? PathValue<V, R & Path<V>> : never : never : P extends keyof T ? T[P] : P extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? V : never : never;
-export declare type FieldPathValue<TFieldValues extends FieldValues, TFieldPath extends FieldPath<TFieldValues>> = PathValue<TFieldValues, TFieldPath>;
-export declare type FieldArrayPathValue<TFieldValues extends FieldValues, TFieldArrayPath extends FieldArrayPath<TFieldValues>> = PathValue<TFieldValues, TFieldArrayPath>;
-export declare type FieldPathValues<TFieldValues extends FieldValues, TPath extends FieldPath<TFieldValues>[] | readonly FieldPath<TFieldValues>[]> = {} & {
-    [K in keyof TPath]: FieldPathValue<TFieldValues, TPath[K] & FieldPath<TFieldValues>>;
-};
-/**
- * Returns the type U when this type is resolved
- * Or the fallback type F when type is no resolved
- */
-export declare type UnresolvableOr<U, F> = keyof U extends U ? F : U
-export {};

package/src/types.ts

@@ -1,199 +0,0 @@
-type PrependNextNum<A extends Array<unknown>> = A["length"] extends infer T
-  ? ((t: T, ...a: A) => void) extends (...x: infer X) => void
-    ? X
-    : never
-  : never;
-
-type EnumerateInternal<A extends Array<unknown>, N extends number> = {
-  0: A;
-  1: EnumerateInternal<PrependNextNum<A>, N>;
-}[N extends A["length"] ? 0 : 1];
-
-export type Enumerate<N extends number> = EnumerateInternal<
-  [],
-  N
-> extends (infer E)[]
-  ? E
-  : never;
-
-export type Range<FROM extends number, TO extends number> = Exclude<
-  Enumerate<TO>,
-  Enumerate<FROM>
->;
-
-export type CommonErrorCodes = "UNEXPECTED_ERROR";
-
-type Decompose<O extends object> = O;
-
-export type BasicContext<T extends object> = {
-  set: <P extends keyof T>(p: P, value: T[typeof p]) => void;
-} & T;
-
-/**
- * This is usefull for omitting props from union
- * Check whz contestation model to see an example
- *
- * If different models with different properties use the native Omit<O>
- * Their differences are also omitted generating a single model
- *
- * This typing solves that
- */
-export type DistributiveOmit<T, K extends keyof any> = T extends any
-  ? Omit<T, K>
-  : never;
-
-declare global {
-  interface Window {
-    ethereum: import("@metamask/providers").MetaMaskInpageProvider | undefined;
-    PRERENDER: boolean;
-    Cypress: any;
-  }
-}
-type NestedValue = unknown;
-type FieldValues = unknown;
-
-export declare type Primitive =
-  | null
-  | undefined
-  | string
-  | number
-  | boolean
-  | symbol
-  | bigint;
-export declare type EmptyObject = {
-  [K in string | number]: never;
-};
-export declare type NonUndefined<T> = T extends undefined ? never : T;
-export declare type LiteralUnion<T extends U, U extends Primitive> =
-  | T
-  | (U & {
-      _?: never;
-    });
-export declare type DeepPartial<T> = T extends Array<infer U>
-  ? Array<DeepPartial<U>>
-  : T extends ReadonlyArray<infer U>
-  ? ReadonlyArray<DeepPartial<U>>
-  : T extends {
-      [key in keyof T]: T[key];
-    }
-  ? {
-      [K in keyof T]?: DeepPartial<T[K]>;
-    }
-  : T;
-export declare type IsAny<T> = boolean extends (T extends never ? true : false)
-  ? true
-  : false;
-export declare type DeepMap<T, TValue> = {
-  [K in keyof T]?: IsAny<T[K]> extends true
-    ? any
-    : NonNullable<T[K]> extends NestedValue | Date | FileList | File
-    ? TValue
-    : NonUndefined<T[K]> extends object | null
-    ? DeepMap<T[K], TValue>
-    : NonUndefined<T[K]> extends Array<infer U>
-    ? IsAny<U> extends true
-      ? Array<any>
-      : U extends NestedValue | Date | FileList
-      ? Array<TValue>
-      : U extends object
-      ? Array<DeepMap<U, TValue>>
-      : Array<TValue>
-    : TValue;
-};
-export declare type IsFlatObject<T extends object> = Extract<
-  Exclude<T[keyof T], NestedValue | Date | FileList>,
-  any[] | object
-> extends never
-  ? true
-  : false;
-declare type IsTuple<T extends ReadonlyArray<any>> = number extends T["length"]
-  ? false
-  : true;
-declare type TupleKey<T extends ReadonlyArray<any>> = Exclude<
-  keyof T,
-  keyof any[]
->;
-declare type ArrayKey = number;
-declare type PathImpl<K extends string | number, V> = V extends Primitive
-  ? `${K}`
-  : `${K}.${Path<V>}`;
-export declare type Path<T> = T extends ReadonlyArray<infer V>
-  ? IsTuple<T> extends true
-    ? {
-        [K in TupleKey<T>]-?: PathImpl<K & string, T[K]>;
-      }[TupleKey<T>]
-    : PathImpl<ArrayKey, V>
-  : {
-      [K in keyof T]-?: PathImpl<K & string, T[K]>;
-    }[keyof T];
-export declare type FieldPath<TFieldValues extends FieldValues> =
-  Path<TFieldValues>;
-declare type ArrayPathImpl<K extends string | number, V> = V extends Primitive
-  ? never
-  : V extends ReadonlyArray<infer U>
-  ? U extends Primitive
-    ? never
-    : `${K}` | `${K}.${ArrayPath<V>}`
-  : `${K}.${ArrayPath<V>}`;
-export declare type ArrayPath<T> = T extends ReadonlyArray<infer V>
-  ? IsTuple<T> extends true
-    ? {
-        [K in TupleKey<T>]-?: ArrayPathImpl<K & string, T[K]>;
-      }[TupleKey<T>]
-    : ArrayPathImpl<ArrayKey, V>
-  : {
-      [K in keyof T]-?: ArrayPathImpl<K & string, T[K]>;
-    }[keyof T];
-export declare type FieldArrayPath<TFieldValues extends FieldValues> =
-  ArrayPath<TFieldValues>;
-export declare type PathValue<T, P extends Path<T> | ArrayPath<T>> =
-  P extends `${infer K}.${infer R}`
-    ? K extends keyof T
-      ? R extends Path<T[K]>
-        ? PathValue<T[K], R>
-        : never
-      : K extends `${ArrayKey}`
-      ? T extends ReadonlyArray<infer V>
-        ? PathValue<V, R & Path<V>>
-        : never
-      : never
-    : P extends keyof T
-    ? T[P]
-    : P extends `${ArrayKey}`
-    ? T extends ReadonlyArray<infer V>
-      ? V
-      : never
-    : never;
-export declare type FieldPathValue<
-  TFieldValues extends FieldValues,
-  TFieldPath extends FieldPath<TFieldValues>
-> = PathValue<TFieldValues, TFieldPath>;
-export declare type FieldArrayPathValue<
-  TFieldValues extends FieldValues,
-  TFieldArrayPath extends FieldArrayPath<TFieldValues>
-> = PathValue<TFieldValues, TFieldArrayPath>;
-export declare type FieldPathValues<
-  TFieldValues extends FieldValues,
-  TPath extends FieldPath<TFieldValues>[] | readonly FieldPath<TFieldValues>[]
-> = {} & {
-  [K in keyof TPath]: FieldPathValue<
-    TFieldValues,
-    TPath[K] & FieldPath<TFieldValues>
-  >;
-};
-
-export type ToFirebaseType<B> = {
-  [k in keyof B]: B[k] extends Date
-    ? import("firebase/firestore").Timestamp
-    : B[k] extends Object
-    ? ToFirebaseType<B[k]>
-    : B[k];
-};
-
-export type FromFirebaseType<B> = {
-  [k in keyof B]: B[k] extends import("firebase/firestore").Timestamp
-    ? Date
-    : B[k] extends Object
-    ? FromFirebaseType<B[k]>
-    : B[k];
-};

package/src/utility.d.ts

@@ -1,70 +0,0 @@
-/**
- * These are typings made to support separated function and prevent excessive Generics usage accross the application
- *
- * Redeclare this namespace with the usefull typings for your project and enjoy intelisense :)
- */
-namespace OnepercentUtility {
-  /** The ids used by the useShortIntl hooks */
-  type IntlIds = "generic.id";
-  /** A type hint to bind the LinkToId action and the SectionContainer identifier */
-  type PageSections = "example-section-1";
-  /** A type hint to autocomplete functions related to the AsyncProcess context */
-  namespace AsyncQueue {
-    /** These are the recovery types available */
-    type RecoveryTypes = {
-      [R: string]: any[];
-    };
-
-    /** These are the available UI models */
-    type Processes = {
-      [k in "waitForBuild"]: [thash: string];
-    };
-  }
-  /** These are the extensible properties for the UI elements */
-  namespace UIElements {
-    type AdaptiveDialogVariants = "default";
-    type ButtonVariants = "transparent" | "filled" | "outline" | "link";
-    type TextVariants =
-      | "title"
-      | "description"
-      | "error"
-      | "caption"
-      | "highlightTitle"
-      | "highlight"
-      | "subtitle"
-      | "boldTitle"
-      | "link"
-      | "boldTitleBig"
-      | "content";
-    type SpacingVariants = "large" | "small";
-    type TextColors = "primary" | "error" | undefined;
-    type FormExtension = {
-      fields:
-        | {
-            type: "phone";
-            country: string;
-          }
-        | {
-            type: "date";
-          };
-      fieldAnswer: {
-        phone: [
-          phoneNumber: string,
-          isValid: boolean,
-          error: string | undefined
-        ];
-        date: string
-      };
-    };
-  }
-}
-declare module "use-wallet" {
-  import * as UseWallet from "use-wallet";
-  export const useWallet: typeof UseWallet["use-wallet"];
-  export const UseWalletProvider: typeof UseWallet["UseWalletProvider"];
-}
-
-declare module "*.mp4" {
-  const v: string;
-  export default v;
-}

package/src/utils/blockchain.ts

@@ -1,43 +0,0 @@
-import { PromiEvent } from 'web3-core'
-
-export async function isTransactionMined(transactionHash: string, provider: any) {
-    const transaction = await provider.eth.getTransactionReceipt(transactionHash)
-
-    if (
-        !transaction ||
-        !transaction.blockHash ||
-        transaction.status === undefined
-    )
-        return undefined // I still don't know if it's loaded
-    else return !!transaction.status === true
-}
-
-export async function waitForConfirmation(tHash: string, provider: any) {
-    return new Promise<void>(async (r, rej) => {
-        while (true) {
-            const bought = await isTransactionMined(tHash, provider)
-            if (bought === undefined)
-                await new Promise<void>((r) => setTimeout(() => r(), 2000))
-            else {
-                if (bought) r()
-                else rej('TRANSACTION_FAILED')
-                break
-            }
-        }
-    })
-}
-
-export function dispatchAndWait(func: any) {
-    const _func = func as PromiEvent<any>
-    return new Promise<string>((r, rej) => {
-        _func.on('transactionHash', (tX) => {
-            r(tX)
-        })
-        _func.catch(rej)
-    })
-}
-
-export async function sendAndWaitForConfirmation(func: Promise<void>, provider: any) {
-    const tHash = await dispatchAndWait(func)
-    await waitForConfirmation(tHash, provider)
-}

package/src/utils/e2e.ts

@@ -1,55 +0,0 @@
-import Module from "module";
-
-function toSrcPath(str: string) {
-  const indexOfSrc = str.indexOf("src");
-  const modName = indexOfSrc === -1 ? str : str.slice(indexOfSrc);
-  return modName.replace("appclientecmascript", "");
-}
-
-/** Try to make the string follow the snake case pattern (e.g. "SOME_ELEMENT") */
-type IDENTIFIER = string
-
-type PossibleT = (
-  | IDENTIFIER 
-  | readonly [id: IDENTIFIER, func: (n: number) => `${string}-${number}`]
-)[];
-
-type T<IDS extends PossibleT> = {
-  [I in IDS[number] extends string
-    ? IDS[number]
-    : IDS[number][0]]: I extends IDS[number] ? string : (id: any) => string;
-};
-
-export function combineTestIds(...t: ReturnType<typeof testIDFactory>[]) {
-  return t.reduce((acc, i) => ({ ...acc, i }), {});
-}
-
-/**
- * Creates an data-testid map generator instance based on the module name or arbitrary id
- * @returns A function to set the IDs that this created instance will provide
- */
-export function testIDFactory(moduleOrId: Pick<Module, "id"> | string) {
-  const moduleId = typeof moduleOrId === "string" ? moduleOrId : moduleOrId.id;
-  return <const IDS extends PossibleT>(idsArr: IDS) =>
-    [idsArr].reduce(
-      (acc, ids) => ({
-        ...acc,
-        ...ids.reduce(
-          (map, id) => ({
-            ...map,
-            [typeof id === "string" ? id : id[0]]:
-              typeof id === "string"
-                ? `${toSrcPath(
-                    moduleId.toLowerCase().replace(/[^a-z]/g, "")
-                  )}-${id}`
-                : (i: any) =>
-                    `${toSrcPath(
-                      moduleId.toLowerCase().replace(/[^a-z]/g, "")
-                    )}-${id[1](i)}`,
-          }),
-          {} as T<IDS>
-        ),
-      }),
-      {} as T<IDS>
-    );
-}

package/src/utils/flatten.ts

@@ -1,17 +0,0 @@
-import { FieldPath } from "../types";
-
-export function flatten<T extends object>(obj: T): { [k in FieldPath<T>]: string } {
-    return Object.assign(
-        {},
-        ...(function _flatten(o, prevKey: string = ""): any {
-            return [].concat(
-                ...Object.keys(o).map((_k) => {
-                    const k = _k as keyof typeof o;
-                    return typeof o[k] === "object"
-                        ? _flatten(o[k] as any, prevKey ? `${prevKey}.${k as string}` : (k as string))
-                        : { [prevKey ? `${prevKey}.${k as string}` : k]: o[k] };
-                })
-            );
-        })(obj)
-    );
-}

package/src/utils/formatters.ts

@@ -1,36 +0,0 @@
-/**
- * A formatter to format to double decimal
- */
-export const currencyNumberFormatter = new Intl.NumberFormat("pt-BR", {
-  minimumFractionDigits: 2,
-  maximumFractionDigits: 2,
-}).format;
-
-/**
- * Instanciate a currency formatter
- */
-export const currencyFormatterFactory = (
-  langCode: string,
-  currency?: string
-) => {
-  try {
-    return new Intl.NumberFormat(langCode, {
-      style: "currency",
-      currency: currency,
-    });
-  } catch (e) {
-    const f = new Intl.NumberFormat(langCode, {
-      minimumFractionDigits: 2,
-      maximumFractionDigits: 2,
-    });
-
-    return {
-      format: (num: number) => `${currency} ${currencyNumberFormatter(num)}`,
-      formatToParts: (num: number) => [
-        { type: "currency", value: currency },
-        { type: "literal", value: " " },
-        ...f.formatToParts(num),
-      ],
-    };
-  }
-};

package/src/utils/html.utils.ts

@@ -1,3 +0,0 @@
-export function isSameTarget({ target, currentTarget }: Event) {
-  return target === currentTarget;
-}

package/src/utils/ownEvent.ts

@@ -1,8 +0,0 @@
-/**
- * Allows invoking a callback, only when the event is ocurring on the same elemnt
- */
-export default function ownEvent<E extends Event>(cb: (e: E) => void) {
-  return (e: E) => {
-    if (e.currentTarget === e.target) cb(e);
-  };
-}

package/src/utils/test.ts

@@ -1,20 +0,0 @@
-type Func = (...args: any[]) => string
-
-/** @deprecated Preffer ./e2e.ts's test ids generator  */
-export const preffixTestIds =
-  (preffix: string) =>
-  <
-    const M extends {
-      [k: string]: string | Func
-    }
-  >(
-    testIds: M
-  ) => {
-    for (let key in testIds)
-      if (typeof testIds[key] === 'function') {
-        const originalFunction = testIds[key] as Func
-        testIds[key] = ((...args: any[]) =>
-          `${preffix}-${originalFunction(...args)}`) as any
-      } else testIds[key] = `${preffix}-${testIds[key]}` as any
-    return testIds
-  }