add useDotAccessOperator #44

cshaa · Sep 22, 2021 · 56df51f · 56df51f
1 parent 7cdaea0
commit 56df51f
Show file tree

Hide file tree

Showing 8 changed files with 249 additions and 16 deletions.
diff --git a/dist/browser/filtrex.js b/dist/browser/filtrex.js
@@ -2261,6 +2261,46 @@ var filtrex = (function (exports) {
     parser.yy = Object.create(std);
 
 
+    /**
+     * A custom prop function which treats dots inside a symbol
+     * as property accessors. If you want to use the `foo.bar`
+     * syntax to access properties instead of the default
+     * `bar of foo`, you can use this function using the following
+     * code:
+     * ```
+     * import {
+     *   compileExpression,
+     *   useDotAccessOperator
+     * } from 'filtrex'
+     *
+     * const expr = "foo.bar"
+     *
+     * const fn = compileExpression(expr, {
+     *   customProp: useDotAccessOperator
+     * });
+     *
+     * fn({ foo: { bar: 42 } }) // → 42
+     * ```
+     */
+    function useDotAccessOperator(name, get, obj, type) {
+        // ignore dots inside escaped symbol
+        if (type === 'single-quoted')
+            return get(name)
+
+
+        const parts = name.split('.');
+
+        for (const propertyName of parts) {
+            if (hasOwnProperty(obj ?? {}, propertyName)) {
+                obj = obj[propertyName];
+            } else {
+                throw new UnknownPropertyError(propertyName)
+            }
+        }
+
+        return obj
+    }
+
 
     /**
      * A simple, safe, JavaScript expression engine, allowing end-users to enter arbitrary expressions without p0wning you.
@@ -2394,7 +2434,7 @@ var filtrex = (function (exports) {
 
         // Metaprogramming functions
 
-        function nakedProp(name, obj) {
+        function nakedProp(name, obj, type) {
             if (hasOwnProperty(obj ?? {}, name))
                 return obj[name]
 
@@ -2411,7 +2451,7 @@ var filtrex = (function (exports) {
         }
 
         if (typeof customProp === 'function') {
-            nakedProp = (name, obj) => customProp(name, safeGetter(obj), obj);
+            nakedProp = (name, obj, type) => customProp(name, safeGetter(obj), obj, type);
         }
 
         function createCall(fns) {
@@ -2427,7 +2467,7 @@ var filtrex = (function (exports) {
             if (type === 'unescaped' && hasOwnProperty(constants, name))
                 return constants[name]
 
-            return nakedProp(name, obj)
+            return nakedProp(name, obj, type)
         }
 
 
@@ -2448,6 +2488,7 @@ var filtrex = (function (exports) {
     }
 
     exports.compileExpression = compileExpression;
+    exports.useDotAccessOperator = useDotAccessOperator;
 
     Object.defineProperty(exports, '__esModule', { value: true });
 

diff --git a/dist/browser/filtrex.min.js b/dist/browser/filtrex.min.js
diff --git a/dist/cjs/filtrex.js b/dist/cjs/filtrex.js
@@ -2262,6 +2262,46 @@ const std =
 parser.yy = Object.create(std);
 
 
+/**
+ * A custom prop function which treats dots inside a symbol
+ * as property accessors. If you want to use the `foo.bar`
+ * syntax to access properties instead of the default
+ * `bar of foo`, you can use this function using the following
+ * code:
+ * ```
+ * import {
+ *   compileExpression,
+ *   useDotAccessOperator
+ * } from 'filtrex'
+ *
+ * const expr = "foo.bar"
+ *
+ * const fn = compileExpression(expr, {
+ *   customProp: useDotAccessOperator
+ * });
+ *
+ * fn({ foo: { bar: 42 } }) // → 42
+ * ```
+ */
+function useDotAccessOperator(name, get, obj, type) {
+    // ignore dots inside escaped symbol
+    if (type === 'single-quoted')
+        return get(name)
+
+
+    const parts = name.split('.');
+
+    for (const propertyName of parts) {
+        if (hasOwnProperty(obj ?? {}, propertyName)) {
+            obj = obj[propertyName];
+        } else {
+            throw new UnknownPropertyError(propertyName)
+        }
+    }
+
+    return obj
+}
+
 
 /**
  * A simple, safe, JavaScript expression engine, allowing end-users to enter arbitrary expressions without p0wning you.
@@ -2395,7 +2435,7 @@ function compileExpression(expression, options) {
 
     // Metaprogramming functions
 
-    function nakedProp(name, obj) {
+    function nakedProp(name, obj, type) {
         if (hasOwnProperty(obj ?? {}, name))
             return obj[name]
 
@@ -2412,7 +2452,7 @@ function compileExpression(expression, options) {
     }
 
     if (typeof customProp === 'function') {
-        nakedProp = (name, obj) => customProp(name, safeGetter(obj), obj);
+        nakedProp = (name, obj, type) => customProp(name, safeGetter(obj), obj, type);
     }
 
     function createCall(fns) {
@@ -2428,7 +2468,7 @@ function compileExpression(expression, options) {
         if (type === 'unescaped' && hasOwnProperty(constants, name))
             return constants[name]
 
-        return nakedProp(name, obj)
+        return nakedProp(name, obj, type)
     }
 
 
@@ -2449,3 +2489,4 @@ function compileExpression(expression, options) {
 }
 
 exports.compileExpression = compileExpression;
+exports.useDotAccessOperator = useDotAccessOperator;
diff --git a/dist/esm/filtrex.d.ts b/dist/esm/filtrex.d.ts
@@ -106,7 +106,8 @@ export interface Options
     customProp?: (
         name: string,
         get: (name: string) => any,
-        object: any
+        object: any,
+        type: 'unescaped' | 'single-quoted'
     ) => any
 
     /**
@@ -134,3 +135,31 @@ export interface Operators {
 
     '~='?: (a: any, b: any) => boolean
 }
+
+/**
+ * A custom prop function which treats dots inside a symbol
+ * as property accessors. If you want to use the `foo.bar`
+ * syntax to access properties instead of the default
+ * `bar of foo`, you can use this function using the following
+ * code:
+ * ```
+ * import {
+ *   compileExpression,
+ *   useDotAccessOperator
+ * } from 'filtrex'
+ *
+ * const expr = "foo.bar"
+ *
+ * const fn = compileExpression(expr, {
+ *   customProp: useDotAccessOperator
+ * });
+ *
+ * fn({ foo: { bar: 42 } }) // → 42
+ * ```
+ */
+export function useDotAccessOperator(
+    name: string,
+    get: (name: string) => any,
+    object: any,
+    type: 'unescaped' | 'single-quoted'
+)
diff --git a/dist/esm/filtrex.mjs b/dist/esm/filtrex.mjs
@@ -118,6 +118,46 @@ const std =
 parser.yy = Object.create(std)
 
 
+/**
+ * A custom prop function which treats dots inside a symbol
+ * as property accessors. If you want to use the `foo.bar`
+ * syntax to access properties instead of the default
+ * `bar of foo`, you can use this function using the following
+ * code:
+ * ```
+ * import {
+ *   compileExpression,
+ *   useDotAccessOperator
+ * } from 'filtrex'
+ *
+ * const expr = "foo.bar"
+ *
+ * const fn = compileExpression(expr, {
+ *   customProp: useDotAccessOperator
+ * });
+ *
+ * fn({ foo: { bar: 42 } }) // → 42
+ * ```
+ */
+export function useDotAccessOperator(name, get, obj, type) {
+    // ignore dots inside escaped symbol
+    if (type === 'single-quoted')
+        return get(name)
+
+
+    const parts = name.split('.')
+
+    for (const propertyName of parts) {
+        if (hasOwnProperty(obj ?? {}, propertyName)) {
+            obj = obj[propertyName]
+        } else {
+            throw new UnknownPropertyError(propertyName)
+        }
+    }
+
+    return obj
+}
+
 
 /**
  * A simple, safe, JavaScript expression engine, allowing end-users to enter arbitrary expressions without p0wning you.
@@ -251,7 +291,7 @@ export function compileExpression(expression, options) {
 
     // Metaprogramming functions
 
-    function nakedProp(name, obj) {
+    function nakedProp(name, obj, type) {
         if (hasOwnProperty(obj ?? {}, name))
             return obj[name]
 
@@ -268,7 +308,7 @@ export function compileExpression(expression, options) {
     }
 
     if (typeof customProp === 'function') {
-        nakedProp = (name, obj) => customProp(name, safeGetter(obj), obj)
+        nakedProp = (name, obj, type) => customProp(name, safeGetter(obj), obj, type)
     }
 
     function createCall(fns) {
@@ -284,7 +324,7 @@ export function compileExpression(expression, options) {
         if (type === 'unescaped' && hasOwnProperty(constants, name))
             return constants[name]
 
-        return nakedProp(name, obj)
+        return nakedProp(name, obj, type)
     }
 
 

diff --git a/src/filtrex.d.ts b/src/filtrex.d.ts
@@ -106,7 +106,8 @@ export interface Options
     customProp?: (
         name: string,
         get: (name: string) => any,
-        object: any
+        object: any,
+        type: 'unescaped' | 'single-quoted'
     ) => any
 
     /**
@@ -134,3 +135,31 @@ export interface Operators {
 
     '~='?: (a: any, b: any) => boolean
 }
+
+/**
+ * A custom prop function which treats dots inside a symbol
+ * as property accessors. If you want to use the `foo.bar`
+ * syntax to access properties instead of the default
+ * `bar of foo`, you can use this function using the following
+ * code:
+ * ```
+ * import {
+ *   compileExpression,
+ *   useDotAccessOperator
+ * } from 'filtrex'
+ *
+ * const expr = "foo.bar"
+ *
+ * const fn = compileExpression(expr, {
+ *   customProp: useDotAccessOperator
+ * });
+ *
+ * fn({ foo: { bar: 42 } }) // → 42
+ * ```
+ */
+export function useDotAccessOperator(
+    name: string,
+    get: (name: string) => any,
+    object: any,
+    type: 'unescaped' | 'single-quoted'
+)
diff --git a/src/filtrex.mjs b/src/filtrex.mjs
@@ -118,6 +118,46 @@ const std =
 parser.yy = Object.create(std)
 
 
+/**
+ * A custom prop function which treats dots inside a symbol
+ * as property accessors. If you want to use the `foo.bar`
+ * syntax to access properties instead of the default
+ * `bar of foo`, you can use this function using the following
+ * code:
+ * ```
+ * import {
+ *   compileExpression,
+ *   useDotAccessOperator
+ * } from 'filtrex'
+ *
+ * const expr = "foo.bar"
+ *
+ * const fn = compileExpression(expr, {
+ *   customProp: useDotAccessOperator
+ * });
+ *
+ * fn({ foo: { bar: 42 } }) // → 42
+ * ```
+ */
+export function useDotAccessOperator(name, get, obj, type) {
+    // ignore dots inside escaped symbol
+    if (type === 'single-quoted')
+        return get(name)
+
+
+    const parts = name.split('.')
+
+    for (const propertyName of parts) {
+        if (hasOwnProperty(obj ?? {}, propertyName)) {
+            obj = obj[propertyName]
+        } else {
+            throw new UnknownPropertyError(propertyName)
+        }
+    }
+
+    return obj
+}
+
 
 /**
  * A simple, safe, JavaScript expression engine, allowing end-users to enter arbitrary expressions without p0wning you.
@@ -251,7 +291,7 @@ export function compileExpression(expression, options) {
 
     // Metaprogramming functions
 
-    function nakedProp(name, obj) {
+    function nakedProp(name, obj, type) {
         if (hasOwnProperty(obj ?? {}, name))
             return obj[name]
 
@@ -268,7 +308,7 @@ export function compileExpression(expression, options) {
     }
 
     if (typeof customProp === 'function') {
-        nakedProp = (name, obj) => customProp(name, safeGetter(obj), obj)
+        nakedProp = (name, obj, type) => customProp(name, safeGetter(obj), obj, type)
     }
 
     function createCall(fns) {
@@ -284,7 +324,7 @@ export function compileExpression(expression, options) {
         if (type === 'unescaped' && hasOwnProperty(constants, name))
             return constants[name]
 
-        return nakedProp(name, obj)
+        return nakedProp(name, obj, type)
     }