npm - @comunica/bus-function-factory - Versions diffs - 3.2.4-alpha.47.0 - Mend

@comunica/bus-function-factory 3.2.4-alpha.47.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (23) hide show

package/LICENSE.txt +22 -0
package/README.md +30 -0
package/components/ActorFunctionFactory.jsonld +367 -0
package/components/ActorFunctionFactoryDedicated.jsonld +242 -0
package/components/BusFunctionFactory.jsonld +56 -0
package/components/components.jsonld +13 -0
package/components/context.jsonld +142 -0
package/lib/ActorFunctionFactory.d.ts +62 -0
package/lib/ActorFunctionFactory.js +29 -0
package/lib/ActorFunctionFactory.js.map +1 -0
package/lib/ActorFunctionFactoryDedicated.d.ts +18 -0
package/lib/ActorFunctionFactoryDedicated.js +22 -0
package/lib/ActorFunctionFactoryDedicated.js.map +1 -0
package/lib/BusFunctionFactory.d.ts +12 -0
package/lib/BusFunctionFactory.js +21 -0
package/lib/BusFunctionFactory.js.map +1 -0
package/lib/implementation/Core.d.ts +46 -0
package/lib/implementation/Core.js +61 -0
package/lib/implementation/Core.js.map +1 -0
package/lib/index.d.ts +4 -0
package/lib/index.js +21 -0
package/lib/index.js.map +1 -0
package/package.json +46 -0

package/LICENSE.txt ADDED Viewed

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+Copyright © 2017–now Ruben Taelman, Joachim Van Herwegen
+Comunica Association and Ghent University – imec, Belgium
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md ADDED Viewed

