@app-brew/brewery 1.0.0

package/src/react-utils/src/hooks.ts

@@ -0,0 +1,176 @@
+import { ScreenContext } from '@gauntlet/state'
+import debounce from 'lodash.debounce'
+import * as React from 'react'
+import { Animated, AppState, View } from 'react-native'
+
+export function useEffectOnce(func: () => void, dependencyArr: Array<any>) {
+  const ref = React.useRef(false)
+  React.useEffect(() => {
+    if (!ref.current) {
+      ref.current = true
+      return func()
+    }
+  }, dependencyArr)
+}
+
+export function useEffectOnResume(func: () => void, dependencyArr: Array<any>) {
+  React.useEffect(() => {
+    const sub = AppState.addEventListener('change', (state) => {
+      if (
+        AppState.currentState === 'active' &&
+        (state === 'background' || state === 'inactive' || state === 'unknown')
+      ) {
+        func()
+        return sub.remove
+      }
+      return
+    })
+  }, dependencyArr)
+}
+
+type UseIsViewInViewPortProps = {
+  viewRef: React.RefObject<View>
+  fraction?: number
+  delay?: number
+  // use this componentName to know from which component the hook is being called.
+  componentName?: string
+}
+/**
+ *
+ * @param scrollRef scrollRef is actually a contentOffsetY of the flatlist. It represents how much the user has scrolled. Its value is updated by the onScroll event of the flatlist.
+ * @param viewRef is the ref of the view that we want to check if it is in the viewport.
+ * @param fraction is the fraction of the view that should be visible in the viewport to consider it as in the viewport.
+ * @param delay is the delay in ms to debounce the scroll event.
+ * @returns
+ */
+
+export function useIsViewInViewPort({
+  viewRef,
+  fraction = 0.4, // 40% atleast should be visible
+  delay = 100,
+  componentName,
+}: UseIsViewInViewPortProps) {
+  const [isInView, setIsInView] = React.useState(false)
+  const screenContext = React.useContext(ScreenContext)
+  const scrollRef = screenContext?.value?.scrollRef
+  const flatListPageY = React.useRef(0)
+  const flatListRef = screenContext?.value.contentViewRef
+
+  const measureView = React.useCallback(() => {
+    const flatlistHeight = screenContext?.value.contentHeight ?? 0
+    const isViewInViewPort = isInView
+
+    viewRef.current?.measure((x, y, width, height, pageX, pageY) => {
+      const viewHeight = height
+
+      if (!height || !pageY) {
+        if (isInView) {
+          setIsInView(false)
+        }
+        return
+      }
+
+      if (viewHeight <= 0) {
+        if (isInView) {
+          setIsInView(false)
+        }
+        return
+      }
+      /**
+       * As user scrolls, pageY becomes negative.
+       * Whenever pageY>=0, means that atleast some portion of the view is visible on the screen.
+       * pageY >= viewHeight * fraction means that atleast 60%(fraction=0.6) of the view should be visible
+       * At the same time, it should not exceed our flatlistHeight
+       *
+       *
+       * flatListPageY is basically the height above our flatList. That needs to be in there in the calculation.
+       * As user scrolls, the pageY should be less than 60% of the view
+       */
+
+      const viewInViewPort =
+        (pageY >= viewHeight * fraction && pageY <= flatlistHeight) ||
+        Math.abs(pageY - flatListPageY.current) <= viewHeight * fraction
+
+      if (viewInViewPort && !isViewInViewPort) {
+        setIsInView(true)
+        return
+      }
+      if (!viewInViewPort && isViewInViewPort) {
+        setIsInView(false)
+      }
+    })
+  }, [])
+
+  React.useEffect(() => {
+    flatListRef?.current?.measure((x, y, width, height, pageX, pageY) => {
+      // this pageY = the space above the flatlist parent = appBarHeight+topInset
+      // it comes NaN in android, since measure function works differently on android
+      if (isNaN(pageY)) return
+      flatListPageY.current = pageY
+    })
+  }, [])
+
+  // To detect if the view is in the viewport. If yes, play the video, else pause it.
+  React.useEffect(() => {
+    const flatlistHeight = screenContext?.value.contentHeight ?? 0
+    const isViewInViewPort = isInView
+
+    // To check if the view is in the viewport when the screen is loaded (for initial state when no scroll has happened).
+    const isInitialLoad = scrollRef?.current?.__getValue() === 0
+    if (isInitialLoad) {
+      measureView()
+    }
+
+    // To check if the view is in the viewport when the user scrolls.
+    const debouncedListener = debounce((e) => {
+      viewRef.current?.measure((x, y, width, height, pageX, pageY) => {
+        const viewHeight = height
+
+        if (!height || !pageY) {
+          if (isInView) {
+            setIsInView(false)
+          }
+          return
+        }
+
+        if (viewHeight <= 0) {
+          if (isInView) {
+            setIsInView(false)
+          }
+          return
+        }
+
+        const viewInViewPort =
+          (pageY >= viewHeight * fraction && pageY <= flatlistHeight) ||
+          Math.abs(pageY - flatListPageY.current) <= viewHeight * fraction
+
+        if (viewInViewPort && !isViewInViewPort) {
+          setIsInView(true)
+          return
+        }
+        if (!viewInViewPort && isViewInViewPort) {
+          setIsInView(false)
+        }
+      })
+    }, delay)
+    const listener = scrollRef?.current?.addListener(debouncedListener)
+
+    return () => {
+      if (listener) {
+        scrollRef?.current?.removeListener(listener)
+      }
+    }
+  }, [
+    delay,
+    fraction,
+    isInView,
+    measureView,
+    screenContext?.value.contentHeight,
+    scrollRef,
+    viewRef,
+  ])
+  const memoizedValue = React.useMemo(() => {
+    return { isInView }
+  }, [isInView])
+  return memoizedValue
+}

