linked-rolls 0.1.1 → 0.2.0

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));