Map of {ActionMap} which hold action dispatchers. Calling a dispatcher should execute the action, causing them to be handled like any back-end sent action.
Constructing action IRI's and dispatching them in user code was a bit hard, this object allows any middleware to define their actions (within their namespace) in a code-oriented fashion. The middleware has control over how the actions will be dispatched, but it should be the same as if a back-end would have executed the action (via the Exec-Action header).
Whenever a resource has no type, assume it to be this.
Can aid in parsing an creating prefix mapping strings.
Please use @ontologies/
Add a custom delta processor in the stack.
Push one or more ontological items onto the graph so it can be used by the render store for component determination.
Adding information after the initial render currently conflicts with the caching and will result in inconsistent results.
Statements added here will also be added to the data store so views can access the statements.
Resolve the values at the end of the path
The resource to start descending on
A list of linked predicates to descend on.
Execute a resource.
Every action will fall through the execution middleware layers.
The resource to execute (can be either an IRI or an URI)
The arguments to the function defined by the subject.
Execute an Action by its IRI. This will result in an HTTP request being done and probably some state changes.
The resource to execute. Generally a schema:Action derivative with a schema:EntryPoint to describe the request. Currently schema:url is used over schema:urlTemplate to acquire the request URL, since template processing isn't implemented (yet).
An object to send in the body when a non-safe method is used.
Retrieve the subjects from {subject} to find all resources which have an object at the end of the {path} which matches {match}.
The resource to start descending on.
A list of linked predicates to descend on.
The value which the predicate at the end of {path} has to match for its subject to return.
Finds the best render component for a given property in respect to a topology.
The type(s) of the resource to render.
The predicate(s) (property(s)) to render.
The most appropriate renderer, if any.
Finds the best render component for a type in respect to a topology.
The type(s) of the resource to render.
The most appropriate renderer, if any.
Will fetch the entity with the URL {iri}. When a resource under that subject is already present, it will not be fetched again.
The Node of the resource
The options for fetch-/processing the resource.
A promise with the resulting entity
Resolves all the properties {property} of resource {subject} to a value.
The expected return type for the properties.
The resolved values of {property}, or an empty array when none are present.
Resolves the property {property} of resource {subject} to a value.
When more than one statement on {property} is present, a random one will be chosen. See {LinkedResourceContainer#getResourceProperties} to retrieve all the values.
The expected return type for the property.
The resolved value of {property}, or undefined when none are present.
Retrieve the (network) status of the resource {iri}.
Status 202 indicates that the resource has been queued for fetching (subject to change).
Process a linked-delta onto the store.
This should generally only be called from the middleware or the data api
An array of [s, p, o, g] arrays containing the delta.
Will immediately process the delta rather than waiting for an idle moment, useful in conjunction with event handlers within the UI needing immediate feedback. Might cause jumpy interfaces.
Queue a linked-delta to be processed.
Note: This should only be used by render-libraries (e.g. link-redux), not by application code.
Efficiently queues a resource to be fetched later.
This skips the overhead of creating a promise and allows the subsystem to retrieve multiple resource in one round trip, sacrificing loading status for performance.
Bulk register components formatted with {LinkedRenderStore.registerRenderer}.
Remove a resource from the store, when views are still rendered the resource will be re-fetched.
Resets the render store mappings and the schema graph.
Note: This should only be used by render-libraries (e.g. link-redux), not by application code.
Determine if it makes sense to load a resource.
Listen for data changes by subscribing to store changes.
function Unsubscription function.
Returns an entity from the cache directly. This won't cause any network requests even if the entity can't be found.
The Node of the resource.
The object if found, or undefined.
Generated using TypeDoc
Main entrypoint into the functionality of link-lib.
Before using the methods for querying data and views here, search through your render library (e.g. link-redux) to see if it exposes an API which covers your use-case. Skipping the render library might cause unexpected behaviour and hard to solve bugs.