react-native-molecules 0.5.0-beta.3 → 0.5.0-beta.31

package/hooks/useSearchable.tsx

@@ -1,74 +0,0 @@
-import { type ReactElement, useCallback, useMemo } from 'react';
-
-import { IconButton } from '../components/IconButton';
-import {
-    TextInput,
-    type TextInputElementProps,
-    type TextInputProps,
-} from '../components/TextInput';
-import useControlledValue from './useControlledValue';
-
-export interface UseSearchableProps {
-    searchable?: boolean;
-    onQueryChange?: (search: string) => void;
-    query?: string;
-    searchInputProps?: Omit<TextInputProps, 'value' | 'onChangeText'>;
-}
-
-const useSearchInputProps = (props?: Partial<TextInputProps>) => {
-    const onChange = props?.onChangeText;
-    const onPressClear = useCallback(() => {
-        onChange?.('');
-    }, [onChange]);
-
-    const right = useCallback(
-        ({ color, forceFocus }: TextInputElementProps) => (
-            <IconButton
-                name={props?.value ? 'close-circle-outline' : 'magnify'}
-                onPress={props?.value ? onPressClear : forceFocus}
-                color={color}
-            />
-        ),
-        [onPressClear, props?.value],
-    );
-
-    return useMemo(
-        () => (props?.right === undefined ? props : { right, ...props }),
-        [props, right],
-    );
-};
-
-const useSearchable = ({
-    searchable,
-    onQueryChange,
-    query,
-    searchInputProps,
-}: UseSearchableProps = {}): ReactElement<TextInputProps> | null => {
-    const [value, onValueChange] = useControlledValue({
-        value: query || '',
-        defaultValue: '', // to disable the useControlledValue inside TextInput
-        onChange: onQueryChange,
-        disabled: !searchable,
-    });
-
-    const props = useSearchInputProps(
-        useMemo(
-            () => ({
-                ...searchInputProps,
-                value,
-                onChangeText: onValueChange,
-            }),
-            [onValueChange, searchInputProps, value],
-        ),
-    );
-
-    return useMemo(() => {
-        if (!searchable || !onQueryChange) return null;
-
-        return <TextInput {...props} />;
-    }, [onQueryChange, props, searchable]);
-};
-
-export { useSearchInputProps };
-
-export default useSearchable;

package/hooks/useSubcomponents.tsx

@@ -1,59 +0,0 @@
-import type { ReactElement } from 'react';
-import { Children, type FC, isValidElement, useMemo } from 'react';
-
-export type UseSubcomponentsProps<T extends string> = {
-    children: ReactElement | ReactElement[];
-    /**
-     * array of displayName as string
-     * */
-    allowedChildren: T[];
-};
-
-/**
- *  This will return an object with the displayNames as the property names
- *  eg. allowedChildren: ['Drawer_Header', 'Drawer_Content', 'Drawer_Footer', 'DrawerItem'];
- *
- *  return value -> {
- *    Drawer_Header: [],
- *    Drawer_Content: [],
- *    Drawer_Footer: [],
- *    DrawerItem: [],
- *  }
- *  */
-const useSubcomponents = <T extends string = string>({
-    children,
-    allowedChildren,
-}: UseSubcomponentsProps<T>) => {
-    return useMemo(() => {
-        // this will create properties with default empty array values even if they don't exist in the children
-        const defaultContext = allowedChildren.reduce((context, childName) => {
-            return {
-                ...context,
-                [childName]: [],
-            };
-        }, {}) as {
-            [key in T]: ReactElement[];
-        };
-
-        return Children.map(children, child => child).reduce((context, child) => {
-            if (!isValidElement(child)) return context;
-
-            if (
-                !allowedChildren.find(name => name === ((child.type as FC).displayName as string))
-            ) {
-                return context;
-            }
-
-            const name = (child.type as FC).displayName as T;
-
-            if (!name) return context;
-
-            return {
-                ...context,
-                [name]: [...context[name], child],
-            };
-        }, defaultContext);
-    }, [allowedChildren, children]);
-};
-
-export default useSubcomponents;

package/hooks/useToggle.tsx

@@ -1,24 +0,0 @@
-import { useCallback, useMemo, useState } from 'react';
-
-const useToggle = (initialState = false) => {
-    const [state, setState] = useState<boolean>(initialState);
-
-    const toggle = useCallback(() => setState(prevState => !prevState), []);
-
-    const handleClose = useCallback(() => setState(false), [setState]);
-
-    const handleOpen = useCallback(() => setState(true), [setState]);
-
-    return useMemo(
-        () => ({
-            state,
-            onToggle: toggle,
-            setState,
-            handleOpen,
-            handleClose,
-        }),
-        [state, toggle, setState, handleOpen, handleClose],
-    );
-};
-
-export default useToggle;

package/utils/color.ts

