linked-rolls 0.1.0 → 0.2.0

package/lib/asJsonLd.js

@@ -1,3 +1,4 @@
+import { systemIdOf } from "./TrackerBar";
 export const exportDate = (date) => {
     const year = date.getFullYear();
     const month = String(date.getMonth() + 1).padStart(2, "0");
@@ -32,13 +33,26 @@ const asJsonLdEntity = (obj) => {
             result[key] = value;
         }
     }
+    if ('@value' in obj && obj['@value'] instanceof Date) {
+        result['@type'] = 'xsd:date';
+    }
     return result;
 };
+/**
+ * The context of the roll's reproducing system, which reads the
+ * expression types as that system's terms.
+ */
+const systemContextOf = (edition) => {
+    const system = systemIdOf(edition.roll?.system);
+    return system ? [`https://w3id.org/reo/${system}/context.jsonld`] : [];
+};
 export const asJsonLd = (edition) => {
-    const { base, copies, ...rest } = asJsonLdEntity(edition);
+    // The context is the export's own; one carried in from an import must not override it.
+    const { base, copies, '@context': carried, ...rest } = asJsonLdEntity(edition);
     return {
         '@context': [
-            'https://linked-rolls.org/rollo/1.0/edition.jsonld',
+            'https://w3id.org/reo/context.jsonld',
+            ...systemContextOf(edition),
             {
                 '@base': edition.base
             }

package/lib/context.d.ts

@@ -1 +1,3 @@
 export { default as jsonLdContext } from './spec/context.json';
+/** The context of the Welte-Mignon T-100, added to an edition of a T-100 roll. */
+export { default as welteT100JsonLdContext } from './spec/welte-t100.context.json';

package/lib/context.js

@@ -1 +1,3 @@
 export { default as jsonLdContext } from './spec/context.json';
+/** The context of the Welte-Mignon T-100, added to an edition of a T-100 roll. */
+export { default as welteT100JsonLdContext } from './spec/welte-t100.context.json';

package/lib/importJsonLd.js

@@ -1,3 +1,4 @@
+import { migrate } from "./migrate";
 const isDate = (value) => {
     const datePattern = /^\d{4}-\d{1,2}-\d{1,2}$/;
     return datePattern.test(value);
@@ -14,7 +15,11 @@ const fromJsonLdEntity = (json) => {
         return json;
     }
     let result = json;
-    if ('@type' in json) {
+    if ('@value' in json) {
+        // the datatype of a value object, not a class
+        delete result['@type'];
+    }
+    else if ('@type' in json) {
         result['type'] = json['@type'];
         delete result['@type'];
     }
@@ -49,10 +54,19 @@ const fromJsonLdEntity = (json) => {
     }
     return result;
 };
+// The export prefixes copy identifiers with `copy/`; this is its inverse.
+const withPlainCopyIds = (json) => ({
+    ...json,
+    copies: (json.copies ?? []).map((copy) => ({
+        ...copy,
+        '@id': typeof copy['@id'] === 'string' ? copy['@id'].replace(/^copy\//, '') : copy['@id']
+    }))
+});
 export const importJsonLd = (json) => {
-    const edition = fromJsonLdEntity(json);
-    if (Array.isArray(json['@context'])) {
-        edition.base = json['@context'].find((c) => c['@base'])?.['@base'] || '';
-    }
+    const { '@context': context, ...document } = withPlainCopyIds(migrate(json));
+    const edition = fromJsonLdEntity(document);
+    edition.base = Array.isArray(context)
+        ? context.find((c) => c['@base'])?.['@base'] || ''
+        : '';
     return edition;
 };

package/lib/migrate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Brings the JSON of an edition written by an earlier release of the
+ * format up to the current shape. The shapes are recognised
+ * structurally, so a file that is current already passes through
+ * unchanged, and a file may be migrated any number of times.
+ *
+ * Format 0.1 used the type discriminator of versions and conditions
+ * for their typology, held the keeper and the production metadata as
+ * strings, and named the roll system on each copy. Some 0.1 files
+ * also carry references written as values and two keys the format
+ * had renamed before.
+ */
+type Json = any;
+export declare const migrate: (edition: Json) => Json;
+export {};

package/lib/migrate.js

@@ -0,0 +1,77 @@
+import { conditions } from "./Feature";
+import { rollConditions } from "./RollCopy";
+import { systemOf, welteT100 } from "./TrackerBar";
+import { versionTypes } from "./Version";
+const versionTypeValues = new Set(versionTypes);
+const conditionTypeValues = new Set([...rollConditions, ...Object.values(conditions).flat()]);
+const renamedKeys = {
+    productionEvent: 'production',
+    annotates: 'depiction',
+    classification: 'editType'
+};
+const referenceKeys = ['alignedWith', 'pairedWith', 'basedOn'];
+const named = (name) => ({ name, sameAs: [] });
+const withRenamedKeys = (node) => Object.fromEntries(Object.entries(node).map(([key, value]) => [renamedKeys[key] ?? key, value]));
+const withTypology = (node) => {
+    if (versionTypeValues.has(node['@type'])) {
+        return { ...node, '@type': 'Version', versionType: node['@type'] };
+    }
+    if (conditionTypeValues.has(node['@type'])) {
+        return { ...node, '@type': 'ConditionState', conditionType: node['@type'] };
+    }
+    return node;
+};
+const withReferences = (node) => referenceKeys.reduce((result, key) => {
+    const reference = result[key];
+    if (reference && typeof reference === 'object' && '@value' in reference) {
+        const { '@value': id, ...rest } = reference;
+        return { ...result, [key]: { '@id': id, ...rest } };
+    }
+    return result;
+}, node);
+const withKeeper = (node) => {
+    if (typeof node.location !== 'string')
+        return node;
+    const { location, ...rest } = node;
+    return { ...rest, keeper: named(location) };
+};
+const withProductionNodes = (node) => {
+    const production = node.production;
+    if (!production || typeof production !== 'object')
+        return node;
+    const { company, paper, system, ...rest } = production;
+    return {
+        ...node,
+        production: {
+            ...rest,
+            ...(typeof company === 'string' ? (company && { company: named(company) }) : { company }),
+            ...(typeof paper === 'string' ? (paper && { paper: named(paper) }) : { paper }),
+        }
+    };
+};
+const migrateNode = (node) => [withRenamedKeys, withTypology, withReferences, withKeeper, withProductionNodes]
+    .reduce((result, step) => step(result), node);
+const walk = (value) => {
+    if (Array.isArray(value))
+        return value.map(walk);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(migrateNode(value)).map(([key, child]) => [key, walk(child)]));
+    }
+    return value;
+};
+/**
+ * Every 0.1 edition was read with the T-100 tracker bar, so a roll
+ * without a system is a T-100 roll. The text a copy's production
+ * gave for the system is kept as the name.
+ */
+const withRollSystem = (edition) => {
+    if (!edition.roll || edition.roll.system)
+        return edition;
+    const stated = (edition.copies ?? [])
+        .map((copy) => copy.production?.system ?? copy.productionEvent?.system)
+        .find((system) => typeof system === 'string' && system !== '');
+    const { id, ...concept } = systemOf(welteT100);
+    const system = { '@id': id, ...concept, ...(stated && { name: stated }) };
+    return { ...edition, roll: { ...edition.roll, system } };
+};
+export const migrate = (edition) => walk(withRollSystem(edition));