JsonLdCallback

The JsonLdCallback is used to return a processed JSON-LD representation as the result of processing an API method.

See JsonLdCallback definition in [[!JSON-LD-API]].

JsonLdOptions

The JsonLdOptions type is used to convert a set of options to an interface method.

See JsonLdOptions definition in [[!JSON-LD-API]].

Framing Algorithm Terms

input frame

the initial frame provided to the framing algorithm.

framing context

a context containing a map of embeds, the object embed flag, the explicit inclusion flag and the omit default flag.

map of embeds

a map that tracks if a subject is to be embedded in the output of the Framing Algorithm; it maps a subject @id to a parent JSON object and property or parent array.

object embed flag

a flag specifying that objects should be directly embedded in the output, instead of being referred to by their IRI.

explicit inclusion flag

a flag specifying that for properties to be included in the output, they must be explicitly declared in the framing context.

omit default flag

a flag specifying that properties that are missing from the JSON-LD input, but present in the input frame should be omitted from the output.

map of flattened subjects

a map of subjects that is the result of the Node Map Generation algorithm.

Framing Algorithm

This algorithm is a work in progress. Presently, it only works for documents without named graphs.

Currently, framing allows just to select node definitions based on @type matching or duck typing for included properties. It allows value properties to be explicitly matched based on defining the property and excluding things that are undefined, but it does not allow to be more specific about the types of values selected. Allowing this is currently being discussed.

The framing algorithm takes an JSON-LD input (expanded input) and an input frame (expanded frame) that have been expanded according to the Expansion Algorithm, and a number of options and produces JSON-LD output.

Create framing context using null for the map of embeds, the object embed flag set to true, the explicit inclusion flag set to false, and the omit default flag set to false along with map of flattened subjects set to the @merged property of the result of performing the Node Map Generation algorithm on expanded input. Also create results as an empty array.

Invoke the recursive algorithm using framing context (state), the map of flattened subjects (subjects), expanded frame (frame), result as parent, and null as active property.

The following series of steps is the recursive portion of the framing algorithm:

1. Validate frame.
2. Create a set of matched subjects by filtering subjects checking the map of flattened subjects against frame:
   1. If frame has a @type property containing one or more IRIs match any node definition with a @type property including any of those IRIs.
   2. Otherwise, if frame has a @type property only a empty JSON object, matches any node definition with a @type property, regardless of the actual values.
   3. Otherwise, match if the node definition contains all of the non-keyword properties in frame.
3. Get values for embedOn and explicitOn by looking in frame for the keys @embed and @explicit using the current values for object embed flag and explicit inclusion flag from state if not found.
4. For each id and subject from the set of matched subjects, ordered by id:
   1. If the active property is null, set the map of embeds in state to an empty map.
   2. Initialize output with @id and id.
   3. Initialize embed with parent and active property to property.
   4. If embedOn is true, and id is in map of embeds from state:
      1. Set existing to the value of id in map of embeds and set embedOn to false.
      2. If existing has a parent which is an array containing a JSON object with @id equal to id, element has already been embedded and can be overwritten, so set embedOn to true.
      3. Otherwise, existing has a parent which is a node definition. Set embedOn to true if any of the items in parent property is a node definition or node reference for id because the embed can be overwritten.
      4. If embedOn is true, existing is already embedded but can be overwritten, so Remove Embedded Definition for id.
   5. If embedOn is false, add output to parent by either appending to parent if it is an array, or appending to active property in parent otherwise.
   6. Otherwise:
      1. Add embed to map of embeds for id.
      2. Process each property and value in the matched subject, ordered by property:
         1. If property is a keyword, add property and a copy of value to output and continue with the next property from subject.
         2. If property is not in frame:
            1. If explicitOn is false, Embed values from subject in output using subject as element and property as active property.
            2. Continue to next property.
         3. Process each item from value as follows:
            1. If item is a JSON object with the key @list, then create a JSON object named list with the key @list and the value of an empty array. Append list to property in output. Process each listitem in the @list array as follows:
               1. If listitem is a node reference process listitem recursively using this algorithm passing a new map of subjects that contains the @id of listitem as the key and the node definition from the original map of flattened subjects as the value. Pass the first value from frame for property as frame, list as parent, and @list as active property.
               2. Otherwise, append a copy of listitem to @list in list.
            2. If item is a node reference process item recursively using this algorithm passing a new map as subjects that contains the @id of item as the key and the node definition from the original map of flattened subjects as the value. Pass the first value from frame for property as frame, output as parent, and property as active property.
               Passing a node reference doesn't work if this map is used recursively. Presently pass node definition from original map of flattened subjects.
            3. Otherwise, append a copy of item to active property in output.
      3. Process each property and value in frame, where property is not a keyword, ordered by property:
         1. Set property frame to the first item in value or a newly created JSON object if value is empty.
         2. Skip to the next property in frame if property is in output or if property frame contains @omitDefault which is true or if it does not contain @omitDefault but the value of omit default flag true.
         3. Set the value of property in output to a new JSON object with a property @preserve and a value that is a copy of the value of @default in frame if it exists, or the string @null otherwise.
      4. Add output to parent. If parent is an array, append output, otherwise append output to active property in parent.

At the completion of the recursive algorithm, results will contain the top-level node definitions.

The final two steps of the framing algorithm require results to be compacted according to the Compaction Algorithm by using the context provided in the input frame. If the frame has no context, compaction is performed with an empty context (not a null context). The compaction result MUST use the @graph keyword at the top-level, even if the context is empty or if there is only one element to put in the @graph array. Subsequently, replace all key-value pairs where the key is @preserve with the value from the key-pair. If the value from the key-pair is @null, replace the value with null. If, after replacement, an array contains only the value null remove the value, leaving an empty array. The resulting value is the final JSON-LD output.

Remove Embedded Definition

This algorithm replaces an already embedded node definition with a node reference. It then recursively removes any entries in the map of embeds that had the removed node definition in their parent chain.

About as clear as mud

The current behaviour avoids embedding the same data multiple times in the result makes it difficult to work with the output. A proposal to change this to "agressive re-embedding" is currently being discussed.

The algorithm is invoked with a framing context and subject id id.

1. Find embed from map of embeds for id.
2. Let parent and property be from embed.
3. If parent is an array, replace the node definition that matches id with a node reference. If parent is a JSON object, replace the node definition for property that matches id with a node reference.
4. Remove dependents for id in map of embeds by scanning the map for entries with parent that have an @id of id, removing that definition from the map, and then removing the dependents for the parent id recursively by repeating this step. This step will terminate when there are no more embed entries containing the removed node definition's @id in their parent chain.

Embed Values

This algorithm recursively embeds property values in node definition output, given a framing context, input node definition element, active property, and output.

1. For each item in active property of element:
   1. If item is a JSON object with the key @list, then create a new JSON object with a key @list and a value of an empty array and add it to output, appending if output is an array, and appending to active property otherwise. Recursively call this algorithm passing item as element, @list as active property, and the new array as output. Continue to the next item.
   2. If item is a node reference:
      1. If map of embeds does not contain an entry for the @id of item:
         1. Initialize embed with output as parent and active property as property and add to map of embeds.
         2. Initialize a new node definition o to act as the embedded node definition.
         3. For each property and value in the expanded definition for item in subjects:
            1. Add property and a copy of value to o if property is a keyword.
            2. Otherwise, recursively call this algorithm passing value as element, property as active property and o as output.
      2. Set item to o.
2. If output is an array, append a copy of item, otherwise append a copy of item to active property in output.