linked-rolls 0.0.1

package/lib/build-schema.cjs

@@ -0,0 +1,113 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+// build-schema.ts
+var ts_json_schema_generator_1 = require("ts-json-schema-generator");
+var fs = __importStar(require("fs"));
+/** Safely check if a referenced type is an ObjectType with a string `id` property. */
+function refTargetsRefableObject(ref, fmt) {
+    var _a;
+    var target = ref.getType();
+    // console.log('target', target, target instanceof ObjectType)
+    // if (!(target instanceof ObjectType)) return false;
+    // Ask the default formatter for the *object's* definition and inspect its properties.
+    // This is safe because 'target' isn't a ReferenceType, so the built-ins will produce
+    // the object schema (possibly via $ref creation behind the scenes).
+    var def = fmt.getDefinition(target);
+    console.log('def=', def);
+    var idSchema = (_a = def === null || def === void 0 ? void 0 : def.properties) === null || _a === void 0 ? void 0 : _a.id;
+    if (!idSchema)
+        return false;
+    // Accept plain string or unions that contain string
+    return idSchema.type === "string" ||
+        (Array.isArray(idSchema.anyOf) && idSchema.anyOf.some(function (s) { return (s === null || s === void 0 ? void 0 : s.type) === "string"; }));
+}
+/** Wrap only ReferenceType occurrences to ref-able objects as oneOf($ref, "#id"). */
+var RefableReferenceWrapper = /** @class */ (function () {
+    function RefableReferenceWrapper(child) {
+        this.child = child;
+    }
+    // Only intercept ReferenceType; let built-ins handle everything else.
+    RefableReferenceWrapper.prototype.supportsType = function (type) {
+        return type instanceof ts_json_schema_generator_1.ReferenceType;
+    };
+    RefableReferenceWrapper.prototype.getDefinition = function (type) {
+        console.log('ref type', type);
+        var isRefable = type.getType().type.type.properties.findIndex(function (p) { return p.name === 'id'; }) !== -1;
+        // Let the built-in ReferenceTypeFormatter do its thing first ($ref, etc.)
+        var original = this.child.getDefinition(type);
+        // If the reference points to an object with string `id`, allow "#id" as alternative.
+        if (isRefable) {
+            console.log('is refable', type);
+            // Avoid double-wrapping if something upstream already produced oneOf.
+            if (original && original.oneOf)
+                return original;
+            return original;
+            //return {
+            //  oneOf: [
+            //    original,                 // usually { "$ref": "#/definitions/..." }
+            //    { type: "string", pattern: "^#.+$" }, // your "#<id>" form; tighten regex if needed
+            //  ],
+            // };
+        }
+        return original;
+    };
+    RefableReferenceWrapper.prototype.getChildren = function (type) {
+        // Always delegate. Do NOT call .getType() here—let the chain manage traversal.
+        return this.child.getChildren(type);
+    };
+    return RefableReferenceWrapper;
+}());
+// ——— Wire up the generator ———
+var config = __assign(__assign({}, ts_json_schema_generator_1.DEFAULT_CONFIG), { path: "../src/**/*.ts", tsconfig: "tsconfig.json", type: "Edition" });
+var formatter = (0, ts_json_schema_generator_1.createFormatter)(config, function (fmt, circular) {
+    fmt.addTypeFormatter(new RefableReferenceWrapper(circular));
+});
+var program = (0, ts_json_schema_generator_1.createProgram)(config);
+var parser = (0, ts_json_schema_generator_1.createParser)(program, config);
+var generator = new ts_json_schema_generator_1.SchemaGenerator(program, parser, formatter, config);
+var schema = generator.createSchema(config.type);
+fs.writeFileSync("./context.json", JSON.stringify(schema, null, 2));

package/lib/context.d.ts

@@ -0,0 +1 @@
+export { default as jsonLdContext } from './spec/context.json';

package/lib/context.js

@@ -0,0 +1 @@
+export { default as jsonLdContext } from './spec/context.json';

package/lib/importJsonLd.d.ts

