JSON-LD API 1.0

3.2.1 Methods

compact

Compacts the given input using the context according to the steps in the Compaction Algorithm. The input must be copied, compacted and returned if there are no errors. If the compaction fails, an appropriate exception must be thrown.

Parameter	Type	Nullable	Optional	Description
input	object or object[] or URL	✘	✘	The JSON-LD object or array of JSON-LD objects to perform the compaction upon or an IRI referencing the JSON-LD document to compact.
context	object or URL	✘	✘	The context to use when compacting the input; either in the form of an JSON object or as IRI.
callback	JsonLdCallback	✘	✘	A callback that is called when processing is complete on the given input.
options	JsonLdOptions	✘	✔	A set of options that may affect the expansion algorithm such as, e.g., the input document's base IRI. This also includes optimize, which if set will cause processor-specific optimization.

Return type: void

expand

Expands the given input according to the steps in the Expansion Algorithm. The input must be copied, expanded and returned if there are no errors. If the expansion fails, an appropriate exception must be thrown.

Parameter	Type	Nullable	Optional	Description
input	object or object[] or URL	✘	✘	The JSON-LD object or array of JSON-LD objects to perform the expansion upon or an IRI referencing the JSON-LD document to expand.
context	object or URL	✔	✘	An optional external context to use additionally to the context embedded in input when expanding the input.
callback	JsonLdCallback	✘	✘	A callback that is called when processing is complete on the given input.
options	JsonLdOptions	✘	✔	A set of options that may affect the expansion algorithm such as, e.g., the input document's base IRI.

Return type: void

fromRDF

Creates a JSON-LD document given an set of Quads.

Parameter	Type	Nullable	Optional	Description
input	Quad[]	✘	✘	A dataset represented as an array of Quads.
callback	JsonLdCallback	✘	✘	A callback that is called when processing is complete on the given input.
options	JsonLdOptions	✘	✔	A set of options that will affect the algorithm. This includes notType, which if set to true causes the resulting document to use rdf:type as a property, instead of @type.

Return type: void

toRDF

Processes the input according to the Convert to RDF Algorithm, calling the provided callback for each Quad generated.

Parameter	Type	Nullable	Optional	Description
input	object or object[] or URL	✘	✘	The JSON-LD object or array of JSON-LD objects to convert to RDF or a URL referencing the JSON-LD document to convert to RDF.
callback	QuadCallback	✘	✘	A callback that is called when a Quad is created from processing the given input.
options	JsonLdOptions	✘	✔	A set of options that may affect the conversion to RDF such as, e.g., the input document's base IRI.

Return type: void

3.3.1 JsonLdCallback

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

[NoInterfaceObject Callback]
interface JsonLdCallback {
    void jsonLd (object or object[] jsonld);
};

3.3.2 QuadCallback

The QuadCallback is called whenever the processor generates a quad during the quad() call.

[NoInterfaceObject Callback]
interface QuadCallback {
    void quad (Quad quad);
};

3.4.1 URL

The URL datatype is a string representation of an IRI.

typedef DOMString URL;

3.4.2 JsonLdOptions

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

typedef object JsonLdOptions;

3.4.3 Quad

The Quad interface represents an RDF Quad. See [RDF-CONCEPTS] definition for RDF triple, which most closely aligns to Quad.

[NoInterfaceObject]
interface Quad {
    readonly attribute Node  subject;
    readonly attribute Node  predicate;
    readonly attribute Node  object;
    readonly attribute Node? graphName;
};

3.4.4 Node

Node is the base class of IRI, BlankNode, and Literal. It is the IDL representation of a linked data graph node.

[NoInterfaceObject]
interface Node {
};

3.4.5 IRI

A node that is an IRI.

[NoInterfaceObject]
interface IRI : Node {
    readonly attribute DOMString value;
};

3.4.6 Blank Node