@@ -0,0 +1,30 @@
+# Comunica Bus Function Factory
+[![npm version](https://badge.fury.io/js/%40comunica%2Fbus-function-factory.svg)](https://www.npmjs.com/package/@comunica/bus-function-factory)
+A comunica bus for function factory events.
+This module is part of the [Comunica framework](https://github.com/comunica/comunica),
+and should only be used by [developers that want to build their own query engine](https://comunica.dev/docs/modify/).
+[Click here if you just want to query with Comunica](https://comunica.dev/docs/query/).
+## Install
+```bash
+$ yarn add @comunica/bus-function-factory
+```
+## Usage
+## Bus usage
+* **Context**: `"https://linkedsoftwaredependencies.org/bundles/npm/@comunica/bus-function-factory/^1.0.0/components/context.jsonld"`
+* **Bus name**: `ActorFunctionFactory:_default_bus`
+When a mediator is required, the argument should get the `MediatorFunctionFactoryUnsafe` and manually cast it to `MediatorFunctionFactory`.
+We require this work around because Components.js does not support the complex type of MediatorFunctions.
+## Creating actors on this bus
+Actors extending [`ActorFunctionFactory`](TODO:jsdoc_url) are automatically subscribed to this bus.

package/components/ActorFunctionFactory.jsonld ADDED Viewed

@@ -0,0 +1,367 @@
+{
+  "@context": [
+    "https://linkedsoftwaredependencies.org/bundles/npm/@comunica/bus-function-factory/^3.0.0/components/context.jsonld",
+    "https://linkedsoftwaredependencies.org/bundles/npm/@comunica/core/^3.0.0/components/context.jsonld"
+  ],
+  "@id": "npmd:@comunica/bus-function-factory",
+  "components": [
+    {
+      "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory",
+      "@type": "AbstractClass",
+      "requireElement": "ActorFunctionFactory",
+      "extends": [
+        {
+          "@type": "GenericComponentExtension",
+          "component": "cc:components/Actor.jsonld#Actor",
+          "genericTypeInstances": [
+            "cbff:components/ActorFunctionFactory.jsonld#IActionFunctionFactory",
+            "cc:components/Actor.jsonld#IActorTest",
+            "cbff:components/ActorFunctionFactory.jsonld#IActorFunctionFactoryOutput",
+            {
+              "@type": "ParameterRangeGenericTypeReference",
+              "parameterRangeGenericType": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory__generic_TS"
+            }
+          ]
+        }
+      ],
+      "comment": "A comunica actor for function factory events.  Actor types: * Input:  IActionFunctions: A request to receive a function implementation for a given function name and potentially the function arguments. * Test:   <none> * Output: IActorFunctionsOutput: A function implementation.",
+      "genericTypeParameters": [
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory__generic_TS",
+          "default": {
+            "@type": "ParameterRangeUndefined"
+          }
+        }
+      ],
+      "parameters": [
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_args_name",
+          "range": "xsd:string",
+          "default": {
+            "@id": "rdf:subject"
+          },
+          "comment": "The name for this actor."
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_args_bus",
+          "range": {
+            "@type": "ParameterRangeGenericComponent",
+            "component": "cc:components/Bus.jsonld#Bus",
+            "genericTypeInstances": [
+              {
+                "@type": "ParameterRangeGenericComponent",
+                "component": "cc:components/Actor.jsonld#Actor",
+                "genericTypeInstances": [
+                  {
+                    "@type": "ParameterRangeGenericTypeReference",
+                    "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_I"
+                  },
+                  {
+                    "@type": "ParameterRangeGenericTypeReference",
+                    "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_T"
+                  },
+                  {
+                    "@type": "ParameterRangeGenericTypeReference",
+                    "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_O"
+                  },
+                  {
+                    "@type": "ParameterRangeGenericTypeReference",
+                    "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_TS"
+                  }
+                ]
+              },
+              {
+                "@type": "ParameterRangeGenericTypeReference",
+                "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_I"
+              },
+              {
+                "@type": "ParameterRangeGenericTypeReference",
+                "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_T"
+              },
+              {
+                "@type": "ParameterRangeGenericTypeReference",
+                "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_O"
+              },
+              {
+                "@type": "ParameterRangeGenericTypeReference",
+                "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_TS"
+              }
+            ]
+          },
+          "default": {
+            "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_default_bus",
+            "@type": "cbff:components/BusFunctionFactory.jsonld#BusFunctionFactory"
+          },
+          "comment": "The bus this actor subscribes to."
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_args_busFailMessage",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              "xsd:string",
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          },
+          "comment": "The message that will be configured in the bus for reporting failures.  This message may be a template string that contains references to the executed `action`. For example, the following templated string is allowed: \"RDF dereferencing failed: no actors could handle ${action.handle.mediaType}\""
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_args_beforeActors",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              {
+                "@type": "ParameterRangeArray",
+                "parameterRangeValue": {
+                  "@type": "ParameterRangeGenericComponent",
+                  "component": "cc:components/Actor.jsonld#Actor",
+                  "genericTypeInstances": [
+                    {
+                      "@type": "ParameterRangeGenericTypeReference",
+                      "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_I"
+                    },
+                    {
+                      "@type": "ParameterRangeGenericTypeReference",
+                      "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_T"
+                    },
+                    {
+                      "@type": "ParameterRangeGenericTypeReference",
+                      "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_O"
+                    },
+                    {
+                      "@type": "ParameterRangeGenericTypeReference",
+                      "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_TS"
+                    }
+                  ]
+                }
+              },
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          },
+          "comment": "Actor that must be registered in the bus before this actor."
+        }
+      ],
+      "memberFields": [
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory__member_constructor",
+          "memberFieldName": "constructor"
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory__member_run",
+          "memberFieldName": "run"
+        }
+      ],
+      "constructorArguments": [
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_args__constructorArgument",
+          "fields": [
+            {
+              "keyRaw": "name",
+              "value": {
+                "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_args_name"
+              }
+            },
+            {
+              "keyRaw": "bus",
+              "value": {
+                "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_args_bus"
+              }
+            },
+            {
+              "keyRaw": "busFailMessage",
+              "value": {
+                "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_args_busFailMessage"
+              }
+            },
+            {
+              "keyRaw": "beforeActors",
+              "value": {
+                "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_args_beforeActors"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "@id": "cbff:components/ActorFunctionFactory.jsonld#MediatorFunctionFactory",
+      "@type": "AbstractClass",
+      "requireElement": "MediatorFunctionFactory",
+      "extends": [
+        {
+          "@type": "GenericComponentExtension",
+          "component": "cc:components/Mediator.jsonld#Mediator",
+          "genericTypeInstances": [
+            {
+              "@type": "ParameterRangeGenericComponent",
+              "component": "cc:components/Actor.jsonld#Actor",
+              "genericTypeInstances": [
+                "cbff:components/ActorFunctionFactory.jsonld#IActionFunctionFactory",
+                "cc:components/Actor.jsonld#IActorTest",
+                "cbff:components/ActorFunctionFactory.jsonld#IActorFunctionFactoryOutput"
+              ]
+            },
+            "cbff:components/ActorFunctionFactory.jsonld#IActionFunctionFactory",
+            "cc:components/Actor.jsonld#IActorTest",
+            "cbff:components/ActorFunctionFactory.jsonld#IActorFunctionFactoryOutput"
+          ]
+        }
+      ],
+      "parameters": [
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#MediatorFunctionFactory_args_name",
+          "range": "xsd:string",
+          "default": {
+            "@id": "rdf:subject"
+          },
+          "comment": "The name for this mediator."
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#MediatorFunctionFactory_args_bus",
+          "range": {
+            "@type": "ParameterRangeGenericComponent",
+            "component": "cc:components/Bus.jsonld#Bus",
+            "genericTypeInstances": [
+              {
+                "@type": "ParameterRangeGenericTypeReference",
+                "parameterRangeGenericType": "npmd:@comunica/core/^3.0.0/components/Mediator.jsonld#Mediator__generic_A"
+              },
+              {
+                "@type": "ParameterRangeGenericTypeReference",
+                "parameterRangeGenericType": "npmd:@comunica/core/^3.0.0/components/Mediator.jsonld#Mediator__generic_I"
+              },
+              {
+                "@type": "ParameterRangeGenericTypeReference",
+                "parameterRangeGenericType": "npmd:@comunica/core/^3.0.0/components/Mediator.jsonld#Mediator__generic_T"
+              },
+              {
+                "@type": "ParameterRangeGenericTypeReference",
+                "parameterRangeGenericType": "npmd:@comunica/core/^3.0.0/components/Mediator.jsonld#Mediator__generic_O"
+              },
+              {
+                "@type": "ParameterRangeGenericTypeReference",
+                "parameterRangeGenericType": "npmd:@comunica/core/^3.0.0/components/Mediator.jsonld#Mediator__generic_TS"
+              }
+            ]
+          },
+          "comment": "The bus this mediator will mediate over."
+        }
+      ],
+      "memberFields": [
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#MediatorFunctionFactory__member_mediate",
+          "memberFieldName": "mediate",
+          "range": {
+            "@type": "ParameterRangeWildcard"
+          }
+        }
+      ],
+      "constructorArguments": [
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#MediatorFunctionFactory_args__constructorArgument",
+          "fields": [
+            {
+              "keyRaw": "name",
+              "value": {
+                "@id": "cbff:components/ActorFunctionFactory.jsonld#MediatorFunctionFactory_args_name"
+              }
+            },
+            {
+              "keyRaw": "bus",
+              "value": {
+                "@id": "cbff:components/ActorFunctionFactory.jsonld#MediatorFunctionFactory_args_bus"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "@id": "cbff:components/ActorFunctionFactory.jsonld#IExpressionFunction",
+      "@type": "AbstractClass",
+      "requireElement": "IExpressionFunction",
+      "parameters": [],
+      "memberFields": [
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#IExpressionFunction__member_apply",
+          "memberFieldName": "apply"
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#IExpressionFunction__member_checkArity",
+          "memberFieldName": "checkArity"
+        }
+      ],
+      "constructorArguments": []
+    },
+    {
+      "@id": "cbff:components/ActorFunctionFactory.jsonld#ITermFunction",
+      "@type": "AbstractClass",
+      "requireElement": "ITermFunction",
+      "extends": [
+        "cbff:components/ActorFunctionFactory.jsonld#IExpressionFunction"
+      ],
+      "parameters": [],
+      "memberFields": [
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#ITermFunction__member_supportsTermExpressions",
+          "memberFieldName": "supportsTermExpressions"
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#ITermFunction__member_applyOnTerms",
+          "memberFieldName": "applyOnTerms"
+        }
+      ],
+      "constructorArguments": []
+    },
+    {
+      "@id": "cbff:components/ActorFunctionFactory.jsonld#IActionFunctionFactory",
+      "@type": "AbstractClass",
+      "requireElement": "IActionFunctionFactory",
+      "extends": [
+        "cc:components/Actor.jsonld#IAction"
+      ],
+      "parameters": [],
+      "memberFields": [
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#IActionFunctionFactory__member_functionName",
+          "memberFieldName": "functionName"
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#IActionFunctionFactory__member_arguments",
+          "memberFieldName": "arguments"
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactory.jsonld#IActionFunctionFactory__member_requireTermExpression",
+          "memberFieldName": "requireTermExpression"
+        }
+      ],
+      "constructorArguments": []
+    },
+    {
+      "@id": "cbff:components/ActorFunctionFactory.jsonld#IActorFunctionFactoryOutput",
+      "@type": "AbstractClass",
+      "requireElement": "IActorFunctionFactoryOutput",
+      "extends": [
+        "cc:components/Actor.jsonld#IActorOutput",
+        "cbff:components/ActorFunctionFactory.jsonld#IExpressionFunction"
+      ],
+      "parameters": [],
+      "constructorArguments": []
+    },
+    {
+      "@id": "cbff:components/ActorFunctionFactory.jsonld#IActorFunctionFactoryOutputTerm",
+      "@type": "AbstractClass",
+      "requireElement": "IActorFunctionFactoryOutputTerm",
+      "extends": [
+        "cc:components/Actor.jsonld#IActorOutput",
+        "cbff:components/ActorFunctionFactory.jsonld#ITermFunction"
+      ],
+      "parameters": [],
+      "constructorArguments": []
+    }
+  ]
+}

package/components/ActorFunctionFactoryDedicated.jsonld ADDED Viewed

@@ -0,0 +1,242 @@
+{
+  "@context": [
+    "https://linkedsoftwaredependencies.org/bundles/npm/@comunica/bus-function-factory/^3.0.0/components/context.jsonld",
+    "https://linkedsoftwaredependencies.org/bundles/npm/@comunica/core/^3.0.0/components/context.jsonld"
+  ],
+  "@id": "npmd:@comunica/bus-function-factory",
+  "components": [
+    {
+      "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated",
+      "@type": "AbstractClass",
+      "requireElement": "ActorFunctionFactoryDedicated",
+      "extends": [
+        "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory"
+      ],
+      "comment": "A base implementation for function factory actors for a dedicated operator.",
+      "parameters": [
+        {
+          "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_functionNames",
+          "range": {
+            "@type": "ParameterRangeTuple",
+            "parameterRangeElements": [
+              "xsd:string",
+              {
+                "@type": "ParameterRangeRest",
+                "parameterRangeValue": {
+                  "@type": "ParameterRangeArray",
+                  "parameterRangeValue": "xsd:string"
+                }
+              }
+            ]
+          }
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_termFunction",
+          "range": "xsd:boolean"
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_name",
+          "range": "xsd:string",
+          "default": {
+            "@id": "rdf:subject"
+          },
+          "comment": "The name for this actor."
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_bus",
+          "range": {
+            "@type": "ParameterRangeGenericComponent",
+            "component": "cc:components/Bus.jsonld#Bus",
+            "genericTypeInstances": [
+              {
+                "@type": "ParameterRangeGenericComponent",
+                "component": "cc:components/Actor.jsonld#Actor",
+                "genericTypeInstances": [
+                  {
+                    "@type": "ParameterRangeGenericTypeReference",
+                    "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_I"
+                  },
+                  {
+                    "@type": "ParameterRangeGenericTypeReference",
+                    "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_T"
+                  },
+                  {
+                    "@type": "ParameterRangeGenericTypeReference",
+                    "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_O"
+                  },
+                  {
+                    "@type": "ParameterRangeGenericTypeReference",
+                    "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_TS"
+                  }
+                ]
+              },
+              {
+                "@type": "ParameterRangeGenericTypeReference",
+                "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_I"
+              },
+              {
+                "@type": "ParameterRangeGenericTypeReference",
+                "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_T"
+              },
+              {
+                "@type": "ParameterRangeGenericTypeReference",
+                "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_O"
+              },
+              {
+                "@type": "ParameterRangeGenericTypeReference",
+                "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_TS"
+              }
+            ]
+          },
+          "default": {
+            "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_default_bus",
+            "@type": "cbff:components/BusFunctionFactory.jsonld#BusFunctionFactory"
+          },
+          "comment": "The bus this actor subscribes to."
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_busFailMessage",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              "xsd:string",
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          },
+          "comment": "The message that will be configured in the bus for reporting failures.  This message may be a template string that contains references to the executed `action`. For example, the following templated string is allowed: \"RDF dereferencing failed: no actors could handle ${action.handle.mediaType}\""
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_beforeActors",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              {
+                "@type": "ParameterRangeArray",
+                "parameterRangeValue": {
+                  "@type": "ParameterRangeGenericComponent",
+                  "component": "cc:components/Actor.jsonld#Actor",
+                  "genericTypeInstances": [
+                    {
+                      "@type": "ParameterRangeGenericTypeReference",
+                      "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_I"
+                    },
+                    {
+                      "@type": "ParameterRangeGenericTypeReference",
+                      "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_T"
+                    },
+                    {
+                      "@type": "ParameterRangeGenericTypeReference",
+                      "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_O"
+                    },
+                    {
+                      "@type": "ParameterRangeGenericTypeReference",
+                      "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^3.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_TS"
+                    }
+                  ]
+                }
+              },
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          },
+          "comment": "Actor that must be registered in the bus before this actor."
+        }
+      ],
+      "memberFields": [
+        {
+          "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated__member_functionNames",
+          "memberFieldName": "functionNames",
+          "range": {
+            "@type": "ParameterRangeTuple",
+            "parameterRangeElements": [
+              "xsd:string",
+              {
+                "@type": "ParameterRangeRest",
+                "parameterRangeValue": {
+                  "@type": "ParameterRangeArray",
+                  "parameterRangeValue": "xsd:string"
+                }
+              }
+            ]
+          }
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated__member_termFunction",
+          "memberFieldName": "termFunction",
+          "range": "xsd:boolean"
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated__member_constructor",
+          "memberFieldName": "constructor"
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated__member_test",
+          "memberFieldName": "test"
+        }
+      ],
+      "constructorArguments": [
+        {
+          "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args__constructorArgument",
+          "fields": [
+            {
+              "keyRaw": "functionNames",
+              "value": {
+                "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_functionNames"
+              }
+            },
+            {
+              "keyRaw": "termFunction",
+              "value": {
+                "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_termFunction"
+              }
+            },
+            {
+              "keyRaw": "name",
+              "value": {
+                "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_name"
+              }
+            },
+            {
+              "keyRaw": "bus",
+              "value": {
+                "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_bus"
+              }
+            },
+            {
+              "keyRaw": "busFailMessage",
+              "value": {
+                "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_busFailMessage"
+              }
+            },
+            {
+              "keyRaw": "beforeActors",
+              "value": {
+                "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_beforeActors"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#IActorFunctionFactoryDedicatedArgs",
+      "@type": "AbstractClass",
+      "requireElement": "IActorFunctionFactoryDedicatedArgs",
+      "parameters": [],
+      "memberFields": [
+        {
+          "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#IActorFunctionFactoryDedicatedArgs__member_functionNames",
+          "memberFieldName": "functionNames"
+        },
+        {
+          "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#IActorFunctionFactoryDedicatedArgs__member_termFunction",
+          "memberFieldName": "termFunction"
+        }
+      ],
+      "constructorArguments": []
+    }
+  ]
+}

package/components/BusFunctionFactory.jsonld ADDED Viewed

@@ -0,0 +1,56 @@
+{
+  "@context": [
+    "https://linkedsoftwaredependencies.org/bundles/npm/@comunica/bus-function-factory/^3.0.0/components/context.jsonld",
+    "https://linkedsoftwaredependencies.org/bundles/npm/@comunica/core/^3.0.0/components/context.jsonld"
+  ],
+  "@id": "npmd:@comunica/bus-function-factory",
+  "components": [
+    {
+      "@id": "cbff:components/BusFunctionFactory.jsonld#BusFunctionFactory",
+      "@type": "Class",
+      "requireElement": "BusFunctionFactory",
+      "extends": [
+        {
+          "@type": "GenericComponentExtension",
+          "component": "cc:components/BusIndexed.jsonld#BusIndexed",
+          "genericTypeInstances": [
+            "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory",
+            "cbff:components/ActorFunctionFactory.jsonld#IActionFunctionFactory",
+            "cc:components/Actor.jsonld#IActorTest",
+            "cbff:components/ActorFunctionFactory.jsonld#IActorFunctionFactoryOutput"
+          ]
+        }
+      ],
+      "comment": "Bus inspired by BusIndexed but specific for function factory.  The implementation differs. In BusIndexed, each actor is indexed only once. Here, a single actor can be indexed multiple times (max 2).",
+      "parameters": [
+        {
+          "@id": "cbff:components/BusFunctionFactory.jsonld#BusFunctionFactory_args_name",
+          "range": "xsd:string",
+          "default": {
+            "@id": "rdf:subject"
+          },
+          "comment": "The name for this bus."
+        }
+      ],
+      "memberFields": [
+        {
+          "@id": "cbff:components/BusFunctionFactory.jsonld#BusFunctionFactory__member_constructor",
+          "memberFieldName": "constructor"
+        }
+      ],
+      "constructorArguments": [
+        {
+          "@id": "cbff:components/BusFunctionFactory.jsonld#BusFunctionFactory_args__constructorArgument",
+          "fields": [
+            {
+              "keyRaw": "name",
+              "value": {
+                "@id": "cbff:components/BusFunctionFactory.jsonld#BusFunctionFactory_args_name"
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

package/components/components.jsonld ADDED Viewed

@@ -0,0 +1,13 @@
+{
+  "@context": [
+    "https://linkedsoftwaredependencies.org/bundles/npm/@comunica/bus-function-factory/^3.0.0/components/context.jsonld"
+  ],
+  "@id": "npmd:@comunica/bus-function-factory",
+  "@type": "Module",
+  "requireName": "@comunica/bus-function-factory",
+  "import": [
+    "cbff:components/ActorFunctionFactory.jsonld",
+    "cbff:components/ActorFunctionFactoryDedicated.jsonld",
+    "cbff:components/BusFunctionFactory.jsonld"
+  ]
+}

package/components/context.jsonld ADDED Viewed

@@ -0,0 +1,142 @@
+{
+  "@context": [
+    "https://linkedsoftwaredependencies.org/bundles/npm/componentsjs/^6.0.0/components/context.jsonld",
+    {
+      "npmd": "https://linkedsoftwaredependencies.org/bundles/npm/",
+      "cbff": "npmd:@comunica/bus-function-factory/^3.0.0/",
+      "ActorFunctionFactory": {
+        "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory",
+        "@prefix": true,
+        "@context": {
+          "args_name": {
+            "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_args_name"
+          },
+          "args_bus": {
+            "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_args_bus"
+          },
+          "args_busFailMessage": {
+            "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_args_busFailMessage"
+          },
+          "args_beforeActors": {
+            "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_args_beforeActors",
+            "@container": "@list"
+          },
+          "name": {
+            "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_args_name"
+          },
+          "bus": {
+            "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_args_bus"
+          },
+          "busFailMessage": {
+            "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_args_busFailMessage"
+          },
+          "beforeActors": {
+            "@id": "cbff:components/ActorFunctionFactory.jsonld#ActorFunctionFactory_args_beforeActors",
+            "@container": "@list"
+          }
+        }
+      },
+      "MediatorFunctionFactory": {
+        "@id": "cbff:components/ActorFunctionFactory.jsonld#MediatorFunctionFactory",
+        "@prefix": true,
+        "@context": {
+          "args_name": {
+            "@id": "cbff:components/ActorFunctionFactory.jsonld#MediatorFunctionFactory_args_name"
+          },
+          "args_bus": {
+            "@id": "cbff:components/ActorFunctionFactory.jsonld#MediatorFunctionFactory_args_bus"
+          },
+          "name": {
+            "@id": "cbff:components/ActorFunctionFactory.jsonld#MediatorFunctionFactory_args_name"
+          },
+          "bus": {
+            "@id": "cbff:components/ActorFunctionFactory.jsonld#MediatorFunctionFactory_args_bus"
+          }
+        }
+      },
+      "IExpressionFunction": {
+        "@id": "cbff:components/ActorFunctionFactory.jsonld#IExpressionFunction",
+        "@prefix": true,
+        "@context": {}
+      },
+      "ITermFunction": {
+        "@id": "cbff:components/ActorFunctionFactory.jsonld#ITermFunction",
+        "@prefix": true,
+        "@context": {}
+      },
+      "IActionFunctionFactory": {
+        "@id": "cbff:components/ActorFunctionFactory.jsonld#IActionFunctionFactory",
+        "@prefix": true,
+        "@context": {}
+      },
+      "IActorFunctionFactoryOutput": {
+        "@id": "cbff:components/ActorFunctionFactory.jsonld#IActorFunctionFactoryOutput",
+        "@prefix": true,
+        "@context": {}
+      },
+      "IActorFunctionFactoryOutputTerm": {
+        "@id": "cbff:components/ActorFunctionFactory.jsonld#IActorFunctionFactoryOutputTerm",
+        "@prefix": true,
+        "@context": {}
+      },
+      "ActorFunctionFactoryDedicated": {
+        "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated",
+        "@prefix": true,
+        "@context": {
+          "args_functionNames": {
+            "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_functionNames"
+          },
+          "args_termFunction": {
+            "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_termFunction"
+          },
+          "args_name": {
+            "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_name"
+          },
+          "args_bus": {
+            "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_bus"
+          },
+          "args_busFailMessage": {
+            "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_busFailMessage"
+          },
+          "args_beforeActors": {
+            "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_beforeActors",
+            "@container": "@list"
+          },
+          "functionNames": {
+            "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_functionNames"
+          },
+          "termFunction": {
+            "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_termFunction"
+          },
+          "name": {
+            "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_name"
+          },
+          "bus": {
+            "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_bus"
+          },
+          "busFailMessage": {
+            "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_busFailMessage"
+          },
+          "beforeActors": {
+            "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#ActorFunctionFactoryDedicated_args_beforeActors",
+            "@container": "@list"
+          }
+        }
+      },
+      "IActorFunctionFactoryDedicatedArgs": {
+        "@id": "cbff:components/ActorFunctionFactoryDedicated.jsonld#IActorFunctionFactoryDedicatedArgs",
+        "@prefix": true,
+        "@context": {}
+      },
+      "BusFunctionFactory": {
+        "@id": "cbff:components/BusFunctionFactory.jsonld#BusFunctionFactory",
+        "@prefix": true,
+        "@context": {
+          "args_name": {
+            "@id": "cbff:components/BusFunctionFactory.jsonld#BusFunctionFactory_args_name"
+          }
+        }
+      }
+    }
+  ]
+}

package/lib/ActorFunctionFactory.d.ts ADDED Viewed

@@ -0,0 +1,62 @@
+import type { IAction, IActorArgs, IActorOutput, IActorTest, Mediate } from '@comunica/core';
+import { Actor, Mediator } from '@comunica/core';
+import type { Expression, IEvalContext, IInternalEvaluator, TermExpression } from '@comunica/types';
+import type { Algebra as Alg } from 'sparqlalgebrajs';
+/**
+ * A comunica actor for function factory events.
+ *
+ * Actor types:
+ * * Input:  IActionFunctions: A request to receive a function implementation for a given function name
+ * and potentially the function arguments.
+ * * Test:   <none>
+ * * Output: IActorFunctionsOutput: A function implementation.
+ *
+ * @see IActionFunctionFactory
+ * @see IActorFunctionFactoryOutput
+ */
+export declare abstract class ActorFunctionFactory<TS = undefined> extends Actor<IActionFunctionFactory, IActorTest, IActorFunctionFactoryOutput, TS> {
+    /**
+     * @param args - @defaultNested {<default_bus> a <cbff:components/BusFunctionFactory.jsonld#BusFunctionFactory>} bus
+     */
+    constructor(args: IActorFunctionFactoryArgs<TS>);
+    abstract run<T extends IActionFunctionFactory>(action: T): Promise<T extends {
+        requireTermExpression: true;
+    } ? IActorFunctionFactoryOutputTerm : IActorFunctionFactoryOutput>;
+}
+export interface IExpressionFunction {
+    apply: (evalContext: IEvalContext) => Promise<TermExpression>;
+    /**
+     * The arity of the function will be checked when parsing and preparing a function.
+     * This allows us to check if the query is correct even before we process any bindings.
+     */
+    checkArity: (args: Expression[]) => boolean;
+}
+export interface ITermFunction extends IExpressionFunction {
+    supportsTermExpressions: true;
+    applyOnTerms: (args: TermExpression[], exprEval: IInternalEvaluator) => TermExpression;
+}
+export interface IActionFunctionFactory extends IAction {
+    /**
+     * The name of the function to retrieve. Can be any string, a function name, or a URL.
+     */
+    functionName: string;
+    /**
+     * The arguments of the function, if they are known, and don't change.
+     */
+    arguments?: Alg.Expression[];
+    /**
+     * Whether the function should return a term expression.
+     */
+    requireTermExpression?: boolean;
+}
+export interface IActorFunctionFactoryOutput extends IActorOutput, IExpressionFunction {
+}
+export interface IActorFunctionFactoryOutputTerm extends IActorOutput, ITermFunction {
+}
+export type IActorFunctionFactoryArgs<TS = undefined> = IActorArgs<IActionFunctionFactory, IActorTest, IActorFunctionFactoryOutput, TS>;
+export type MediatorFunctionFactoryUnsafe = Mediate<IActionFunctionFactory, IActorFunctionFactoryOutput>;
+export declare abstract class MediatorFunctionFactory extends Mediator<Actor<IActionFunctionFactory, IActorTest, IActorFunctionFactoryOutput>, IActionFunctionFactory, IActorTest, IActorFunctionFactoryOutput> {
+    abstract mediate: <T extends IActionFunctionFactory>(action: T) => Promise<T extends {
+        requireTermExpression: true;
+    } ? IActorFunctionFactoryOutputTerm : IActorFunctionFactoryOutput>;
+}

package/lib/ActorFunctionFactory.js ADDED Viewed

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediatorFunctionFactory = exports.ActorFunctionFactory = void 0;
+const core_1 = require("@comunica/core");
+/**
+ * A comunica actor for function factory events.
+ *
+ * Actor types:
+ * * Input:  IActionFunctions: A request to receive a function implementation for a given function name
+ * and potentially the function arguments.
+ * * Test:   <none>
+ * * Output: IActorFunctionsOutput: A function implementation.
+ *
+ * @see IActionFunctionFactory
+ * @see IActorFunctionFactoryOutput
+ */
+class ActorFunctionFactory extends core_1.Actor {
+    /**
+     * @param args - @defaultNested {<default_bus> a <cbff:components/BusFunctionFactory.jsonld#BusFunctionFactory>} bus
+     */
+    constructor(args) {
+        super(args);
+    }
+}
+exports.ActorFunctionFactory = ActorFunctionFactory;
+class MediatorFunctionFactory extends core_1.Mediator {
+}
+exports.MediatorFunctionFactory = MediatorFunctionFactory;
+//# sourceMappingURL=ActorFunctionFactory.js.map

package/lib/ActorFunctionFactory.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"ActorFunctionFactory.js","sourceRoot":"","sources":["ActorFunctionFactory.ts"],"names":[],"mappings":";;;AACA,yCAAiD;AAIjD;;;;;;;;;;;GAWG;AACH,MAAsB,oBAAqC,SACzD,YAA0E;IAC1E;;OAEG;IACH,YAAmB,IAAmC;QACpD,KAAK,CAAC,IAAI,CAAC,CAAC;IACd,CAAC;CAIF;AAXD,oDAWC;AA2CD,MAAsB,uBAAwB,SAAQ,eAKrD;CAGA;AARD,0DAQC","sourcesContent":["import type { IAction, IActorArgs, IActorOutput, IActorTest, Mediate } from '@comunica/core';\nimport { Actor, Mediator } from '@comunica/core';\nimport type { Expression, IEvalContext, IInternalEvaluator, TermExpression } from '@comunica/types';\nimport type { Algebra as Alg } from 'sparqlalgebrajs';\n\n/**\n * A comunica actor for function factory events.\n *\n * Actor types:\n * * Input: IActionFunctions: A request to receive a function implementation for a given function name\n * and potentially the function arguments.\n * * Test: <none>\n * * Output: IActorFunctionsOutput: A function implementation.\n *\n * @see IActionFunctionFactory\n * @see IActorFunctionFactoryOutput\n */\nexport abstract class ActorFunctionFactory<TS = undefined> extends\n Actor<IActionFunctionFactory, IActorTest, IActorFunctionFactoryOutput, TS> {\n /**\n * @param args - @defaultNested {<default_bus> a <cbff:components/BusFunctionFactory.jsonld#BusFunctionFactory>} bus\n */\n public constructor(args: IActorFunctionFactoryArgs<TS>) {\n super(args);\n }\n\n public abstract override run<T extends IActionFunctionFactory>(action: T):\n Promise<T extends { requireTermExpression: true } ? IActorFunctionFactoryOutputTerm : IActorFunctionFactoryOutput>;\n}\n\nexport interface IExpressionFunction {\n apply: (evalContext: IEvalContext) => Promise<TermExpression>;\n /**\n * The arity of the function will be checked when parsing and preparing a function.\n * This allows us to check if the query is correct even before we process any bindings.\n */\n checkArity: (args: Expression[]) => boolean;\n}\n\nexport interface ITermFunction extends IExpressionFunction {\n supportsTermExpressions: true;\n applyOnTerms: (args: TermExpression[], exprEval: IInternalEvaluator) => TermExpression;\n}\nexport interface IActionFunctionFactory extends IAction {\n /**\n * The name of the function to retrieve. Can be any string, a function name, or a URL.\n */\n functionName: string;\n /**\n * The arguments of the function, if they are known, and don't change.\n */\n arguments?: Alg.Expression[];\n /**\n * Whether the function should return a term expression.\n */\n requireTermExpression?: boolean;\n}\n\nexport interface IActorFunctionFactoryOutput extends IActorOutput, IExpressionFunction {}\n\nexport interface IActorFunctionFactoryOutputTerm extends IActorOutput, ITermFunction {}\n\nexport type IActorFunctionFactoryArgs<TS = undefined> = IActorArgs<\nIActionFunctionFactory,\nIActorTest,\nIActorFunctionFactoryOutput,\nTS\n>;\n\nexport type MediatorFunctionFactoryUnsafe = Mediate<IActionFunctionFactory, IActorFunctionFactoryOutput>;\n\nexport abstract class MediatorFunctionFactory extends Mediator<\nActor<IActionFunctionFactory, IActorTest, IActorFunctionFactoryOutput>,\nIActionFunctionFactory,\nIActorTest,\nIActorFunctionFactoryOutput\n> {\n public abstract override mediate: <T extends IActionFunctionFactory>(action: T) =>\n Promise<T extends { requireTermExpression: true } ? IActorFunctionFactoryOutputTerm : IActorFunctionFactoryOutput>;\n}\n"]}

package/lib/ActorFunctionFactoryDedicated.d.ts ADDED Viewed

@@ -0,0 +1,18 @@
+import type { IActorTest, TestResult } from '@comunica/core';
+import type { IActionFunctionFactory, IActorFunctionFactoryArgs } from './ActorFunctionFactory';
+import { ActorFunctionFactory } from './ActorFunctionFactory';
+type StringArray = [string, ...string[]];
+/**
+ * A base implementation for function factory actors for a dedicated operator.
+ */
+export declare abstract class ActorFunctionFactoryDedicated extends ActorFunctionFactory {
+    readonly functionNames: StringArray;
+    readonly termFunction: boolean;
+    protected constructor(args: IActorFunctionFactoryDedicatedArgs);
+    test(action: IActionFunctionFactory): Promise<TestResult<IActorTest>>;
+}
+export interface IActorFunctionFactoryDedicatedArgs extends IActorFunctionFactoryArgs {
+    functionNames: StringArray;
+    termFunction: boolean;
+}
+export {};

package/lib/ActorFunctionFactoryDedicated.js ADDED Viewed

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActorFunctionFactoryDedicated = void 0;
+const core_1 = require("@comunica/core");
+const ActorFunctionFactory_1 = require("./ActorFunctionFactory");
+/**
+ * A base implementation for function factory actors for a dedicated operator.
+ */
+class ActorFunctionFactoryDedicated extends ActorFunctionFactory_1.ActorFunctionFactory {
+    constructor(args) {
+        super(args);
+    }
+    async test(action) {
+        // Name must match, if this is a term function, all is fine, if not, look whether term-function is not requested.
+        if (this.functionNames.includes(action.functionName) && (this.termFunction || !action.requireTermExpression)) {
+            return (0, core_1.passTestVoid)();
+        }
+        return (0, core_1.failTest)(`Actor ${this.name} can not provide implementation for "${action.functionName}", only for ${this.termFunction ? '' : 'non-termExpression '}${this.functionNames.join(' and ')}.`);
+    }
+}
+exports.ActorFunctionFactoryDedicated = ActorFunctionFactoryDedicated;
+//# sourceMappingURL=ActorFunctionFactoryDedicated.js.map

package/lib/ActorFunctionFactoryDedicated.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"ActorFunctionFactoryDedicated.js","sourceRoot":"","sources":["ActorFunctionFactoryDedicated.ts"],"names":[],"mappings":";;;AACA,yCAAwD;AAExD,iEAA8D;AAI9D;;GAEG;AACH,MAAsB,6BAA8B,SAAQ,2CAAoB;IAI9E,YAAsB,IAAwC;QAC5D,KAAK,CAAC,IAAI,CAAC,CAAC;IACd,CAAC;IAEM,KAAK,CAAC,IAAI,CAAC,MAA8B;QAC9C,iHAAiH;QACjH,IAAI,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC,EAAE,CAAC;YAC7G,OAAO,IAAA,mBAAY,GAAE,CAAC;QACxB,CAAC;QACD,OAAO,IAAA,eAAQ,EAAC,SAAS,IAAI,CAAC,IAAI,wCAAwC,MAAM,CAAC,YAAY,eAAe,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,qBAAqB,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACpM,CAAC;CACF;AAfD,sEAeC","sourcesContent":["import type { IActorTest, TestResult } from '@comunica/core';\nimport { failTest, passTestVoid } from '@comunica/core';\nimport type { IActionFunctionFactory, IActorFunctionFactoryArgs } from './ActorFunctionFactory';\nimport { ActorFunctionFactory } from './ActorFunctionFactory';\n\ntype StringArray = [ string, ...string[]];\n\n/**\n * A base implementation for function factory actors for a dedicated operator.\n */\nexport abstract class ActorFunctionFactoryDedicated extends ActorFunctionFactory {\n public readonly functionNames: StringArray;\n public readonly termFunction: boolean;\n\n protected constructor(args: IActorFunctionFactoryDedicatedArgs) {\n super(args);\n }\n\n public async test(action: IActionFunctionFactory): Promise<TestResult<IActorTest>> {\n // Name must match, if this is a term function, all is fine, if not, look whether term-function is not requested.\n if (this.functionNames.includes(action.functionName) && (this.termFunction || !action.requireTermExpression)) {\n return passTestVoid();\n }\n return failTest(`Actor ${this.name} can not provide implementation for \"${action.functionName}\", only for ${this.termFunction ? '' : 'non-termExpression '}${this.functionNames.join(' and ')}.`);\n }\n}\n\nexport interface IActorFunctionFactoryDedicatedArgs extends IActorFunctionFactoryArgs {\n functionNames: StringArray;\n termFunction: boolean;\n}\n"]}

package/lib/BusFunctionFactory.d.ts ADDED Viewed

@@ -0,0 +1,12 @@
+import type { IActorTest, IBusArgs } from '@comunica/core';
+import { BusIndexed } from '@comunica/core';
+import type { ActorFunctionFactory, IActionFunctionFactory, IActorFunctionFactoryOutput } from './ActorFunctionFactory';
+/**
+ * Bus inspired by BusIndexed but specific for function factory.
+ *
+ * The implementation differs. In BusIndexed, each actor is indexed only once.
+ * Here, a single actor can be indexed multiple times (max 2).
+ */
+export declare class BusFunctionFactory extends BusIndexed<ActorFunctionFactory, IActionFunctionFactory, IActorTest, IActorFunctionFactoryOutput> {
+    constructor(args: IBusArgs);
+}

package/lib/BusFunctionFactory.js ADDED Viewed

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BusFunctionFactory = void 0;
+const core_1 = require("@comunica/core");
+/**
+ * Bus inspired by BusIndexed but specific for function factory.
+ *
+ * The implementation differs. In BusIndexed, each actor is indexed only once.
+ * Here, a single actor can be indexed multiple times (max 2).
+ */
+class BusFunctionFactory extends core_1.BusIndexed {
+    constructor(args) {
+        super({
+            ...args,
+            actorIdentifierFields: ['functionNames'],
+            actionIdentifierFields: ['functionName'],
+        });
+    }
+}
+exports.BusFunctionFactory = BusFunctionFactory;
+//# sourceMappingURL=BusFunctionFactory.js.map

package/lib/BusFunctionFactory.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"BusFunctionFactory.js","sourceRoot":"","sources":["BusFunctionFactory.ts"],"names":[],"mappings":";;;AACA,yCAA4C;AAG5C;;;;;GAKG;AACH,MAAa,kBACX,SAAQ,iBAAiG;IACzG,YAAmB,IAAc;QAC/B,KAAK,CAAC;YACJ,GAAG,IAAI;YACP,qBAAqB,EAAE,CAAE,eAAe,CAAE;YAC1C,sBAAsB,EAAE,CAAE,cAAc,CAAE;SAC3C,CAAC,CAAC;IACL,CAAC;CACF;AATD,gDASC","sourcesContent":["import type { IActorTest, IBusArgs } from '@comunica/core';\nimport { BusIndexed } from '@comunica/core';\nimport type { ActorFunctionFactory, IActionFunctionFactory, IActorFunctionFactoryOutput } from './ActorFunctionFactory';\n\n/**\n * Bus inspired by BusIndexed but specific for function factory.\n *\n * The implementation differs. In BusIndexed, each actor is indexed only once.\n * Here, a single actor can be indexed multiple times (max 2).\n */\nexport class BusFunctionFactory\n extends BusIndexed<ActorFunctionFactory, IActionFunctionFactory, IActorTest, IActorFunctionFactoryOutput> {\n public constructor(args: IBusArgs) {\n super({\n ...args,\n actorIdentifierFields: [ 'functionNames' ],\n actionIdentifierFields: [ 'functionName' ],\n });\n }\n}\n"]}

package/lib/implementation/Core.d.ts ADDED Viewed

@@ -0,0 +1,46 @@
+import type { Expression, IEvalContext, IInternalEvaluator, TermExpression } from '@comunica/types';
+import type { GeneralOperator, OverloadTree } from '@comunica/utils-expression-evaluator';
+import type { IExpressionFunction, ITermFunction } from '../ActorFunctionFactory';
+interface BaseFunctionDefinitionArgs {
+    arity: number | number[];
+    operator: GeneralOperator;
+    apply: (evalContext: IEvalContext) => Promise<TermExpression>;
+}
+export declare class ExpressionFunctionBase implements IExpressionFunction {
+    protected readonly arity: number | number[];
+    readonly operator: GeneralOperator;
+    readonly apply: (evalContext: IEvalContext) => Promise<TermExpression>;
+    constructor({ arity, operator, apply }: BaseFunctionDefinitionArgs);
+    checkArity(args: Expression[]): boolean;
+}
+interface TermSparqlFunctionArgs {
+    arity: number | number[];
+    operator: GeneralOperator;
+    overloads: OverloadTree;
+}
+/**
+ * Varying kinds of functions take arguments of different types on which the
+ * specific behaviour is dependant. Although their behaviour is often varying,
+ * it is always relatively simple, and better suited for synced behaviour.
+ * The types of their arguments are always terms, but might differ in
+ * their term-type (eg: iri, literal),
+ * their specific literal type (eg: string, integer),
+ * their arity (see BNODE),
+ * or even their specific numeric type (eg: integer, float).
+ *
+ * Examples include:
+ *  - Arithmetic operations such as: *, -, /, +
+ *  - Bool operators such as: =, !=, <=, <, ...
+ *  - Functions such as: str, IRI
+ *
+ * See also: https://www.w3.org/TR/definitionTypesparql11-query/#func-rdfTerms
+ * and https://www.w3.org/TR/sparql11-query/#OperatorMapping
+ */
+export declare class TermFunctionBase extends ExpressionFunctionBase implements ITermFunction {
+    readonly supportsTermExpressions = true;
+    protected readonly overloads: OverloadTree;
+    constructor({ arity, operator, overloads }: TermSparqlFunctionArgs);
+    applyOnTerms(args: TermExpression[], exprEval: IInternalEvaluator): TermExpression;
+    protected handleInvalidTypes(args: TermExpression[]): never;
+}
+export {};

package/lib/implementation/Core.js ADDED Viewed

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TermFunctionBase = exports.ExpressionFunctionBase = void 0;
+const context_entries_1 = require("@comunica/context-entries");
+const utils_expression_evaluator_1 = require("@comunica/utils-expression-evaluator");
+class ExpressionFunctionBase {
+    constructor({ arity, operator, apply }) {
+        this.arity = arity;
+        this.operator = operator;
+        this.apply = apply;
+    }
+    checkArity(args) {
+        if (Array.isArray(this.arity)) {
+            return this.arity.includes(args.length);
+        }
+        if (this.arity === Number.POSITIVE_INFINITY) {
+            // Infinity is used to represent var-args, so it's always correct.
+            return true;
+        }
+        return args.length === this.arity;
+    }
+}
+exports.ExpressionFunctionBase = ExpressionFunctionBase;
+/**
+ * Varying kinds of functions take arguments of different types on which the
+ * specific behaviour is dependant. Although their behaviour is often varying,
+ * it is always relatively simple, and better suited for synced behaviour.
+ * The types of their arguments are always terms, but might differ in
+ * their term-type (eg: iri, literal),
+ * their specific literal type (eg: string, integer),
+ * their arity (see BNODE),
+ * or even their specific numeric type (eg: integer, float).
+ *
+ * Examples include:
+ *  - Arithmetic operations such as: *, -, /, +
+ *  - Bool operators such as: =, !=, <=, <, ...
+ *  - Functions such as: str, IRI
+ *
+ * See also: https://www.w3.org/TR/definitionTypesparql11-query/#func-rdfTerms
+ * and https://www.w3.org/TR/sparql11-query/#OperatorMapping
+ */
+class TermFunctionBase extends ExpressionFunctionBase {
+    constructor({ arity, operator, overloads }) {
+        super({
+            arity,
+            operator,
+            apply: async ({ args, exprEval, mapping }) => this.applyOnTerms(await Promise.all(args.map(arg => exprEval.evaluatorExpressionEvaluation(arg, mapping))), exprEval),
+        });
+        this.supportsTermExpressions = true;
+        this.overloads = overloads;
+    }
+    applyOnTerms(args, exprEval) {
+        const concreteFunction = this.overloads.search(args, exprEval.context.getSafe(context_entries_1.KeysExpressionEvaluator.superTypeProvider), exprEval.context.getSafe(context_entries_1.KeysInitQuery.functionArgumentsCache)) ?? this.handleInvalidTypes(args);
+        return concreteFunction(exprEval)(args);
+    }
+    handleInvalidTypes(args) {
+        throw new utils_expression_evaluator_1.InvalidArgumentTypes(args, this.operator);
+    }
+}
+exports.TermFunctionBase = TermFunctionBase;
+//# sourceMappingURL=Core.js.map

package/lib/implementation/Core.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"Core.js","sourceRoot":"","sources":["Core.ts"],"names":[],"mappings":";;;AAAA,+DAAmF;AAMnF,qFAC8C;AAa9C,MAAa,sBAAsB;IAKjC,YAAmB,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAA8B;QACvE,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAEM,UAAU,CAAC,IAAkB;QAClC,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC1C,CAAC;QACD,IAAI,IAAI,CAAC,KAAK,KAAK,MAAM,CAAC,iBAAiB,EAAE,CAAC;YAC5C,kEAAkE;YAClE,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,KAAK,CAAC;IACpC,CAAC;CACF;AAtBD,wDAsBC;AAQD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAa,gBAAiB,SAAQ,sBAAsB;IAI1D,YAAmB,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAA0B;QACvE,KAAK,CAAC;YACJ,KAAK;YACL,QAAQ;YACR,KAAK,EAAE,KAAK,EAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAgB,EAA2B,EAAE,CAAC,IAAI,CAAC,YAAY,CACnG,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,QAAQ,CAAC,6BAA6B,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,EACxF,QAAQ,CACT;SACF,CAAC,CAAC;QAXW,4BAAuB,GAAG,IAAI,CAAC;QAa7C,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAEM,YAAY,CAAC,IAAsB,EAAE,QAA4B;QACtE,MAAM,gBAAgB,GACpB,IAAI,CAAC,SAAS,CAAC,MAAM,CACnB,IAAI,EACJ,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,yCAAuB,CAAC,iBAAiB,CAAC,EACnE,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,+BAAa,CAAC,sBAAsB,CAAC,CAC/D,IAAI,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;QACrC,OAAO,gBAAgB,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC;IAC1C,CAAC;IAES,kBAAkB,CAAC,IAAsB;QACjD,MAAM,IAAI,iDAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IACtD,CAAC;CACF;AA9BD,4CA8BC","sourcesContent":["import { KeysExpressionEvaluator, KeysInitQuery } from '@comunica/context-entries';\nimport type { Expression, IEvalContext, IInternalEvaluator, TermExpression } from '@comunica/types';\nimport type {\n GeneralOperator,\n OverloadTree,\n} from '@comunica/utils-expression-evaluator';\nimport { InvalidArgumentTypes,\n} from '@comunica/utils-expression-evaluator';\nimport type { IExpressionFunction, ITermFunction } from '../ActorFunctionFactory';\n\n// ----------------------------------------------------------------------------\n// Overloaded Functions\n// ----------------------------------------------------------------------------\n\ninterface BaseFunctionDefinitionArgs {\n arity: number | number[];\n operator: GeneralOperator;\n apply: (evalContext: IEvalContext) => Promise<TermExpression>;\n}\n\nexport class ExpressionFunctionBase implements IExpressionFunction {\n protected readonly arity: number | number[];\n public readonly operator: GeneralOperator;\n public readonly apply: (evalContext: IEvalContext) => Promise<TermExpression>;\n\n public constructor({ arity, operator, apply }: BaseFunctionDefinitionArgs) {\n this.arity = arity;\n this.operator = operator;\n this.apply = apply;\n }\n\n public checkArity(args: Expression[]): boolean {\n if (Array.isArray(this.arity)) {\n return this.arity.includes(args.length);\n }\n if (this.arity === Number.POSITIVE_INFINITY) {\n // Infinity is used to represent var-args, so it's always correct.\n return true;\n }\n\n return args.length === this.arity;\n }\n}\n\ninterface TermSparqlFunctionArgs {\n arity: number | number[];\n operator: GeneralOperator;\n overloads: OverloadTree;\n}\n\n/**\n * Varying kinds of functions take arguments of different types on which the\n * specific behaviour is dependant. Although their behaviour is often varying,\n * it is always relatively simple, and better suited for synced behaviour.\n * The types of their arguments are always terms, but might differ in\n * their term-type (eg: iri, literal),\n * their specific literal type (eg: string, integer),\n * their arity (see BNODE),\n * or even their specific numeric type (eg: integer, float).\n *\n * Examples include:\n * - Arithmetic operations such as: *, -, /, +\n * - Bool operators such as: =, !=, <=, <, ...\n * - Functions such as: str, IRI\n *\n * See also: https://www.w3.org/TR/definitionTypesparql11-query/#func-rdfTerms\n * and https://www.w3.org/TR/sparql11-query/#OperatorMapping\n */\nexport class TermFunctionBase extends ExpressionFunctionBase implements ITermFunction {\n public readonly supportsTermExpressions = true;\n protected readonly overloads: OverloadTree;\n\n public constructor({ arity, operator, overloads }: TermSparqlFunctionArgs) {\n super({\n arity,\n operator,\n apply: async({ args, exprEval, mapping }: IEvalContext): Promise<TermExpression> => this.applyOnTerms(\n await Promise.all(args.map(arg => exprEval.evaluatorExpressionEvaluation(arg, mapping))),\n exprEval,\n ),\n });\n\n this.overloads = overloads;\n }\n\n public applyOnTerms(args: TermExpression[], exprEval: IInternalEvaluator): TermExpression {\n const concreteFunction =\n this.overloads.search(\n args,\n exprEval.context.getSafe(KeysExpressionEvaluator.superTypeProvider),\n exprEval.context.getSafe(KeysInitQuery.functionArgumentsCache),\n ) ?? this.handleInvalidTypes(args);\n return concreteFunction(exprEval)(args);\n }\n\n protected handleInvalidTypes(args: TermExpression[]): never {\n throw new InvalidArgumentTypes(args, this.operator);\n }\n}\n"]}

package/lib/index.d.ts ADDED Viewed

@@ -0,0 +1,4 @@
+export * from './ActorFunctionFactory';
+export * from './ActorFunctionFactoryDedicated';
+export * from './BusFunctionFactory';
+export * from './implementation/Core';

package/lib/index.js ADDED Viewed

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ActorFunctionFactory"), exports);
+__exportStar(require("./ActorFunctionFactoryDedicated"), exports);
+__exportStar(require("./BusFunctionFactory"), exports);
+__exportStar(require("./implementation/Core"), exports);
+//# sourceMappingURL=index.js.map

package/lib/index.js.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,yDAAuC;AACvC,kEAAgD;AAChD,uDAAqC;AACrC,wDAAsC","sourcesContent":["export * from './ActorFunctionFactory';\nexport * from './ActorFunctionFactoryDedicated';\nexport * from './BusFunctionFactory';\nexport * from './implementation/Core';\n"]}

package/package.json ADDED Viewed

@@ -0,0 +1,46 @@
+{
+  "name": "@comunica/bus-function-factory",
+  "version": "3.2.4-alpha.47.0",
+  "description": "A comunica bus for function factory events.",
+  "lsd:module": true,
+  "license": "MIT",
+  "homepage": "https://comunica.dev/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/comunica/comunica.git",
+    "directory": "packages/bus-functions"
+  },
+  "bugs": {
+    "url": "https://github.com/comunica/comunica/issues"
+  },
+  "keywords": [
+    "comunica",
+    "bus",
+    "functions"
+  ],
+  "sideEffects": false,
+  "main": "lib/index.js",
+  "typings": "lib/index",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "components",
+    "lib/**/*.d.ts",
+    "lib/**/*.js",
+    "lib/**/*.js.map"
+  ],
+  "scripts": {
+    "build": "npm run build:ts && npm run build:components",
+    "build:ts": "node \"../../node_modules/typescript/bin/tsc\"",
+    "build:components": "componentsjs-generator"
+  },
+  "dependencies": {
+    "@comunica/context-entries": "3.2.4-alpha.47.0",
+    "@comunica/core": "3.2.4-alpha.47.0",
+    "@comunica/types": "3.2.4-alpha.47.0",
+    "@comunica/utils-expression-evaluator": "3.2.4-alpha.47.0",
+    "sparqlalgebrajs": "^4.2.0"
+  },
+  "gitHead": "85bd4c5cf07dfc293ebbc3a1416b70e2db8bfc48"
+}