Naming changes, Function is now Rpc

Author: Josema

src/api/createNodeFactory.js

@@ -12,27 +12,22 @@ export default function createNodeFactory({ encode, decode }) {
     } = {}) {
         const requests = {}
         let request_id_index = 0
-        const local_functions_id = {}
-        const local_functions = new Map()
+        const local_rpcs_id = {}
+        const local_rpcs = new Map()
         let local_function_index = 1 // 0 is reserved for the entry function used in open()
 
         const encode_params = {
-            local_functions,
-            registerLocalFunctionFromEncode,
+            local_rpcs,
+            registerLocalRpcFromEncode,
         }
 
-        function registerLocalFunction(function_id, fn) {
-            local_functions_id[function_id] = fn
-            local_functions.set(fn, function_id)
+        function registerLocalRpc(function_id, fn) {
+            local_rpcs_id[function_id] = fn
+            local_rpcs.set(fn, function_id)
             return function_id
         }
 
-        function createRemoteFunction({
-            function_id,
-            function_creator,
-            caller,
-            path,
-        }) {
+        function createRpc(function_id) {
             const makeCall = (request_id, args) => {
                 const data = [request_id, function_id]
                 if (args.length > 0) data.push(args)
@@ -62,8 +57,17 @@ export default function createNodeFactory({ encode, decode }) {
                 makeCall(0, args)
             }
 
+            return rpc
+        }
+
+        function createRemoteFunction({
+            function_id,
+            function_creator,
+            caller,
+            path,
+        }) {
             return rpcFilter({
-                rpc,
+                rpc: createRpc(function_id),
                 node,
                 function_id,
                 function_creator,
@@ -73,15 +77,15 @@ export default function createNodeFactory({ encode, decode }) {
         }
 
         function getNextLocalFunctionId() {
-            while (local_functions_id.hasOwnProperty(local_function_index)) {
+            while (local_rpcs_id.hasOwnProperty(local_function_index)) {
                 local_function_index += 1
             }
             return local_function_index
         }
 
         function open(send, fn) {
             const function_id = 0
-            if (isFunction(fn)) registerLocalFunction(function_id, fn)
+            if (isFunction(fn)) registerLocalRpc(function_id, fn)
             node.send = (msg) => send(serialize(msg))
             return createRemoteFunction({
                 function_id,
@@ -97,7 +101,7 @@ export default function createNodeFactory({ encode, decode }) {
 
             const [id, function_id] = msg
             const is_request = id > -1
-            const fn = is_request ? local_functions_id[function_id] : undefined
+            const fn = is_request ? local_rpcs_id[function_id] : undefined
 
             msg = decode(msg, {
                 createRemoteFunction,
@@ -152,8 +156,8 @@ export default function createNodeFactory({ encode, decode }) {
             return false
         }
 
-        function registerLocalFunctionFromEncode(fn) {
-            return registerLocalFunction(getNextLocalFunctionId(), fn)
+        function registerLocalRpcFromEncode(fn) {
+            return registerLocalRpc(getNextLocalFunctionId(), fn)
         }
 
         const node = {

src/index.js

@@ -6,7 +6,7 @@ import createNodeFactory from './api/createNodeFactory'
 import createStoreFactory from './api/createStoreFactory'
 import applyPatchFactory from './api/applyPatchFactory'
 
-import Function from './types/Function'
+import Rpc from './types/Rpc'
 import Primitives from './types/Primitives'
 import Delete from './types/Delete'
 import Replace from './types/Replace'
@@ -31,7 +31,7 @@ function factory() {
         if (isFunction(decode)) decoders.push(decode)
     }
 
-    addType(Function)
+    addType(Rpc)
     addType(Primitives)
     addType(Delete)
     addType(Replace)

src/types/Function.js

@@ -3,25 +3,21 @@ import { isValidToEscape, isValidToDecode } from '../util/isValid'
 import { getUniqueKey } from '../util/get'
 import { isInteger, isFunction } from '../util/is'
 
-export default function Function() {}
+export default function Rpc() {}
 
-Function.encode = function ({
-    value,
-    local_functions,
-    registerLocalFunctionFromEncode,
-}) {
+Rpc.encode = function ({ value, local_rpcs, registerLocalRpcFromEncode }) {
     if (isFunction(value)) {
-        const function_id = local_functions.has(value)
-            ? local_functions.get(value)
-            : registerLocalFunctionFromEncode(value)
+        const function_id = local_rpcs.has(value)
+            ? local_rpcs.get(value)
+            : registerLocalRpcFromEncode(value)
         return { [FUNCTION_KEY]: function_id }
     } else if (isValidToDecode({ value, key: FUNCTION_KEY })) {
         return { [ESCAPE_KEY]: value }
     }
     return value
 }
 
-Function.decode = function ({
+Rpc.decode = function ({
     value,
     createRemoteFunction,
     path,

src/types/Rpc.js

@@ -0,0 +1,44 @@
+import { ESCAPE_KEY, FUNCTION_KEY } from '../const'
+import { isValidToEscape, isValidToDecode } from '../util/isValid'
+import { getUniqueKey } from '../util/get'
+import { isInteger, isFunction } from '../util/is'
+
+export default function Rpc() {}
+
+Rpc.encode = function ({ value, local_rpcs, registerLocalRpcFromEncode }) {
+    if (isFunction(value)) {
+        const function_id = local_rpcs.has(value)
+            ? local_rpcs.get(value)
+            : registerLocalRpcFromEncode(value)
+        return { [FUNCTION_KEY]: function_id }
+    } else if (isValidToDecode({ value, key: FUNCTION_KEY })) {
+        return { [ESCAPE_KEY]: value }
+    }
+    return value
+}
+
+Rpc.decode = function ({
+    value,
+    createRemoteFunction,
+    path,
+    caller,
+    function_creator,
+}) {
+    if (
+        getUniqueKey(value) === FUNCTION_KEY &&
+        isInteger(value[FUNCTION_KEY])
+    ) {
+        return createRemoteFunction({
+            function_id: value[FUNCTION_KEY],
+            function_creator,
+            caller,
+            path: path.slice(2),
+        })
+    } else if (
+        isValidToEscape({ value }) &&
+        isValidToDecode({ value: value[ESCAPE_KEY], key: FUNCTION_KEY })
+    ) {
+        return value[ESCAPE_KEY]
+    }
+    return value
+}