A node in the linked data graph that does not contain a de-reference-able identifier because it is either ephemeral in nature or does not contain information that needs to be linked to from outside of the linked data graph. A blank node is assigned an identifier starting with the prefix _: and an implementation dependent, auto-generated suffix that is unique to all information associated with the particular blank node.

[NoInterfaceObject]
interface BlankNode : Node {
    readonly attribute DOMString identifier;
};

3.4.7 Literal

Literals represent values such as numbers, dates and strings in RDF data. A Literal is comprised of three attributes:

• a lexical form of the value
• an optional language tag
• a datatype specified by an IRI

Literals representing plain text in a natural language may have a language tag specified by a string token, as specified in [BCP47], normalized to lowercase (e.g., 'en', 'fr', 'en-gb'). They also have a datatype attribute such as xsd:string. If unspecified, the datatype defaults to xsd:string.

Literals representing values with a specific datatype, such as the integer 72, may have a datatype attribute specified in the form of a IRI (e.g., xsd:integer).

See[RDF-CONCEPTS] definition for literal.

[NoInterfaceObject]
interface Literal : Node {
    readonly attribute DOMString  value;
    readonly attribute DOMString? language;
    readonly attribute IRI?       datatype;
};

4.4.1 IRI Compaction Algorithm

The algorithm for generating a compact IRI is:

1. Create an empty list of terms terms that will be populated with terms that are ranked according to how closely they match value. Initialize highest rank to 0, and set a flag list container to false.
2. For each term in the active context:
   1. If the term's IRI is not a complete match against iri, continue to the next term.
   2. If value is a JSON object containing only the property @list:
      1. If term has a @container set to @set, continue to the next term.
      2. If list container is true and term does not have a container set to @list, continue to the next term.
   3. Otherwise, if term has a container set to @list, continue to the next term.
   4. Set rank to the term rank of value by passing passing term, value, and active context to the Term Rank Algorithm.
   5. If rank is greater than 0:
      1. If term has a container set to @set, then add 1 to rank.
      2. If value is a JSON object containing only the property @list and list container is false and term has a container set to @list, then set list container to true, clear terms, set highest rank to rank, and add term to terms.
      3. Otherwise, if rank is greater than or equal to highest rank:
         1. If rank is greater than highest rank, clear terms and set highest rank to rank.
         2. Add term to terms.
3. If terms is empty, add a compact IRI representation of iri for each term in the active context which maps to an IRI which is a prefix for iri where the resulting compact IRI is not a term in the active context. The resulting compact IRI is the term associated with the partially matched IRI in the active context concatenated with a colon (:) character and the unmatched part of iri.
4. If terms is empty, return iri.
5. Otherwise, return the shortest and lexicographically least value in terms.

4.4.2 Term Rank Algorithm

When selecting among multiple possible terms for a given property, it may be that multiple terms are defined with the same IRI, but differ in @type, @container or @language. The purpose of this algorithm is to take a term and a value and give it a term rank. The selection can then be based, partly, on the term having the highest term rank.

Given a term term, value, and active context determine the term rank using the following steps:

1. If value is null, term rank is 3.
2. Otherwise, if value is a JSON object containing only the property @list:
   1. If the @list property is an empty array, if term has @container set to @list, term rank is 1, otherwise 0.
   2. Otherwise, return the sum of the term ranks for every entry in the list.
3. Otherwise, value must be a subject definition, subject reference, or a JSON object having a @value.
   1. If value has a @value property:
      1. If value has a @type property matching a @type coercion for term, term rank is 3, otherwise if term has no @type coercion and no @language, term rank is 1, otherwise 0.
      2. Otherwise, if @value is not a string, if term has no @type or @language it is 2, otherwise 1.
      3. Otherwise, if value has no @language property, if term has @language null, or term has no @type or @language and the active context has no @language, term rank is 3, otherwise 0.
      4. Otherwise, if value has a @language property matching a @language definition for term (or term has no @type or @language definition and @language in the active context matches the value @language), term rank is 3, otherwise if term has no @type coercion and no @language, term rank is 1, otherwise 0.
   2. Otherwise, if term has @type coerced to @id, term rank is 3, otherwise if term has no @type coercion and no @language, term rank is 1, otherwise 0.