package/src/react-utils/src/index.ts

@@ -0,0 +1 @@
+export * from './hooks'

package/src/rn-rulepilot/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./types/rule";
+export * from "./types/error";
+export * from './services/rule-pilot'
+export * from './services/validator'

package/src/rn-rulepilot/src/services/builder.ts

@@ -0,0 +1,92 @@
+import {
+  Rule,
+  Operator,
+  Condition,
+  Constraint,
+  ConditionType,
+} from "../types/rule";
+import { Validator } from "./validator";
+import { RuleError } from "../types/error";
+
+export class Builder {
+  constructor(validator: Validator) {
+    this.validator = validator;
+  }
+
+  /** Stores to rule being constructed */
+  private rule: Rule = { conditions: [] };
+
+  /** Holds a reference to the Validator class */
+  private validator: Validator;
+
+  /**
+   * Adds a node (in the root) to the rule being constructed
+   * @param node The node to add to the rule
+   */
+  add(node: Condition): Builder {
+    (this.rule.conditions as Condition[]).push(node);
+    return this;
+  }
+
+  /**
+   * Sets the default value of the rule being constructed
+   * @param value The default value of the rule
+   */
+  default(value: Rule["default"]): Builder {
+    this.rule.default = value;
+    return this;
+  }
+
+  /**
+   * Builds the rule being and returns it
+   * @param validate Whether to validate the rule before returning it
+   * @throws Error if validation is enabled and the rule is invalid
+   */
+  build(validate?: boolean): Rule {
+    if (!validate) {
+      return this.rule;
+    }
+
+    const validationResult = this.validator.validate(this.rule);
+    if (validationResult.isValid) {
+      return this.rule;
+    }
+
+    throw new RuleError(validationResult);
+  }
+
+  /**
+   * Creates a new condition node
+   * @param type The type of condition
+   * @param nodes Any child nodes of the condition
+   * @param result The result of the condition node (for granular rules)
+   */
+  condition(
+    type: ConditionType,
+    nodes: Condition[ConditionType],
+    result?: Condition["result"]
+  ): Condition {
+    return {
+      [type]: nodes,
+      ...(result ? { result } : {}),
+    };
+  }
+
+  /**
+   * Creates a new constraint node
+   * @param field The field to apply the constraint to
+   * @param operator The operator to apply to the field
+   * @param value The value to compare the field to
+   */
+  constraint(
+    field: string,
+    operator: Operator,
+    value: Constraint["value"]
+  ): Constraint {
+    return {
+      field,
+      operator,
+      value,
+    };
+  }
+}

