@rr0/cms 0.2.5 → 0.3.0

package/dist/cms/src/people/PeopleDirectoryStepFactory.js

@@ -0,0 +1,124 @@
+import { RR0FileUtil } from "../util/file/RR0FileUtil.js";
+import { PeopleDirectoryStep, peopleOccupationFilter } from "./PeopleDirectoryStep.js";
+import { glob } from "glob";
+import path from "path";
+import { Occupation } from "@rr0/data";
+/**
+ * Scan directories for people information, then populates a template with collected data.
+ */
+export class PeopleDirectoryStepFactory {
+    constructor(outputFunc, config, service, renderer, excludedDirs) {
+        this.outputFunc = outputFunc;
+        this.config = config;
+        this.service = service;
+        this.renderer = renderer;
+        this.excludedDirs = excludedDirs;
+    }
+    async create(options) {
+        const dirs = RR0FileUtil.findDirectoriesContaining("people*.json", "out");
+        const allPeopleDirectoryStep = this.createAll(dirs, options.root);
+        const letterDirectorySteps = await this.createLetters();
+        const steps = [
+            allPeopleDirectoryStep,
+            ...letterDirectorySteps
+        ];
+        const scientists = options.scientists;
+        if (scientists) {
+            steps.push(this.createScientists(dirs, scientists));
+        }
+        const ufologists = options.ufologists;
+        if (ufologists) {
+            steps.push(this.createUfologists(dirs, ufologists));
+        }
+        const ufoWitnesses = options.ufoWitnesses;
+        if (ufoWitnesses) {
+            steps.push(this.createUfoWitnesses(dirs, ufoWitnesses));
+        }
+        const astronomers = options.astronomers;
+        if (astronomers) {
+            steps.push(this.createAstronomers(dirs, astronomers));
+        }
+        const contactees = options.contactees;
+        if (contactees) {
+            steps.push(this.createContactees(dirs, contactees));
+        }
+        const pilots = options.pilots;
+        if (pilots) {
+            steps.push(this.createPilots(dirs, pilots));
+        }
+        const military = options.military;
+        if (military) {
+            steps.push(this.createMilitary(dirs, military));
+        }
+        const softwareEngineers = options.softwareEngineers;
+        if (softwareEngineers) {
+            steps.push(this.createSoftwareEngineers(dirs, softwareEngineers));
+        }
+        const politicians = options.politicians;
+        if (politicians) {
+            steps.push(...this.createPoliticians(dirs, politicians, options.rulers));
+        }
+        return steps;
+    }
+    async createLetters() {
+        const letterDirs = await glob("people/*/");
+        const peopleLetterFiles = letterDirs.filter(l => /(.+)\/[a-z]$/.test(l));
+        const letterDirectorySteps = [];
+        for (const peopleLetterFile of peopleLetterFiles) {
+            const c = peopleLetterFile.charAt(peopleLetterFile.length - 1);
+            const peopleDir = `people/${c}/`;
+            const peopleDirectoryStep = new PeopleDirectoryStep(`directory of people with name starting with "${c}"`, [peopleDir], [], path.join(peopleDir, "index.html"), this.outputFunc, this.config, this.service, this.renderer, (p) => p.dirName.startsWith(peopleDir));
+            letterDirectorySteps.push(peopleDirectoryStep);
+        }
+        return letterDirectorySteps;
+    }
+    createAll(dirs, templateFileName) {
+        return new PeopleDirectoryStep("all people directories", dirs, this.excludedDirs, templateFileName, this.outputFunc, this.config, this.service, this.renderer);
+    }
+    createMilitary(dirs, templateFileName) {
+        return new PeopleDirectoryStep("military people directories", dirs, this.excludedDirs, templateFileName, this.outputFunc, this.config, this.service, this.renderer, peopleOccupationFilter([Occupation.military]));
+    }
+    createPoliticians(dirs, templateFileName, rulersTemplateFileName) {
+        const steps = [
+            new PeopleDirectoryStep("politicians directories", dirs, this.excludedDirs, templateFileName, this.outputFunc, this.config, this.service, this.renderer, peopleOccupationFilter([Occupation.politician]))
+        ];
+        if (rulersTemplateFileName) {
+            steps.push(new PeopleDirectoryStep("politician leaders directories", dirs, this.excludedDirs, rulersTemplateFileName, this.outputFunc, this.config, this.service, this.renderer, peopleOccupationFilter([Occupation.leader])));
+        }
+        return steps;
+    }
+    createSoftwareEngineers(dirs, templateFileName) {
+        return new PeopleDirectoryStep("software engineers directories", dirs, this.excludedDirs, templateFileName, this.outputFunc, this.config, this.service, this.renderer, peopleOccupationFilter([Occupation.softwareEngineer]));
+    }
+    createPilots(dirs, templateFileName) {
+        return new PeopleDirectoryStep("pilots directories", dirs, this.excludedDirs, templateFileName, this.outputFunc, this.config, this.service, this.renderer, peopleOccupationFilter([Occupation.astronaut, Occupation.pilot]));
+    }
+    createContactees(dirs, templateFileName) {
+        return new PeopleDirectoryStep("contactees directories", dirs, this.excludedDirs, templateFileName, this.outputFunc, this.config, this.service, this.renderer, peopleOccupationFilter([Occupation.contactee]));
+    }
+    createAstronomers(dirs, templateFileName) {
+        return new PeopleDirectoryStep("astronomers directories", dirs, this.excludedDirs, templateFileName, this.outputFunc, this.config, this.service, this.renderer, peopleOccupationFilter([Occupation.astronomer]));
+    }
+    createUfoWitnesses(dirs, templateFileName) {
+        return new PeopleDirectoryStep(`UFO witnesses directories`, dirs, this.excludedDirs, templateFileName, this.outputFunc, this.config, this.service, this.renderer, peopleOccupationFilter([Occupation.ufoWitness, Occupation.ufoWitness2, Occupation.abductee, Occupation.contactee]));
+    }
+    createUfologists(dirs, templateFileName) {
+        return new PeopleDirectoryStep("ufologists directories", dirs, this.excludedDirs, templateFileName, this.outputFunc, this.config, this.service, this.renderer, peopleOccupationFilter([Occupation.ufologist]));
+    }
+    createScientists(dirs, templateFileName) {
+        return new PeopleDirectoryStep("scientists directories", dirs, this.excludedDirs, templateFileName, this.outputFunc, this.config, this.service, this.renderer, peopleOccupationFilter([
+            Occupation.anthropologist, Occupation.astronomer, Occupation.astrophysicist, Occupation.archeologist,
+            Occupation.biochemist, Occupation.biologist, Occupation.biophysicist, Occupation.botanist,
+            Occupation.chemist,
+            Occupation.engineer, Occupation.exobiologist, Occupation.ethnologist,
+            Occupation.geophysicist, Occupation.geologist, Occupation.geographer,
+            Occupation.historian,
+            Occupation.mathematician, Occupation.meteorologist,
+            Occupation.neuroscientist, Occupation.neurologist, Occupation.neuropsychiatrist,
+            Occupation.oceanographer,
+            Occupation.philosopher, Occupation.psychologist, Occupation.physicist, Occupation.psychiatrist,
+            Occupation.radioastronomer,
+            Occupation.sociologist
+        ]));
+    }
+}

