react-native-molecules 0.5.0-beta.22 → 0.5.0-beta.24

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,121 +0,0 @@
-type MemoizeCache<K = any, V = any> = {
-    has(key: K): boolean;
-    get(key: K): V | undefined;
-    set(key: K, value: V): unknown;
-};
-
-type MemoizeFn = {
-    <T extends (...args: any[]) => any>(
-        func: T,
-        resolver?: (...args: Parameters<T>) => any,
-    ): MemoizedFunction<T>;
-    Cache: { new (): MemoizeCache<any, any> };
-};
-
-export interface MemoizedFunction<T extends (...args: any[]) => any> {
-    (...args: Parameters<T>): ReturnType<T>;
-    cache: MemoizeCache<any, ReturnType<T>>;
-}
-
-export const memoize: MemoizeFn = ((
-    func: (...args: any[]) => any,
-    resolver?: (...args: any[]) => any,
-) => {
-    if (typeof func !== 'function') {
-        throw new TypeError('Expected a function');
-    }
-    const memoized = function (this: unknown, ...args: any[]) {
-        const key = resolver ? resolver.apply(this, args) : args[0];
-        const { cache } = memoized as MemoizedFunction<typeof func>;
-        if (cache.has(key)) {
-            return cache.get(key);
-        }
-        const result = func.apply(this, args);
-        cache.set(key, result);
-        return result;
-    } as MemoizedFunction<typeof func>;
-
-    (memoized as MemoizedFunction<typeof func>).cache = new memoize.Cache();
-    return memoized;
-}) as MemoizeFn;
-
-memoize.Cache = Map;
-
-type Iteratee<T> = ((item: T) => string | number | symbol) | keyof T;
-
-export const keyBy = <T extends Record<string, any>>(
-    collection: T[],
-    iteratee: Iteratee<T>,
-): Record<string, T> => {
-    const result: Record<string, T> = {};
-    if (!Array.isArray(collection)) return result;
-
-    const getter = typeof iteratee === 'function' ? iteratee : (item: T) => item[iteratee];
-    for (const item of collection) {
-        const key = getter(item);
-        if (key != null) {
-            result[String(key)] = item;
-        }
-    }
-    return result;
-};
-
-type Predicate = (value: any, key: string) => boolean;
-
-export const omitBy = <T extends Record<string, any>>(
-    object: T,
-    predicate: Predicate,
-): Partial<T> => {
-    if (object == null) return {};
-    const result: Partial<T> = {};
-    for (const [key, value] of Object.entries(object)) {
-        if (!predicate(value, key)) {
-            result[key as keyof T] = value;
-        }
-    }
-    return result;
-};
-
-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;
-    };
-}