@onepercentio/one-ui 0.28.8 → 0.28.9

package/src/models/GenericContract.ts

@@ -0,0 +1,169 @@
+// @ts-nocheck
+import {
+  Contract,
+  ContractOptions,
+  EventData,
+  PastEventOptions,
+} from "web3-eth-contract";
+import { AbiItem } from "web3-utils";
+
+export type AllABIs = readonly any[];
+
+type ExtractMethods<A extends AllABIs[number]> = A extends {
+  type: "function";
+}
+  ? A["name"]
+  : never;
+
+type ExtractEvents<A extends AllABIs[number]> = A extends {
+  type: "event";
+}
+  ? A["name"]
+  : never;
+
+type TypeOrInternalType<T> = T['internalType'] extends unknown ? T['type'] : T['internalType']
+
+export type MapTypeToJS<L, C> =
+  L extends "tuple[]" ? TuplifyUnion<C[number], C[number]['name']>[] :
+  L extends "address" | "uint256" | "uint128" | "uint8" | "string" | "bytes32" | "uint64"
+  ? string
+  : L extends "uint256[]" | "string[]"
+  ? string[]
+  : L extends "bool"
+  ? boolean
+  : L extends 'tuple'
+  ? TuplifyUnion<C[number], C[number]['name']>
+  : unknown;
+
+type ExtractFromObj<R extends (AllABIs[number] & { type: "function" })> = {
+  [K in R["outputs"][number]["name"]]: MapTypeToJS<
+    TypeOrInternalType<(R["outputs"][number] & {
+      name: K;
+    })>,
+    (R["outputs"][number] & {
+      name: K;
+    })["components"]
+  >;
+}
+
+export type ExtractMethodDefinition<
+  A extends AllABIs,
+  N extends (AllABIs[number] & { type: "function" })["name"],
+  R = A[number] & {
+    type: "function";
+    name: N;
+  }
+  > = (
+    ...args: TuplifyUnion<
+      (A[number] & {
+        type: "function";
+        name: N;
+      })["inputs"][number],
+      (A[number] & {
+        type: "function";
+        name: N;
+      })["inputs"][number]["name"]
+    >
+  ) => {
+    call: () => Promise<
+      R extends { outputs: { length: 1 } }
+      ? MapTypeToJS<
+        TypeOrInternalType<R["outputs"][0]>,
+        R["outputs"][0]['components']
+      >
+      : R extends { outputs: any }
+      ? ExtractFromObj<R>
+      : void
+    >;
+    send: (prop: { from: string, maxPriorityFeePerGas?: number, gas?: number, gasPrice?: string }) => Promise<void>;
+  };
+
+// oh boy don't do this
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+  k: infer I
+) => void
+  ? I
+  : never;
+type LastOf<T> = UnionToIntersection<
+  T extends any ? () => T : never
+> extends () => infer R
+  ? R
+  : never;
+
+// TS4.0+
+type Push<T extends any[], V> = [...T, V];
+
+// TS4.1+
+export type TuplifyUnion<
+  FUNCS,
+  T,
+  L = LastOf<T>,
+  N = [T] extends [never] ? true : false
+  > = true extends N
+  ? []
+  : Push<
+    TuplifyUnion<FUNCS, Exclude<T, L>>,
+    MapTypeToJS<
+      TypeOrInternalType<(FUNCS & { name: L })>,
+      (FUNCS & { name: L })['components']
+    >
+  >;
+
+export class GenericContract<
+  A extends AllABIs = AllABIs,
+  E extends string = ExtractEvents<A[number]> | "allEvents"
+  > extends Contract {
+  events!: Exclude<E, "allEvents">;
+  constructor(jsonInterface: A, address?: string, options?: ContractOptions) {
+    super(jsonInterface as unknown as AbiItem[], address, options);
+  }
+  override methods!: {
+    [k in ExtractMethods<A[number]>]: ExtractMethodDefinition<A, k>;
+  };
+  override getPastEvents(event: E): Promise<GenericEventData<A>[]>;
+  override getPastEvents(
+    event: E,
+    options: PastEventOptions,
+    callback: (error: Error, event: EventData) => void
+  ): Promise<GenericEventData<A>[]>;
+  override getPastEvents(
+    event: E,
+    options: PastEventOptions
+  ): Promise<GenericEventData<A>[]>;
+  override getPastEvents(
+    event: E,
+    callback: (error: Error, event: EventData) => void
+  ): Promise<GenericEventData<A>[]>;
+  override getPastEvents(
+    event: any,
+    options?: any,
+    callback?: any
+  ): Promise<GenericEventData<A>[]> {
+    return super.getPastEvents(event, options, callback) as any;
+  }
+}
+
+export default GenericContract;
+
+export type GenericEventData<E extends AllABIs> = EventData & GenericEvent<E>;
+
+type ABIEvent = AllABIs[number] & { type: "event" };
+
+type GenericEvent<
+  ABI extends AllABIs,
+  E extends string = ExtractEvents<ABI[number]>
+  > = {
+    event: E;
+    returnValues: ExtractReturnValues<ABIEvent & { name: E }>;
+  };
+
+type ExtractReturnValues<E extends ABIEvent> = ExtractInputType<
+  E["inputs"][number]
+>;
+
+type ExtractInputType<I extends ABIEvent["inputs"][number]> = {
+  [k in I["name"]]: MapTypeToJS<
+    TypeOrInternalType<I>,
+    I['components']
+  >;
+};