package/dist/cms/src/people/PeopleFactory.test.js

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "@javarome/testscript";
+import { CountryCode, Occupation, People, PeopleFactory, RR0EventFactory } from "@rr0/data";
+describe("PeopleFactory", () => {
+    const eventFactory = new RR0EventFactory();
+    const factory = new PeopleFactory(eventFactory);
+    test("build people with two first names", () => {
+        const villaJson = {
+            "birthTime": "1916-09-24",
+            "deathTime": "1980-11-22",
+            "occupations": [
+                "contactee",
+                "mechanic"
+            ],
+            "countries": [
+                "us"
+            ],
+            "pseudonyms": [
+                "Paul Villa"
+            ]
+        };
+        const parsed = factory.parse(villaJson);
+        const expected = new People(undefined, undefined, ["Paul Villa"], [Occupation.contactee, Occupation.mechanic], [CountryCode.us], true);
+        expect(parsed).toEqual(expected);
+    });
+});

package/dist/cms/src/people/PeopleHtmlRenderer.d.ts

@@ -0,0 +1,7 @@
+import { HtmlRR0Context } from "../RR0Context.js";
+import { CountryCode, Occupation, People } from "@rr0/data";
+export declare class PeopleHtmlRenderer {
+    protected defaultPreviewFileNames: string[];
+    constructor(defaultPreviewFileNames?: string[]);
+    renderLink(context: HtmlRR0Context, people: People, pseudoPeopleList: People[], allCountries: Set<CountryCode>, occupations: Set<Occupation>, filterOccupations?: Occupation[], content?: string): HTMLElement;
+}