@@ -0,0 +1,4 @@
+import { Edition } from "./Edition";
+export declare const exportDate: (date: Date) => string;
+export declare const importDate: (str: string) => Date;
+export declare const importJsonLd: (json: any) => Edition;

package/lib/importJsonLd.js

@@ -0,0 +1,121 @@
+import { RollCopy } from "./RollCopy";
+import { referenceTypes } from "./asJsonLd";
+export const exportDate = (date) => {
+    return `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`;
+};
+const isDate = (value) => {
+    const datePattern = /^\d{4}-\d{1,2}-\d{1,2}$/;
+    return datePattern.test(value);
+};
+export const importDate = (str) => {
+    const [y, m, d] = str.split('-').map(s => parseInt(s, 10));
+    if ([y, m, d].some(n => isNaN(n))) {
+        throw new Error(`Invalid date format: "${str}". Expected "YYYY-MM-DD".`);
+    }
+    return new Date(y, m - 1, d);
+};
+const collectEntitiesWithId = (json) => {
+    const result = new Map();
+    // Check if the current object has an `id` property and store it
+    if (json && typeof json === 'object') {
+        if ('@id' in json) {
+            result.set(json['@id'], json);
+        }
+    }
+    // Recursively search within arrays or nested objects
+    for (const key in json) {
+        if (Array.isArray(json[key])) {
+            for (const item of json[key]) {
+                collectEntitiesWithId(item).forEach((v, k) => result.set(k, v));
+            }
+        }
+        else if (typeof json[key] === 'object' && json[key] !== null) {
+            collectEntitiesWithId(json[key]).forEach((v, k) => result.set(k, v));
+        }
+    }
+    return result;
+};
+const fromIDArray = (arr, entities) => {
+    return arr.map(id => {
+        const entity = entities.get(id);
+        if (!entity) {
+            console.warn('Could not find entity with id', id);
+        }
+        return entity;
+    });
+};
+const fromJsonLdEntity = (json, entitiesWithId) => {
+    if (typeof json !== 'object') {
+        return json;
+    }
+    let result = json;
+    if ('@type' in json) {
+        const value = json['@type'];
+        if (value === 'RollCopy') {
+            result = new RollCopy();
+        }
+        else {
+            result['type'] = value;
+        }
+    }
+    for (const [key, value] of Object.entries(json)) {
+        if (key === '@id') {
+            result['id'] = value;
+        }
+        if (typeof value === 'string' && isDate(value)) {
+            console.log('importing date', value);
+            result[key] = importDate(value);
+        }
+        else if ([...referenceTypes, 'premises', 'delete', 'comprehends', 'assigned'].includes(key)) {
+            if (Array.isArray(value) && value.every(e => typeof e === 'string')) {
+                result[key] = fromIDArray(value, entitiesWithId);
+            }
+            else if (typeof value === 'string') {
+                if (isDate(value)) {
+                    console.log('treating', value, 'as date');
+                    result[key] = importDate(value);
+                }
+                else {
+                    if (value.startsWith('1905')) {
+                        console.log('oh no, dealing with a date, but it is treated as a string!', value);
+                    }
+                    const entity = entitiesWithId.get(value);
+                    if (entity) {
+                        result[key] = entity;
+                    }
+                    else {
+                        result[key] = value;
+                    }
+                }
+            }
+        }
+        else if (Array.isArray(value)) {
+            result[key] = value.map(v => {
+                if (typeof v === 'string') {
+                    if (isDate(v)) {
+                        return importDate(v);
+                    }
+                    return v;
+                }
+                else {
+                    return fromJsonLdEntity(v, entitiesWithId);
+                }
+            });
+        }
+        else if (typeof value === 'object') {
+            result[key] = fromJsonLdEntity(value, entitiesWithId);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+};
+export const importJsonLd = (json) => {
+    const entitiesWithId = collectEntitiesWithId(json);
+    const edition = fromJsonLdEntity(json, entitiesWithId);
+    if (Array.isArray(json['@context'])) {
+        edition.base = json['@context'].find((c) => c['@base'])?.['@base'] || '';
+    }
+    return edition;
+};

package/lib/index.d.ts

@@ -0,0 +1,17 @@
+export * from './asJsonLd';
+export * from './Collation';
+export * from './ConditionState';
+export * from './context';
+export * from './Edit';
+export * from './Edition';
+export * from './EditorialAssumption';
+export * from './Emulation';
+export * from './Feature';
+export * from './importJsonLd';
+export * from './PlaceTimeConversion';
+export * from './RollCopy';
+export * from './Version';
+export * from './Symbol';
+export * from './TrackerBar';
+export * from './WithId';
+export * from './alignFeatures';

package/lib/index.js

@@ -0,0 +1,17 @@
+export * from './asJsonLd';
+export * from './Collation';
+export * from './ConditionState';
+export * from './context';
+export * from './Edit';
+export * from './Edition';
+export * from './EditorialAssumption';
+export * from './Emulation';
+export * from './Feature';
+export * from './importJsonLd';
+export * from './PlaceTimeConversion';
+export * from './RollCopy';
+export * from './Version';
+export * from './Symbol';
+export * from './TrackerBar';
+export * from './WithId';
+export * from './alignFeatures';

package/lib/spec/context.json

@@ -0,0 +1,192 @@
+{
+    "@context": {
+        "crm": "http://www.cidoc-crm.org/cidoc-crm/",
+        "lrmoo": "http://iflastandards.info/ns/lrm/lrmoo/",
+        "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
+        "owl": "http://www.w3.org/2002/07/owl#",
+        "reo": "http://linked-rolls.org/reo/",
+        "@vocab": "http://linked-rolls.org/reo/",
+        "C11_Derivation": {
+            "@id": "reo:C11_Derivation",
+            "@context": {
+                "original": {
+                    "@id": "reo:P10_used",
+                    "@type": "@id"
+                }
+            }
+        },
+        "C12_Version": {
+            "@id": "reo:C12_Version",
+            "@context": {
+                "siglum": {
+                    "@id": "reo:P22_is_identified_by",
+                    "@type": "xsd:string"
+                },
+                "witnesses": {
+                    "@id": "reo:P2i_is_witnessed_by",
+                    "@type": "@id"
+                }
+            }
+        },
+        "C13_Version_Creation": {
+            "@id": "reo:C13_Version_Creation",
+            "@context": {
+                "created": {
+                    "@id": "reo:P15_created_version",
+                    "@type": "reo:C12_Version"
+                },
+                "basedOn": {
+                    "@id": "reo:P10i_is_based_on",
+                    "@type": "reo:C11_Derivation"
+                },
+                "edits": {
+                    "@id": "reo:P16_involved_edit",
+                    "@type": "reo:C8_Edit"
+                },
+                "intentions": {
+                    "@id": "reo:P18_was_motivated_by",
+                    "@type": "reo:C9_Assumed_Intention"
+                }
+            }
+        },
+        "C9_Assument_Intention": {
+            "@id": "reo:C9_Assumed_Intention",
+            "@context": {
+                "description": {
+                    "@id": "reo:P23_has_description",
+                    "@type": "xsd:string"
+                },
+                "belief": {
+                    "@id": "crminf:J4i_is_subject_to",
+                    "@type": "crminf:I2_Belief"
+                }
+            }
+        },
+        "crminf:I2_Belief": {
+            "@id": "crminf:I2_Belief",
+            "@context": {
+                "certainty": {
+                    "@id": "crminf:J5_holds_to_be",
+                    "@type": "xsd:string"
+                },
+                "reasons": {
+                    "@id": "crminf:J2i_was_concluded_by",
+                    "@type": "crminf:Argumentation"
+                }
+            }
+        },
+        "C1_Witness": {
+            "@context": {
+                "@base": "copy/",
+                "siglum": {
+                    "@id": "reo:P21_is_identified_by",
+                    "@type": "xsd:string"
+                },
+                "productionEvent": {
+                    "@id": "lrmoo:R28i_was_produced_by",
+                    "@type": "lrmoo:F33_Reproduction_Event",
+                    "@context": {
+                        "date": {
+                            "@id": "crm:P4_has_time-span",
+                            "@type": "xsd:dateTime"
+                        },
+                        "paper": {
+                            "@id": "crm:P126_employed",
+                            "@type": "@id"
+                        },
+                        "company": {
+                            "@id": "crm:P14_was_carried_out_by",
+                            "@type": "@id"
+                        }
+                    }
+                },
+                "location": {
+                    "@id": "crm:P53_has_current_or_former_location",
+                    "@type": "xsd:string"
+                },
+                "measurements": {
+                    "@id": "crm:P39i_was_measured_by",
+                    "@type": "reo:RollMeasurement",
+                    "@context": {
+                        "date": {
+                            "@id": "crm:P4_has_time-span",
+                            "@type": "xsd:dateTime"
+                        },
+                        "software": {
+                            "@id": "crmdig:L23_used_software_or_firmware",
+                            "@type": "@id"
+                        }
+                    }
+                },
+                "events": {
+                    "@id": "crm:P128_carries",
+                    "@context": {
+                        "measurement": {
+                            "@id": "crmdig:L20i_was_created_by",
+                            "@type": "@id"
+                        },
+                        "annotates": {
+                            "@id": "crm:P62i_is_depicted_by",
+                            "@type": "@id"
+                        },
+                        "horizontal": {
+                            "@id": "crm:P43_has_dimension",
+                            "@type": "reo:C5_Event_Span"
+                        },
+                        "vertical": {
+                            "@id": "crm:P43_has_dimension",
+                            "@type": "reo:C5_Event_Span"
+                        }
+                    }
+                }
+            }
+        },
+        "stamp": {
+            "@type": "reo:C7_Stamp",
+            "@context": {
+                "text": {
+                    "@id": "reo:has_text"
+                }
+            }
+        },
+        "publicationEvent": {
+            "@id": "lrmoo:R17i_was_created_by",
+            "@type": "lrmoo:F28_Expression_Creation",
+            "@context": {
+                "publicationDate": {
+                    "@id": "crm:P4_has_time-span",
+                    "@type": "xsd:dateTime"
+                },
+                "publisher": {
+                    "@id": "crm:P14_carried_out_by",
+                    "@type": "crm:E21_Person",
+                    "@context": {
+                        "name": {
+                            "@id": "rdfs:label",
+                            "@type": "xsd:string"
+                        },
+                        "sameAs": {
+                            "@id": "owl:sameAs",
+                            "@type": "@id"
+                        }
+                    }
+                }
+            }
+        },
+        "title": "crm:P102_has_title",
+        "license": {
+            "@id": "crm:P104_is_subject_to",
+            "@type": "@id"
+        },
+        "copies": {
+            "@id": "lrmoo:R2_is_derivative_of",
+            "@type": "reo:C1_Witness"
+        },
+        "collation": "crm:P9_consists_of",
+        "versions": {
+            "@id": "crm:P9_consists_of",
+            "@type": "reo:C13_Version_Creation"
+        },
+        "questions": "crm:P9_consists_of"
+    }
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "linked-rolls",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": ["lib", "README.md", "LICENSE"],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest",
+    "compile:schema": "tsc build-schema.ts --outDir lib --esModuleInterop --skipLibCheck && mv lib/build-schema.js lib/build-schema.cjs",
+    "build:schema": "npm run compile:schema && node lib/build-schema.cjs"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0-dev.20240809",
+    "vite": "^5.0.8",
+    "vitest": "^1.2.0"
+  },
+  "dependencies": {
+    "@types/uuid": "^10.0.0",
+    "aton": "^0.0.4",
+    "fast-xml-parser": "^4.4.1",
+    "midifile-ts": "^1.5.1",
+    "ts-json-schema-generator": "^2.4.0",
+    "uuid": "^10.0.0"
+  }
+}