4. Return term rank.

4.7.1 Expansion Algorithm

The algorithm takes three input variables: an active context, an active property, and an element to be expanded. To begin, the active context is set to the result of performing, Context Processing on the passed context, or to the initial context if context is null, active property is set to null, and element is set to the JSON-LD input.

1. If element is an array, process each entry in element recursively using this algorithm, passing copies of the active context and active property. If has a @container set to @list and any entry in element is an array, or is a JSON object containing a @list property, throw an exception, as lists of lists are not allowed. If the expanded entry is null, drop it. If it's an array, merge its entries with element's entries.
2. Otherwise, if element is an object
   1. If element has a @context property, update the active context according to the steps outlined in Context Processing and remove the @context property.
   2. Then, proceed and process each property and value in element as follows:
      1. Remove property from element, expand property according to the steps outlined in IRI Expansion. Set the active property to the original un-expanded property if property is not a keyword.
      2. If property does not expand to a keyword or an absolute IRI (i.e., it doesn't contain a colon), continue with the next property from element.
      3. If value is null and property is not @value, continue with the next property from element.
      4. If the property is @id the value must be a string. Expand the value according to IRI Expansion.
      5. Otherwise, if the property is @type:
         1. If value is a string, expand according to IRI Expansion.
         2. Otherwise, if value is a subject reference, the expanded value is the result of performing IRI Expansion on the value of @id.
         3. Otherwise, if value is a JSON Object, it must be empty (used for Framing).
         4. Otherwise, if value is an array, all elements must be either a string or subject reference. Expand value for each of its entries using the previous three steps.
      6. Otherwise, if the property is @value or @language the value must not be a JSON object or an array.
      7. Otherwise, if the property is @list or @set expand value recursively using this algorithm, passing copies of the active context and active property. If the expanded value is not an array, convert it to an array. If property is @list and any entry in value is a JSON object containing an @list property, throw an exception, as lists of lists are not supported.
      8. Otherwise, expand value recursively using this algorithm, passing copies of the active context and active property.
      9. If property is not a keyword and active property has a @container @list and the expanded value is not null, convert value to an object with an @list property whose value is set to value (unless value is already in that form).
      10. Convert value to array form unless value is null or property is @id, @type, @value, or @language.
      11. If value is not null, either merge value into an existing property property of element or create a new property property with value as value.
   3. If the processed element has an @value property
      1. element must not have more than one other property, which can either be @language or @type with a string value.
      2. if the value of @value equals null, replace element with the value of @value.
   4. Otherwise, if element has an @type property and its value is not in the form of an array, convert it to an array.
   5. If element has an @set or @list property, it must be the only property. Set element to the value of @set; leave @list untouched.
   6. If element has just a @language property, set element to null.
3. Otherwise, expand element according to the Value Expansion rules, passing copies of the active context and active property.

If, after the algorithm outlined above is run, the resulting element is an JSON object with just a @graph property, element is set to the value of @graph's value. Finally, if element is a JSON object, it is wrapped into an array.

4.8.1 Compaction Algorithm

The algorithm takes three input variables: an active context, an active property, and an element to be compacted. To begin, the active context is set to the result of performing Context Processing on the passed context, active property is set to null, and element is set to the result of performing the Expansion Algorithm on the JSON-LD input. This removes any existing context to allow the given active context to be cleanly applied.

1. If element is an array, process each entry in element recursively using this algorithm, passing a copy of the active context and the active property. If element has a single item, the compacted value is that item; otherwise the compacted value is element.
2. Otherwise, if element is an object:
   1. If element has an @value property or element is a subject reference, return the result of performing Value Compaction on element using active property.
   2. Otherwise, if the active property has a @container mapping to @list and element has a corresponding @list property, recursively compact that property's value passing a copy of the active context and the active property ensuring that the result is an array and removing null values. Return either the result as an array, as an object with a key of @list (or appropriate alias from active context).
   3. Otherwise, construct output as a new JSON object used for returning the result of compacting element. For each property and value in element:
      1. If property is @id or @type
         1. Set active property to the result of performing IRI Compaction on property.
         2. If value is a string, the compacted value is the result of performing IRI Compaction on value.
         3. Otherwise, value must be an array. Perform IRI Compaction on every entry of value. If value contains just one entry, value is set to that entry.
         4. Add active property and the expanded value to output.
      2. Otherwise, value must be an array.
      3. If value is empty:
         1. Set active property to the result of performing IRI Compaction on property.
         2. Create an entry in output for active property and value.
      4. For each item in value:
         1. Set active property to the result of performing IRI Compaction for property and item using the active context.
         2. Compact item by recursively performing this algorithm passing a copy of the active context and the active property.
         3. If an entry already exists in output for active property, convert it to an array if necessary, and append the compacted value.
         4. Otherwise, if the compacted value is not an array and active property has a @container mapping to @set, create an entry in output for active property and value as an array.
         5. Otherwise, create an entry in output for active property and value.
3. Otherwise, return element as the compacted element.
   Issue 7

   Perhaps this should also call Value Compaction on native types and strings, which could consolidate potential transformation in one place.

If, after the algorithm outlined above is run, the resulting element is an array, put element into the @graph property of a new JSON object and then set element to that JSON object. Finally, add a @context property to element and set it to the initially passed context.

4.9.3 Convert to RDF Algorithm

The algorithm below is designed for in-memory implementations with random access to JSON object elements.

A conforming JSON-LD processor implementing RDF conversion must implement a processing algorithm that results in the same set of RDF Quads that the following algorithm generates:

The algorithm takes five input variables: a element to be converted, an active subject, active property and graph name. To begin, the active subject, active property and graph name are set to null, and element is set to the result of performing the Expansion Algorithm on the JSON-LD input. This removes any existing context to allow the given context to be cleanly applied.

1. If element is a JSON object, perform the following steps:
   1. Set active object to null.
   2. If element has a @value property:
      1. If the value of @value is a number, set the active object to a typed literal using a string representation of the value as defined in the section Data Round Tripping. Set datatype to the value of the @type property if it exists, otherwise either xsd:integer or xsd:double, depending on if the value contains a fractional and/or an exponential component.
      2. Otherwise, if the value of @value is true or false, set the active object to a typed literal created from the string representation of the value. Set datatype to the value of the @type property if it exists, otherwise xsd:boolean.
      3. Otherwise, if element contains a @type property, set the active object to a typed literal.
      4. Otherwise, if element contains a @language property, set the active object to a language-tagged literal.
      5. Otherwise, set the active object to a typed literal using xsd:string as the datatype.
   3. If element has a @list property the value must be an array. Process its value as a list as described in List Conversion using the return value as the active object
   4. If active object is not null:
      1. If neither active subject nor active property are null, generate a Quad representing active subject, active property, active object, and graph name.
      2. Return active object.
   5. If element has a @id property, the value must be a string, set the active subject to the previously expanded value (either a blank node or an IRI).
   6. Otherwise, if element does not have a @id property, set the active subject to newly generated blank node.
   7. Process each property and value in element, ordered by property, as follows:
      1. If property is @type, set the active property to rdf:type.
      2. Otherwise, if property is @graph, process value algorithm recursively, using active subject as graph name and null values for active subject and active property and then proceed to next property.
      3. Otherwise, if property is a keyword, skip this step.
      4. Otherwise, set active property to the IRI value of property.
      5. Process value recursively using this algorithm, passing copies of active subject, active property and graph name.
   8. Set active object to active subject.
2. Otherwise, if element is an array, process each value in the array as follows, process element recursively using this algorithm, using copies of active subject, active property, and graph name.
3. Otherwise, if element is a string, then the active property must be rdf:type so set the active object to an IRI.
4. If any of these steps created an active object and neither active subject nor active property are null, generate a Quad using active subject,active property, active object and graph name.
5. Return active object.

4.9.4 List Conversion

List Conversion is the process of taking an array of values and adding them to a newly created RDF Collection (see [RDF-SCHEMA]) by linking each element of the list using rdf:first and rdf:next, terminating the list with rdf:nil using the following sequence:

The algorithm is invoked with an array array, the active property and returns a value to be used as an active object in the calling location.

1. If array is empty return rdf:nil.
2. Otherwise, generate a Quad using using the active subject, active property and a newly generated blank node identified as first blank node.
3. For each element in array other than the last element:
   1. Create a processor state using first blank node as the active subject, and rdf:first as the active property.
      1. Process the value starting at Step 1.
      2. Proceed using the previous processor state.
   2. Unless this is the last element in array, generate a new blank node identified as rest blank node, otherwise use rdf:nil.
   3. Generate a new Quad using first blank node, rdf:rest and rest blank node.
   4. Set first blank node to rest blank node.
   5. Return first blank node.

4.9.5 Convert from RDF Algorithm

In some cases, data exists natively in Triples or Quads form; for example, if the data was originally represented in an RDF graph or triple/quad store. This algorithm is designed to simply translate an array of Quads into a JSON-LD document.

When expanding typed literal values having a datatype of xsd:string, the @type must not be set to xsd:string and the resulting value must have only a @value property.

The conversion algorithm takes a single parameter input in the form of an array of Quad representations.

1. Construct defaultGraph as a JSON object containing subjects and listMap, each an empty JSON object.
2. Construct graphs as a JSON object containing defaultGraph identified by an empty string.
3. For each quad in input:
   1. Set graph to the entry in graphs identified by name, initializing it to a new entry using the mechanism described in Step 1.
   2. If property is rdf:first, use the entry in graph.listMap indexed by subject, initializing it to a new JSON object if nesessary. Represent object in expanded form, as described in Value Expansion. Add the resulting object representation to the entry indexed by first, and skip to the next quad.
   3. If property is rdf:rest:
      1. If object is a blank node, use the entry in graph.listMap indexed by subject, initializing it to a new JSON object if necessary. Add the nominalValue of object to the entry indexed by rest.
      2. Skip to the next quad.
   4. If name is not null, and defaultGraph.subjects does not contain an entry for name, create a new entry for name from a new JSON object with key/value pair of @id and a string representation of name.
   5. Set value as the entry from graph.subjects for subject, initializing it to a new JSON object with key/value pair of @id and a string representation of subject if necessary.
   6. If property is rdf:type and the notType option is present and not true:
      1. Append the string representation of object to the array value for the key @type, creating an entry in value if necessary.
   7. Otherwise, if object is rdf:nil:
      1. Let key be the string representation of property.
      2. Append an empty @list representation to the array value for key, creating an entry in value if necessary.
   8. Otherwise,
      1. Let key be the string representation of property and let object representation be object represented in expanded form as described in Value Expansion.
      2. If object is a blank node, use the entry in graph.listMap indexed by object, initializing it to a new JSON object if nesessary. Add an entry for head with object representation.
      3. Append object representation to the array value for key, creating an entry in value if necessary.
4. For each name and graph in graphs:
   1. For each subject and entry in graph where entry has both head and first keys:
      1. Set value to the value of head in entry.
      2. Remove the entry for @id in value.
      3. Add an entry to value for @list initialized to a new array containing the value of first from entry.
      4. While entry has a key for rest:
         1. Set entry to the value of graph.listMap for entry.rest.
         2. Add the value for entry.first to the list array.
5. Create array as an empty array.
6. For each subject and entry in defaultGraph.subjects ordered by subject:
   1. Add entry to array.
   2. If graphs has an entry for subject, add a property @graph in entry containing the ordered entries from graphs[subject].subjects.
7. Return array as the result.