package/dist/cms/src/people/PeopleRegexReplaceCommand.test.js

@@ -0,0 +1,19 @@
+import path from "path";
+import { ClassDomReplaceCommand } from "ssg-api";
+import { describe, expect, test } from "@javarome/testscript";
+import { PeopleReplacerFactory } from "./PeopleReplacerFactory.js";
+import { rr0TestUtil } from "../test/index.js";
+import { PeopleHtmlRenderer } from "./PeopleHtmlRenderer.js";
+import { PeopleService } from "@rr0/data";
+describe("ClassDomReplaceCommand", () => {
+    test("replaces", async () => {
+        const peopleRoot = "src/people";
+        const peopleFiles = [path.join(peopleRoot, "b/BeauJerome")];
+        const peopleRenderer = new PeopleHtmlRenderer();
+        const peopleService = new PeopleService(rr0TestUtil.dataService, rr0TestUtil.peopleFactory, { files: peopleFiles, rootDir: peopleRoot });
+        const command = new ClassDomReplaceCommand(new PeopleReplacerFactory(peopleService, peopleRenderer), "people");
+        const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08/index.html", `<span class="people">Jérôme Beau</span>`);
+        await command.execute(context);
+        expect(context.file.contents).toBe(`<html><head></head><body><span title="1972-, 50 ans, France, ufologue, Informaticien" class="country-fr occupation-ufologist occupation-softwareEngineer" translate="no"><a href="/src/people/b/BeauJerome/">Jérôme Beau</a></span></body></html>`);
+    });
+});

package/dist/cms/src/people/PeopleReplacer.d.ts

@@ -0,0 +1,10 @@
+import { DomReplacement } from "../time/DomReplacement.js";
+import { HtmlRR0Context } from "../RR0Context.js";
+import { PeopleHtmlRenderer } from "./PeopleHtmlRenderer";
+import { PeopleService } from "@rr0/data";
+export declare class PeopleReplacer implements DomReplacement<HtmlRR0Context> {
+    protected service: PeopleService;
+    protected renderer: PeopleHtmlRenderer;
+    constructor(service: PeopleService, renderer: PeopleHtmlRenderer);
+    replacement(context: HtmlRR0Context, element: HTMLElement): Promise<HTMLElement>;
+}

package/dist/cms/src/people/PeopleReplacer.test.js