package/src/models/Orbs.ts

@@ -0,0 +1,97 @@
+export interface OrbDrawer {
+  drawOrb(x: number, y: number, radius: number): void;
+}
+
+class BaseOrb {
+  protected drawer: OrbDrawer;
+  constructor(drawer: OrbDrawer) {
+    this.drawer = drawer;
+  }
+}
+
+export class Orb extends BaseOrb {
+  x: number;
+  y: number;
+  vx: number;
+  vy: number;
+  radius: number;
+  bounds: { width: number; height: number };
+
+  constructor(
+    drawer: OrbDrawer,
+    velocity: number,
+    bounds: Orb["bounds"],
+    radius: number
+  ) {
+    super(drawer);
+    this.x = (Math.random() * bounds.width) | 0;
+    this.y = (Math.random() * bounds.height) | 0;
+    this.radius = radius;
+    this.bounds = bounds;
+
+    var radiant = Math.random() * Math.PI * 2,
+      vel = velocity;
+
+    vel *= 0.2;
+
+    this.vx = Math.cos(radiant) * vel;
+    this.vy = Math.sin(radiant) * vel;
+  }
+  step() {
+    this.x += this.vx;
+    this.y += this.vy;
+
+    var radius = this.radius / 2;
+
+    if (this.x < -radius || this.x > this.bounds.width + radius) this.vx *= -1;
+
+    if (this.y < -radius || this.y > this.bounds.height + radius) this.vy *= -1;
+
+    this.drawer.drawOrb(this.x | 0, this.y | 0, this.radius);
+  }
+}
+
+export class GuideOrb extends BaseOrb {
+  lastRadius!: number;
+  lastX!: number;
+  lastY!: number;
+  deflateDuration: number;
+
+  constructor(drawer: OrbDrawer, deflateDuration: number) {
+    super(drawer);
+    this.deflateDuration = deflateDuration;
+  }
+
+  step(
+    size: number,
+    sizeToIncrease: number,
+    lastSizeTimestamp: number,
+    lastPositionTimestamp: number,
+    currPos: { x: number; y: number },
+    moveBy: {
+      x: number;
+      y: number;
+    }
+  ) {
+    const deltaTime = Date.now() - lastSizeTimestamp;
+    const deltaTimePercent =
+      deltaTime > 250 ? 1 : (deltaTime * 100) / 250 / 100;
+
+    const radius = size - (sizeToIncrease - sizeToIncrease * deltaTimePercent);
+
+    this.lastRadius = radius;
+
+    const deltaTimePos = Date.now() - lastPositionTimestamp;
+    const deltaTimePosPercent =
+      deltaTimePos > this.deflateDuration
+        ? 1
+        : (deltaTimePos * 100) / this.deflateDuration / 100;
+
+    const translateX = currPos.x - (moveBy.x - moveBy.x * deltaTimePosPercent);
+    this.lastX = translateX;
+    const translateY = currPos.y - (moveBy.y - moveBy.y * deltaTimePosPercent);
+    this.lastY = translateY;
+
+    this.drawer.drawOrb(translateX | 0, translateY | 0, radius);
+  }
+}

package/src/reac-app-env.d.ts

@@ -0,0 +1,6 @@
+declare module "*.module.scss" {
+  const Styles: {
+    [style: string]: string;
+  };
+  export default Styles;
+}

package/src/storybookUtils/index.tsx

@@ -0,0 +1,53 @@
+import React, { ComponentProps, PropsWithChildren, forwardRef } from "react";
+import Spacing from "../components/Spacing";
+import { _Text } from "../components/Text/Text";
+
+export function extractAllPossibilitiesFromEnumProp<
+  C extends (...args: any[]) => any,
+  K extends keyof P,
+  P extends ComponentProps<C> = ComponentProps<C>
+>(component: C, propName: K): P[K][] {
+  if (component === _Text)
+    (_Text as any).__docgenInfo.props[propName] = {
+      type: {
+        value: [
+          "title",
+          "description",
+          "error",
+          "caption",
+          "highlightTitle",
+          "highlight",
+          "subtitle",
+          "boldTitle",
+          "link",
+          "boldTitleBig",
+          "content",
+        ].map((a) => ({ value: JSON.stringify(a) })),
+      },
+    };
+  return (component as any).__docgenInfo.props[propName].type.value.map(
+    (a: { value: string }) => JSON.parse(a.value)
+  ) as P[K][];
+}
+
+export function SideBySideContainer({
+  children,
+  exampleName,
+}: PropsWithChildren<{ exampleName: string }>) {
+  return (
+    <div
+      style={{
+        width: "25%",
+        marginRight: 24,
+        display: "inline-flex",
+        flexDirection: "column",
+      }}
+    >
+      <span style={{ borderBottom: "2px solid black", marginBottom: 14 }}>
+        Tipo: <b>{exampleName}</b>
+      </span>
+      {children}
+      <Spacing size="large" />
+    </div>
+  );
+}

package/src/type-utils.ts

@@ -0,0 +1,49 @@
+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/utility.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 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

@@ -0,0 +1,43 @@
+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/flatten.ts

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,36 @@
+/**
+ * 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

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

package/src/utils/ownEvent.ts

@@ -0,0 +1,8 @@
+/**
+ * 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

@@ -0,0 +1,19 @@
+type Func = (...args: any[]) => string
+
+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
+  }