@@ -1,22 +0,0 @@
-import color from 'color';
-
-import { weakMemoized } from './lodash';
-
-export const resolveContrastColor = weakMemoized(
-    (
-        bgColor: string,
-        lightColor: string = '#fff',
-        darkColor: string = '#000',
-        isDarkMode?: boolean,
-    ) => {
-        let isLightColor = !isDarkMode;
-        try {
-            // TODO: Account for transparency.
-            isLightColor = color(bgColor).isLight();
-        } finally {
-            return isLightColor ? darkColor : lightColor;
-        }
-    },
-);
-
-export default color;

package/utils/compare/index.ts

@@ -1,54 +0,0 @@
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-
-/**
- * inlined Object.is polyfill to avoid requiring consumers ship their own
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
- */
-function is(x: any, y: any) {
-    // SameValue algorithm
-    if (x === y) {
-        // Steps 1-5, 7-10
-        // Steps 6.b-6.e: +0 != -0
-        return x !== 0 || 1 / x === 1 / y;
-    } else {
-        // Step 6.a: NaN == NaN
-        return x !== x && y !== y;
-    }
-}
-
-/**
- * Performs equality by iterating through keys on an object and returning false
- * when any key has values which are not strictly equal between the arguments.
- * Returns true when the values of all keys are strictly equal.
- */
-export function shallowCompare(objA?: unknown, objB?: unknown) {
-    if (is(objA, objB)) {
-        return true;
-    }
-
-    if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
-        return false;
-    }
-
-    const keysA = Object.keys(objA);
-    const keysB = Object.keys(objB);
-
-    if (keysA.length !== keysB.length) {
-        return false;
-    }
-
-    // Test for A's keys different from B.
-    for (let i = 0; i < keysA.length; i++) {
-        if (
-            !hasOwnProperty.call(objB, keysA[i]) ||
-            !is(
-                (objA as Record<string, unknown>)[keysA[i]],
-                (objB as Record<string, unknown>)[keysA[i]],
-            )
-        ) {
-            return false;
-        }
-    }
-
-    return true;
-}

package/utils/lodash.ts

@@ -1,49 +0,0 @@
-import memoize from 'lodash.memoize';
-export { default as get } from 'lodash.get';
-export { default as keyBy } from 'lodash.keyby';
-export { default as memoize } from 'lodash.memoize';
-export { default as omitBy } from 'lodash.omitby';
-
-export const isNil = (value: unknown): value is null | undefined => value == null;
-export const noop = () => {};
-
-const uniqueIdFactory = () => {
-    let number = Number.MAX_SAFE_INTEGER;
-    return () => number--;
-};
-
-const getUniqueId = uniqueIdFactory();
-const weakMemoize = Object.assign(memoize.bind(null), { Cache: WeakMap });
-const getObjectMemoryAddress = weakMemoize((x: unknown | null) => x && getUniqueId());
-
-export const allArgumentResolver = (...args: unknown[]) =>
-    args
-        .map(x => {
-            const type = typeof x;
-            switch (type) {
-                case 'object':
-                case 'function':
-                    return type.slice(0, 2)! + getObjectMemoryAddress(x);
-                default:
-                    return type.slice(0, 2)! + String(x);
-            }
-        })
-        .join('_');
-
-export const createMemoizedFunction = ({
-    resolver = allArgumentResolver,
-    Cache = Map,
-}: {
-    resolver?: (...args: any[]) => any;
-    Cache?: typeof memoize.Cache;
-} = {}) => {
-    const memo = Object.assign(memoize.bind(null), { Cache });
-    return Object.assign(
-        <T extends (...args: any[]) => any>(func: T, resolverOverwride?: (...args: any[]) => any) =>
-            memo(func, resolverOverwride ?? resolver),
-    );
-};
-
-export const weakMemoized = createMemoizedFunction({
-    Cache: WeakMap,
-});

package/utils/repository.ts

@@ -1,53 +0,0 @@
-interface RepositoryConstructor<T> {
-    onRegister?: (arg: T, name: string, registery: Record<string, T>) => T;
-    name?: string;
-}
-
-let id = Date.now();
-
-export class Repository<T> {
-    private registry: Record<string, T> = {};
-    readonly #name!: string;
-
-    readonly #onRegister!: (arg: T, name: string, registery: Record<string, T>) => T;
-
-    get name() {
-        return this.#name;
-    }
-
-    static get uniqueId() {
-        return (id++).toString(36).substring(0, 15);
-    }
-
-    constructor({
-        onRegister = arg => arg,
-        name = Repository.uniqueId,
-    }: RepositoryConstructor<T> = {}) {
-        this.#onRegister = onRegister;
-        this.#name = name;
-    }
-
-    has = (itemName: string): boolean => {
-        return !!this.registry[itemName];
-    };
-
-    /**
-     * Register a item with the src.
-     */
-    register = <X extends T = T, ItemName extends string = ''>(itemName: ItemName, item: X) => {
-        let updatedItem = this.#onRegister?.(item, itemName, { ...this.registry });
-        if (!updatedItem) updatedItem = item;
-
-        this.registry = {
-            ...this.registry,
-            [itemName]: updatedItem,
-        };
-    };
-
-    /**
-     * Get all registered module from the registry.
-     */
-    getAll = () => {
-        return this.registry;
-    };
-}