@@ -0,0 +1,61 @@
+import { PeopleReplacer } from "./PeopleReplacer.js";
+import { rr0TestUtil, testFilePath } from "../test/index.js";
+import { describe, expect, test } from "@javarome/testscript";
+import path from "path";
+import { AllDataService, PeopleFactory, PeopleService, RR0EventFactory } from "@rr0/data";
+import { PeopleHtmlRenderer } from "./PeopleHtmlRenderer";
+describe("PeopleReplacer", () => {
+    const rootDir = testFilePath("people");
+    const files = [
+        path.join(rootDir, "b/BeauJerome"),
+        path.join(rootDir, "h/HynekJosefAllen")
+    ];
+    const peopleFactory = new PeopleFactory(new RR0EventFactory());
+    function createPeopleElement(context, content, title) {
+        const peopleElement = context.file.document.createElement("span");
+        peopleElement.textContent = content;
+        if (title) {
+            peopleElement.title = title;
+        }
+        return peopleElement;
+    }
+    test("ignore brackets", async () => {
+        const dataService = new AllDataService([peopleFactory]);
+        const peopleService = new PeopleService(dataService, peopleFactory, { rootDir, files });
+        const peopleRenderer = new PeopleHtmlRenderer();
+        const replacer = new PeopleReplacer(peopleService, peopleRenderer);
+        const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+        {
+            const lastnameFirstElement = createPeopleElement(context, "Hynek, Josef Allen (Northwestern University, Evanston, Illinois)");
+            const replacement = await replacer.replacement(context, lastnameFirstElement);
+            expect(replacement.outerHTML).toBe(`<span title="1910-1986, 76 ans, USA, ufologue, astronome" class="deceased country-us occupation-ufologist occupation-astronomer" translate="no"><a href="/src/people/h/HynekJosefAllen/">Hynek, Josef Allen (Northwestern University, Evanston, Illinois)</a></span>`);
+        }
+        {
+            const firstnameFirstElement = createPeopleElement(context, "Josef Allen Hynek (Northwestern University, Evanston, Illinois)");
+            const replacement = await replacer.replacement(context, firstnameFirstElement);
+            expect(replacement.outerHTML).toBe(`<span title="1910-1986, 76 ans, USA, ufologue, astronome" class="deceased country-us occupation-ufologist occupation-astronomer" translate="no"><a href="/src/people/h/HynekJosefAllen/">Josef Allen Hynek (Northwestern University, Evanston, Illinois)</a></span>`);
+        }
+    });
+    test("replace people tags", async () => {
+        const dataService = new AllDataService([peopleFactory]);
+        const peopleService = new PeopleService(dataService, peopleFactory, { rootDir, files });
+        const peopleRenderer = new PeopleHtmlRenderer();
+        const replacer = new PeopleReplacer(peopleService, peopleRenderer);
+        const context = rr0TestUtil.time.newHtmlContext("1/9/9/0/08/index.html", "");
+        {
+            const peopleWithTitle = createPeopleElement(context, "Ronald Reagan", "Ronald Wilson Reagan");
+            let replacement = await replacer.replacement(context, peopleWithTitle);
+            expect(replacement.outerHTML).toBe(`<span translate="no"><a href="/src/people/r/ReaganRonald/">Ronald Reagan</a></span>`);
+        }
+        {
+            const peopleWithFullName = createPeopleElement(context, "Jérôme Beau");
+            let replacement = await replacer.replacement(context, peopleWithFullName);
+            expect(replacement.outerHTML).toBe(`<span title="1972-, 50 ans, France, ufologue, Informaticien" class="country-fr occupation-ufologist occupation-softwareEngineer" translate="no"><a href="/src/people/b/BeauJerome/">Jérôme Beau</a></span>`);
+        }
+        {
+            const peopleWithLastName = createPeopleElement(context, "Beau");
+            let replacement = await replacer.replacement(context, peopleWithLastName);
+            expect(replacement.outerHTML).toBe(`<span title="1972-, 50 ans, France, ufologue, Informaticien" class="country-fr occupation-ufologist occupation-softwareEngineer" translate="no" title="Jérôme Beau"><a href="/src/people/b/BeauJerome/" title="Jérôme Beau">Beau</a></span>`);
+        }
+    });
+});

package/dist/cms/src/people/PeopleReplacerFactory.d.ts

@@ -0,0 +1,16 @@
+import { PeopleReplacer } from "./PeopleReplacer.js";
+import { DomReplacer, ReplacerFactory } from "ssg-api";
+import { HtmlRR0Context } from "../RR0Context.js";
+import { PeopleHtmlRenderer } from "./PeopleHtmlRenderer";
+import { PeopleService } from "@rr0/data";
+/**
+ * Creates replacers for people HTML in a given context.
+ */
+export declare class PeopleReplacerFactory implements ReplacerFactory<DomReplacer> {
+    protected service: PeopleService;
+    protected renderer: PeopleHtmlRenderer;
+    protected singleton?: PeopleReplacer;
+    constructor(service: PeopleService, renderer: PeopleHtmlRenderer);
+    create(context: HtmlRR0Context): Promise<DomReplacer>;
+    protected getInstance(): Promise<PeopleReplacer>;
+}