package/src/rn-rulepilot/src/services/evaluator.ts

@@ -0,0 +1,176 @@
+import { ObjectDiscovery } from './object-discovery'
+import { Condition, Constraint, Rule } from '../types/rule'
+
+export class Evaluator {
+  private _objectDiscovery: ObjectDiscovery = new ObjectDiscovery()
+
+  /**
+   * Evaluates a rule against a set of criteria and returns the result.
+   * If the criteria is an array (indicating multiple criteria to test),
+   * the rule will be evaluated against each item in the array and
+   * an array of results will be returned.
+   *
+   * @param rule The rule to evaluate.
+   * @param criteria The criteria to evaluate the rule against.
+   */
+  evaluate(rule: Rule, criteria: object | object[]): boolean | any {
+    // Cater for the case where the conditions property is not an array.
+    const conditions =
+      rule.conditions instanceof Array ? rule.conditions : [rule.conditions]
+
+    if (criteria instanceof Array) {
+      const result = []
+      for (const c of criteria) {
+        result.push(this.evaluateRule(conditions, c, rule?.default))
+      }
+
+      return result
+    }
+
+    return this.evaluateRule(conditions, criteria, rule?.default)
+  }
+
+  /**
+   * Evaluates a rule against a set of criteria and returns the result.
+   * @param conditions The conditions to evaluate.
+   * @param criteria The criteria to evaluate the conditions against.
+   * @param defaultResult The default result to return if no conditions pass.
+   */
+  private evaluateRule(
+    conditions: Condition[],
+    criteria: object,
+    defaultResult?: any
+  ): boolean | any {
+    // We should evaluate all conditions and return the result
+    // of the first condition that passes.
+    for (const condition of conditions) {
+      const result = this.evaluateCondition(condition, criteria)
+      if (result) {
+        return condition?.result ?? true
+      }
+    }
+
+    // If no conditions pass, we should return the default result of
+    // the rule or false if no default result is provided.
+    return defaultResult ?? false
+  }
+
+  /**
+   * Evaluates a condition against a set of criteria and returns the result.
+   * Uses recursion to evaluate nested conditions.
+   * @param condition The condition to evaluate.
+   * @param criteria The criteria to evaluate the condition against.
+   */
+  private evaluateCondition(condition: Condition, criteria: object): boolean {
+    // The condition must have an 'any' or 'all' property.
+    const type = this._objectDiscovery.conditionType(condition)
+    if (!type) {
+      return false
+    }
+
+    // If the type is 'all' or 'none', we should set the initial
+    // result to true, otherwise we should set it to false.
+    let result = ['all', 'none'].includes(type)
+
+    // Check each node in the condition.
+    for (const node of condition[type]) {
+      let fn
+      if (this._objectDiscovery.isCondition(node)) {
+        fn = 'evaluateCondition'
+      }
+      if (this._objectDiscovery.isConstraint(node)) {
+        fn = 'checkConstraint'
+      }
+
+      // Process the node
+      switch (type) {
+        case 'any':
+          result = result || this[fn](node, criteria)
+          break
+        case 'all':
+          result = result && this[fn](node, criteria)
+          break
+        case 'none':
+          result = result && !this[fn](node, criteria)
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * Checks a constraint against a set of criteria and returns true whenever the constraint passes.
+   * @param constraint The constraint to evaluate.
+   * @param criteria The criteria to evaluate the constraint with.
+   */
+  private checkConstraint(constraint: Constraint, criteria: object): boolean {
+    // If the value contains '.' we should assume it is a nested property
+    const criterion = constraint.field.includes('.')
+      ? this._objectDiscovery.resolveNestedProperty(constraint.field, criteria)
+      : criteria[constraint.field]
+
+    // If the criteria object does not have the field
+    // we are looking for, we should return false.
+    if (typeof criterion === 'undefined') {
+      return false
+    }
+
+    let criterionValue = criterion
+    let constraintValue = constraint.value
+
+    // Normalize strings (case-insensitive)
+    if (typeof criterionValue === 'string')
+      criterionValue = criterionValue.trim().toLowerCase()
+    if (typeof constraintValue === 'string')
+      constraintValue = constraintValue.trim().toLowerCase()
+
+    // Normalize arrays (case-insensitive for string items)
+    if (Array.isArray(criterionValue)) {
+      criterionValue = criterionValue.map((v) =>
+        typeof v === 'string' ? v.trim().toLowerCase() : v
+      )
+    }
+    if (Array.isArray(constraintValue)) {
+      constraintValue = constraintValue.map((v) =>
+        typeof v === 'string' ? v.trim().toLowerCase() : v
+      )
+    }
+
+    switch (constraint.operator) {
+      case '==':
+        return criterionValue == constraintValue
+      case '!=':
+        return criterionValue != constraintValue
+      case '>':
+        return criterionValue > constraintValue
+      case '>=':
+        return criterionValue >= constraintValue
+      case '<':
+        return criterionValue < constraintValue
+      case '<=':
+        return criterionValue <= constraintValue
+      case 'in':
+        return (
+          Array.isArray(constraintValue) &&
+          constraintValue.includes(criterionValue as never)
+        )
+      case 'not in':
+        return (
+          !Array.isArray(constraintValue) ||
+          !constraintValue.includes(criterionValue as never)
+        )
+      case 'contains':
+        return (
+          Array.isArray(criterionValue) &&
+          criterionValue.includes(constraintValue as never)
+        )
+      case 'not contains':
+        return (
+          !Array.isArray(criterionValue) ||
+          !criterionValue.includes(constraintValue as never)
+        )
+      default:
+        return false
+    }
+  }
+}

package/src/rn-rulepilot/src/services/logger.ts

@@ -0,0 +1,6 @@
+export class Logger {
+  static debug(message: string): void {
+    if (!process.env.DEBUG) return;
+    console.debug(message);
+  }
+}

package/src/rn-rulepilot/src/services/mutator.ts

@@ -0,0 +1,203 @@
+import { JSHash, CONSTANTS } from 'react-native-hash'
+import { Logger } from './logger'
+import { ObjectDiscovery } from './object-discovery'
+
+export class Mutator {
+  private _cache: Map<string, any> = new Map()
+  private _buffer: Map<string, boolean> = new Map()
+  private _mutations: Map<string, Function> = new Map()
+
+  private _objectDiscovery = new ObjectDiscovery()
+
+  /**
+   * Adds a mutation to the mutator instance.
+   * @param name The name of the mutation.
+   * @param mutation The mutation function.
+   */
+  add(name: string, mutation: Function): void {
+    this._mutations.set(name, mutation)
+  }
+
+  /**
+   * Removes a mutation to the mutator instance.
+   * Any cached mutation values for this mutation will be purged.
+   * @param name The name of the mutation.
+   */
+  remove(name: string): void {
+    this.clearCache(name)
+    this._mutations.delete(name)
+  }
+
+  /**
+   * Clears the mutator cache.
+   * The entire cache, or cache for a specific mutator, can be cleared
+   * by passing or omitting the mutator name as an argument.
+   * @param name The mutator name to clear the cache for.
+   */
+  clearCache(name?: string): void {
+    if (!name) {
+      this._cache.clear()
+      return
+    }
+
+    for (const key of this._cache.keys()) {
+      if (key.startsWith(name)) {
+        this._cache.delete(key)
+      }
+    }
+  }
+
+  /**
+   * Mutates and returns a criteria object.
+   * @param criteria The criteria to mutate.
+   */
+  async mutate(criteria: object | object[]): Promise<object | object[]> {
+    // Handles checking the mutability of a criteria object
+    // If it is mutable it will be cloned, mutated and returned
+    const exec = async (criteria) => {
+      // If there are no mutations or the criteria does not contain
+      // any of the mutation keys, return the criteria as is.
+      if (!this._mutations.size || !this.hasMutations(criteria)) {
+        return criteria
+      }
+
+      // Make a copy of the criteria.
+      const copy = { ...criteria }
+
+      // Apply the mutations to the copy and return it.
+      await this.applyMutations(copy)
+      return copy
+    }
+
+    // If the criteria is an array, we want to apply the mutations
+    // to each item in the array in parallel.
+    if (criteria instanceof Array) {
+      return await Promise.all(
+        criteria.map(
+          (c) =>
+            new Promise(async (resolve) => {
+              resolve(await exec(c))
+            })
+        )
+      )
+    } else {
+      return await exec(criteria)
+    }
+  }
+
+  /**
+   * Checks if the criteria contains any mutate-able properties.
+   * @param criteria The criteria to check.
+   * @param result Whether a mutate-able property has been found.
+   * @param parentPath The parent path to the current property.
+   */
+  private hasMutations(
+    criteria: object,
+    result: boolean = false,
+    parentPath: string = ''
+  ): boolean {
+    // If we have already found a mutation, we can stop.
+    if (result) return true
+
+    for (const key of Object.keys(criteria)) {
+      if (result) return true
+
+      // Prepare dotted path to the current property.
+      const path = parentPath ? `${parentPath}.${key}` : key
+
+      // If the value is an object, we should recurse.
+      result = this._objectDiscovery.isObject(criteria[key])
+        ? result || this.hasMutations(criteria[key], result, path)
+        : result || this._mutations.has(path)
+    }
+
+    return result
+  }
+
+  /**
+   * Recursively applies mutations to the criteria.
+   * @param criteria The criteria to mutate.
+   * @param parentPath The parent path to the current property.
+   */
+  private async applyMutations(
+    criteria: object,
+    parentPath: string = ''
+  ): Promise<void> {
+    const promises = Object.keys(criteria).map(
+      async (key) =>
+        new Promise(async (resolve) => {
+          // Prepare dotted path to the current property.
+          const path = parentPath ? `${parentPath}.${key}` : key
+
+          if (this._objectDiscovery.isObject(criteria[key])) {
+            await this.applyMutations(criteria[key], path)
+          }
+
+          if (this._mutations.has(path)) {
+            criteria[key] = await this.execMutation(key, criteria, path)
+          }
+
+          resolve(criteria[key])
+        })
+    )
+
+    await Promise.all(promises)
+  }
+
+  /**
+   * Executes a mutation.
+   * Defers duplicate executions to the same object from a memory cache.
+   * @param criteriaProp The criteria property to execute the mutation on.
+   * @param criteria The criteria to execute the mutation with.
+   * @param mutationKey The key of the mutation to execute.
+   */
+  private async execMutation(
+    criteriaProp: string,
+    criteria: unknown,
+    mutationKey: string
+  ): Promise<any> {
+    const value = criteria[criteriaProp]
+    const hashValue = await JSHash(value, CONSTANTS.HashAlgorithms.sha256)
+    // Create a cache key
+    const cacheKey = `${mutationKey}${hashValue}`
+
+    // If the mutation has already been executed, return the cached result.
+    if (this._cache.has(cacheKey)) {
+      Logger.debug(`Cache hit on "${mutationKey}" with param "${value}"`)
+      return this._cache.get(cacheKey)
+    }
+
+    // If the mutation is already in progress, wait for it to finish.
+    // if (this._buffer.get(cacheKey)) {
+    //   return await new Promise((resolve) => {
+    //     Logger.debug(
+    //       `Waiting on mutation "${mutationKey}" with param "${value}"`
+    //     );
+    //     this._eventEmitter.once(`mutation:${cacheKey}`, (result) => {
+    //       Logger.debug(
+    //         `Resolved mutation "${mutationKey}" with param "${value}"`
+    //       );
+    //       resolve(result);
+    //     });
+    //   });
+    // }
+
+    // Set the buffer to true to indicate that the mutation is in progress.
+    // This prevents duplicate executions of the same mutation.
+    this._buffer.set(cacheKey, true)
+
+    // Execute the mutation
+    Logger.debug(`Running mutation "${mutationKey}" with param "${value}"`)
+    const mutation = this._mutations.get(mutationKey)
+    const result = await mutation(value, criteria)
+
+    // Cache the result and release the buffer to false.
+    this._cache.set(cacheKey, result)
+    this._buffer.set(cacheKey, false)
+
+    // Emit an event to indicate that the mutation has been executed.
+    // this._eventEmitter.emit(`mutation:${cacheKey}`, result);
+
+    return result
+  }
+}