package/dist/cms/src/people/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./author/index.js";
+export * from "./witness/index.js";
+export * from "../../../data/src/people/Occupation.js";
+export * from "./OccupationMessages.js";
+export * from "../../../data/src/people/People.js";
+export * from "./PeopleDirectoryStep.js";
+export * from "./PeopleDirectoryStepFactory.js";
+export * from "../../../data/src/people/PeopleFactory.js";
+export * from "./PeopleMessages.js";
+export * from "./PeopleMessages_en.js";
+export * from "./PeopleMessages_fr.js";
+export * from "./PeopleReplacer.js";
+export * from "./PeopleReplacerFactory.js";
+export * from "../../../data/src/people/PeopleService.js";

package/dist/cms/src/people/index.js

@@ -0,0 +1,14 @@
+export * from "./author/index.js";
+export * from "./witness/index.js";
+export * from "../../../data/src/people/Occupation.js";
+export * from "./OccupationMessages.js";
+export * from "../../../data/src/people/People.js";
+export * from "./PeopleDirectoryStep.js";
+export * from "./PeopleDirectoryStepFactory.js";
+export * from "../../../data/src/people/PeopleFactory.js";
+export * from "./PeopleMessages.js";
+export * from "./PeopleMessages_en.js";
+export * from "./PeopleMessages_fr.js";
+export * from "./PeopleReplacer.js";
+export * from "./PeopleReplacerFactory.js";
+export * from "../../../data/src/people/PeopleService.js";

package/dist/cms/src/place/OrganizationPlace.d.ts

@@ -0,0 +1,6 @@
+import { CmsOrganization } from "../org";
+import { Place } from "@rr0/place";
+export declare class OrganizationPlace extends Place {
+    readonly org: CmsOrganization;
+    constructor(org: CmsOrganization);
+}

package/dist/cms/src/place/PlaceReplacer.test.js

@@ -0,0 +1,89 @@
+import { PlaceReplacer } from "./PlaceReplacer.js";
+import { OrganizationService } from "../org/OrganizationService.js";
+import { rr0TestUtil } from "../test/index.js";
+import { describe, expect, test } from "@javarome/testscript";
+import { OrganizationMessages } from "../org/index.js";
+import { Place, PlaceLocation, PlaceService } from "@rr0/place";
+import { OrganizationKind } from "../../../data/src/org/OrganizationKind";
+class MockPlaceService extends PlaceService {
+    constructor(location, elevation, dirName) {
+        super("place");
+        this.location = location;
+        this.elevation = elevation;
+        this.dirName = dirName;
+    }
+    async read(fileName) {
+        return new Place([this.location], this.elevation, this.dirName);
+    }
+    async geocode(address) {
+        return { location: this.location, data: {} };
+    }
+    async getElevation(location) {
+        return this.elevation;
+    }
+}
+class MockOrganizationService extends OrganizationService {
+    constructor(dirName) {
+        super([], "org", rr0TestUtil.orgFactory, null);
+        this.dirName = dirName;
+    }
+    async read(_fileName) {
+        let title = "Los Alamos National Laboratories";
+        return {
+            type: "org",
+            kind: OrganizationKind.company,
+            id: "laln",
+            dirName: this.dirName,
+            getTitle(_context) {
+                return title;
+            },
+            places: [new Place([new PlaceLocation(35.87555555555556, -106.32416666666666)])],
+            getMessages: (_context) => new OrganizationMessages([title]),
+            events: []
+        };
+    }
+}
+describe("PlaceReplacer", () => {
+    function createPlaceTag(doc, text) {
+        const placeTag = doc.createElement("span");
+        placeTag.className = "place";
+        placeTag.innerHTML = text;
+        return placeTag;
+    }
+    test("link to existing organization", async () => {
+        return; // Disable test
+        const location = new PlaceLocation(35.8440582, -106.287162);
+        const elevation = 2161.025390625;
+        const dirName = "org/us/state/nm/lanl/";
+        const placeService = new MockPlaceService(location, { elevation }, dirName);
+        const orgService = new MockOrganizationService(dirName);
+        const replacer = new PlaceReplacer();
+        const context = rr0TestUtil.newHtmlContext("people/a/AlexanderJohnB/index.html", "");
+        const doc = context.file.document;
+        const text = "LANL";
+        const placeTag = createPlaceTag(doc, text);
+        const replacement = await replacer.replacement(context, placeTag);
+        expect(replacement.tagName).toBe("A");
+        expect(replacement.className).toBe("plac");
+        expect(replacement.href).toBe(`/${dirName}`);
+        expect(replacement.textContent).toBe(text);
+        expect(replacement.getAttribute("onclick")).toBe(`showMap(event,${location.lat},${location.lng},true)`);
+    });
+    test("link to non-existing organization", async () => {
+        const location = new PlaceLocation(34.0, -105.0);
+        const elevation = 100.0;
+        const dirName = "";
+        const placeService = new MockPlaceService(location, { elevation }, dirName);
+        const orgService = new MockOrganizationService(dirName);
+        const replacer = new PlaceReplacer();
+        const context = rr0TestUtil.newHtmlContext("people/a/AlexanderJohnB/index.html", "");
+        const doc = context.file.document;
+        const text = "Non existing";
+        const placeTag = createPlaceTag(doc, text);
+        const replacement = await replacer.replacement(context, placeTag);
+        expect(replacement.tagName).toBe("SPAN");
+        expect(replacement.className).toBe("plac");
+        expect(replacement.textContent).toBe(text);
+        expect(replacement.getAttribute("onclick")).toBe(`showMap(event,'${text}',true)`);
+    });
+});

package/dist/cms/src/test/RR0TestUtil.d.ts

@@ -0,0 +1,29 @@
+import { HtmlRR0Context, RR0Context } from "../RR0Context.js";
+import { FileWriteConfig } from "ssg-api";
+import { CityService, DepartmentService, OrganizationFactory, OrganizationService, RegionService } from "../org/index.js";
+import { CaseFactory } from "../science/index.js";
+import { TimeTestUtil } from "../time/TimeTestUtil";
+import { AllDataService, PeopleFactory } from "@rr0/data";
+import { CountryService } from "../org/country/CountryService";
+export declare class RR0TestUtil {
+    readonly rootDir: string;
+    readonly outDir: string;
+    readonly config: FileWriteConfig;
+    readonly intlOptions: Intl.DateTimeFormatOptions;
+    readonly dataService: AllDataService;
+    readonly caseFactory: CaseFactory;
+    readonly peopleFactory: PeopleFactory;
+    readonly time: TimeTestUtil;
+    readonly orgService: OrganizationService<any, undefined>;
+    readonly cityService: CityService;
+    readonly orgFactory: OrganizationFactory;
+    readonly departmentService: DepartmentService;
+    readonly countryService: CountryService;
+    readonly regionService: RegionService;
+    constructor(rootDir?: string, outDir?: string);
+    newContext(inputFileName: string, contents?: string, locale?: string): RR0Context;
+    filePath(inputFileName: string): string;
+    newHtmlContext(inputFileName: string, contents?: string, locale?: string): HtmlRR0Context;
+}
+export declare const rr0TestUtil: RR0TestUtil;
+export declare function testFilePath(filePath: string): string;

package/dist/cms/src/test/RR0TestUtil.js

@@ -0,0 +1,80 @@
+import path from "path";
+import { RR0ContextImpl } from "../RR0Context.js";
+import { HtmlFileContents } from "ssg-api";
+import { cities, CityService, countries, departments, DepartmentService, OrganizationFactory, OrganizationService, regions, RegionService } from "../org/index.js";
+import { CaseFactory } from "../science/index.js";
+import { APIFactory } from "../tech/index.js";
+import { TimeTestUtil } from "../time/TimeTestUtil";
+import { TimeContext } from "@rr0/time";
+import { FileContents } from "@javarome/fileutil";
+import { AllDataService, EventDataFactory, PeopleFactory, RR0EventFactory, TypedDataFactory } from "@rr0/data";
+import { CountryService } from "../org/country/CountryService";
+export class RR0TestUtil {
+    constructor(rootDir = "test", outDir = "out") {
+        this.rootDir = rootDir;
+        this.outDir = outDir;
+        this.config = {
+            getOutputPath: (context) => {
+                return path.join(this.outDir, context.file.name);
+            }
+        };
+        this.intlOptions = {
+            year: "numeric",
+            month: "long",
+            day: "numeric",
+            weekday: "long",
+            hour: "2-digit",
+            minute: "2-digit",
+            timeZoneName: "short"
+        };
+        const eventFactory = new RR0EventFactory();
+        const sightingFactory = new EventDataFactory(eventFactory, "sighting", ["index"]);
+        const orgFactory = this.orgFactory = new OrganizationFactory(eventFactory);
+        this.orgService = new OrganizationService([], "org", orgFactory, undefined);
+        this.caseFactory = new CaseFactory(eventFactory);
+        this.peopleFactory = new PeopleFactory(eventFactory);
+        const apiFactory = new APIFactory(eventFactory);
+        const bookFactory = new TypedDataFactory(eventFactory, "book");
+        const articleFactory = new TypedDataFactory(eventFactory, "article");
+        this.dataService = new AllDataService([orgFactory, this.caseFactory, this.peopleFactory, bookFactory, articleFactory, sightingFactory, apiFactory]);
+        this.dataService.getFromDir("", ["people", "case"]).then(data => {
+            //   console.debug(data)
+        });
+        this.time = new TimeTestUtil(this);
+        const countryService = this.countryService = new CountryService(countries, "org", orgFactory, undefined);
+        const regionService = this.regionService = new RegionService(regions, "org", orgFactory, countryService);
+        const departmentService = this.departmentService = new DepartmentService(departments, "org", orgFactory, regionService);
+        this.cityService = new CityService(cities, "org", orgFactory, departmentService);
+    }
+    newContext(inputFileName, contents, locale = "fr") {
+        const context = new RR0ContextImpl(locale, new TimeContext(), this.config);
+        if (contents !== undefined && contents != null) {
+            const langInfo = FileContents.getLang(inputFileName);
+            context.file = new FileContents(inputFileName, "utf8", contents, new Date(), langInfo);
+        }
+        else {
+            context.file = FileContents.read(inputFileName);
+        }
+        context.file = context.file; // By default
+        return context;
+    }
+    filePath(inputFileName) {
+        return path.join(this.rootDir, inputFileName);
+    }
+    newHtmlContext(inputFileName, contents, locale = "fr") {
+        const context = this.newContext(this.filePath(inputFileName), contents, locale);
+        const titleExec = /<title>(.*)<\/title>/.exec(contents);
+        const title = titleExec && titleExec.length > 0 ? titleExec[1].trim() : undefined;
+        const currentFile = context.file;
+        const lang = currentFile.lang;
+        context.file = new HtmlFileContents(currentFile.name, currentFile.encoding, currentFile.contents, currentFile.lastModified, lang, { author: [] }, {}, title);
+        const htmlContext = context;
+        const timeContext = this.time.getService().contextFromFileName(htmlContext, inputFileName);
+        Object.assign(htmlContext.time, timeContext);
+        return htmlContext;
+    }
+}
+export const rr0TestUtil = new RR0TestUtil();
+export function testFilePath(filePath) {
+    return path.join(rr0TestUtil.rootDir, filePath);
+}

package/dist/cms/src/time/datasource/nuforc/NuforcRR0Mapper.d.ts

@@ -0,0 +1,24 @@
+import { CaseMapper } from "../CaseMapper.js";
+import { NuforcCaseSummary } from "./NuforcCaseSummary.js";
+import { HtmlRR0Context } from "../../../RR0Context.js";
+import { NuforcCountry } from "./NuforcCountry.js";
+import { RR0CaseSummary } from "../rr0/RR0CaseSummary.js";
+import { NuforcShape } from "./NuforcShape.js";
+import { CityService } from "../../../org/country/index.js";
+import { CountryService } from "../../../org/country/CountryService";
+export declare class NuforcRR0Mapper implements CaseMapper<HtmlRR0Context, NuforcCaseSummary, RR0CaseSummary> {
+    protected cityService: CityService;
+    protected countryService: CountryService;
+    readonly baseUrl: string;
+    readonly copyright: string;
+    readonly authors: string[];
+    static readonly countryMap: {
+        [key in NuforcCountry]: string;
+    };
+    readonly translations: {
+        [key in NuforcShape]: string;
+    };
+    constructor(cityService: CityService, countryService: CountryService, baseUrl: string, copyright: string, authors: string[]);
+    getDescription(c: NuforcCaseSummary): string;
+    map(context: HtmlRR0Context, sourceCase: NuforcCaseSummary, sourceTime: Date): RR0CaseSummary;
+}

package/dist/cms/src/time/datasource/nuforc/NuforcRR0Mapping.d.ts

@@ -0,0 +1,14 @@
+import { NuforcRR0Mapper } from "./NuforcRR0Mapper.js";
+import { NuforcHttpDatasource } from "./NuforcHttpDatasource.js";
+import { CityService } from "../../../org";
+import { RR0CaseMapping } from "../rr0";
+import { ChronologyReplacerActions } from "../ChronologyReplacerActions";
+import { NuforcCaseSummary } from "./NuforcCaseSummary";
+import { CountryService } from "../../../org/country/CountryService";
+export declare const nuforcDatasource: NuforcHttpDatasource;
+export declare class NuforcRR0Mapping implements RR0CaseMapping<NuforcCaseSummary> {
+    readonly actions: ChronologyReplacerActions;
+    datasource: NuforcHttpDatasource;
+    mapper: NuforcRR0Mapper;
+    constructor(cityService: CityService, countryService: CountryService, actions: ChronologyReplacerActions);
+}

package/dist/cms/src/time/datasource/urecat/UrecatRR0Mapper.d.ts

@@ -0,0 +1,16 @@
+import { CaseMapper } from "../CaseMapper.js";
+import { UrecatCase } from "./UrecatCase.js";
+import { HtmlRR0Context } from "../../../RR0Context.js";
+import { RR0CaseSummary } from "../rr0/RR0CaseSummary.js";
+import { CityService } from "../../../org/country/index.js";
+import { CountryService } from "../../../org/country/CountryService";
+export declare class UrecatRR0Mapper implements CaseMapper<HtmlRR0Context, UrecatCase, RR0CaseSummary> {
+    protected cityService: CityService;
+    protected countryService: CountryService;
+    readonly baseUrl: URL;
+    readonly copyright: string;
+    readonly authors: string[];
+    constructor(cityService: CityService, countryService: CountryService, baseUrl: URL, copyright: string, authors: string[]);
+    getDescription(c: UrecatCase): string;
+    map(context: HtmlRR0Context, sourceCase: UrecatCase, sourceTime: Date): RR0CaseSummary;
+}

package/dist/cms/src/time/datasource/urecat/UrecatRR0Mapping.d.ts

@@ -0,0 +1,14 @@
+import { UrecatRR0Mapper } from "./UrecatRR0Mapper.js";
+import { UrecatHttpDatasource } from "./UrecatHttpDatasource.js";
+import { ChronologyReplacerActions } from "../ChronologyReplacerActions.js";
+import { RR0CaseMapping } from "../rr0";
+import { UrecatCase } from "./UrecatCase";
+import { CityService } from "../../../org";
+import { CountryService } from "../../../org/country/CountryService";
+export declare const urecatDatasource: UrecatHttpDatasource;
+export declare class UrecatRR0Mapping implements RR0CaseMapping<UrecatCase> {
+    readonly actions: ChronologyReplacerActions;
+    datasource: UrecatHttpDatasource;
+    mapper: UrecatRR0Mapper;
+    constructor(cityService: CityService, countryService: CountryService, actions: ChronologyReplacerActions);
+}

package/dist/data/src/AbstractDataFactory.d.ts

@@ -0,0 +1,16 @@
+import { RR0Data } from "./RR0Data.js";
+import { RR0DataFactory } from "./RR0DataFactory.js";
+import { RR0DataJson } from "./RR0DataJson.js";
+import { RR0Event, RR0EventFactory, RR0EventJson } from "./event/index.js";
+export declare abstract class AbstractDataFactory<T extends RR0Data, J extends RR0DataJson> implements RR0DataFactory<T> {
+    protected eventFactory: RR0EventFactory;
+    protected previewFileNames: string[];
+    static readonly defaultPreviewFileNames: string[];
+    /**
+     * @param eventFactory The factory to create sub-events.
+     * @param previewFileNames
+     */
+    protected constructor(eventFactory: RR0EventFactory, previewFileNames?: string[]);
+    parse(dataJson: J): T;
+    parseEvents(jsonEvents: RR0EventJson[], defaultParent: RR0Data): RR0Event[];
+}