338 lines
13 KiB
JavaScript
338 lines
13 KiB
JavaScript
"use strict";
|
|
|
|
import { CmapModel } from "../../cmap/model/concept-map.js";
|
|
|
|
/** Manage loading, persistence workflows and metadata of stored concept maps. */
|
|
export class CmapMapController {
|
|
constructor({ state, repository, referenceIndex, canonicalPageReference,
|
|
normalizeConceptName, renderSelector, getEditor, resetEditor,
|
|
getCurrentStorageMap, save, markSaved, cancelAutosave, hasUnsavedChanges,
|
|
status, translate, cmapRoute, navigateToHash, navigateToMap, refreshPageConnections }) {
|
|
this.state = state;
|
|
this.repository = repository;
|
|
this.referenceIndex = referenceIndex;
|
|
this.canonicalPageReference = canonicalPageReference;
|
|
this.normalizeConceptName = normalizeConceptName;
|
|
this.renderSelector = renderSelector;
|
|
this.getEditor = getEditor;
|
|
this.resetEditor = resetEditor;
|
|
this.getCurrentStorageMap = getCurrentStorageMap;
|
|
this.save = save;
|
|
this.markSaved = markSaved;
|
|
this.cancelAutosave = cancelAutosave;
|
|
this.hasUnsavedChanges = hasUnsavedChanges;
|
|
this.status = status;
|
|
this.translate = translate;
|
|
this.cmapRoute = cmapRoute;
|
|
this.navigateToHash = navigateToHash;
|
|
this.navigateToMap = navigateToMap;
|
|
this.refreshPageConnections = refreshPageConnections;
|
|
}
|
|
|
|
async loadMaps() {
|
|
const [conceptMaps, placements] = await Promise.all([
|
|
this.repository.list(),
|
|
this.repository.conceptUsage().catch((error) => {
|
|
console.warn("[racket-wiki:cmap-host 0.2.122] concept usage is unavailable; CMaps continue without global counts", error);
|
|
return [];
|
|
})
|
|
]);
|
|
this.state.conceptMaps = conceptMaps;
|
|
this.referenceIndex.load(
|
|
placements,
|
|
conceptMaps,
|
|
this.canonicalPageReference,
|
|
this.normalizeConceptName);
|
|
this.state.cmapConceptUsage = this.referenceIndex.byConceptId;
|
|
this.state.cmapConceptIdsByName = this.referenceIndex.byName;
|
|
this.state.cmapPageConcepts = this.referenceIndex.byPage;
|
|
this.renderSelector();
|
|
const editor = this.getEditor();
|
|
if (editor) editor.refreshConceptUsageIndicators();
|
|
if (this.state.currentPage) this.refreshPageConnections(this.state.currentPage);
|
|
return this.state.conceptMaps;
|
|
}
|
|
|
|
updateSummary(conceptMap) {
|
|
const summary = typeof conceptMap.toSummary === "function" ?
|
|
conceptMap.toSummary() : conceptMap;
|
|
const index = this.state.conceptMaps.findIndex((item) => item.slug === conceptMap.slug);
|
|
if (index >= 0) {
|
|
this.state.conceptMaps[index] = { ...this.state.conceptMaps[index], ...summary };
|
|
} else {
|
|
this.state.conceptMaps.push(summary);
|
|
}
|
|
this.renderSelector();
|
|
}
|
|
|
|
async open(slug) {
|
|
if (!slug) return;
|
|
const loadSequence = ++this.state.cmapLoadSequence;
|
|
this.status(this.translate("loading", "Loading…"));
|
|
const conceptMap = await this.repository.load(slug);
|
|
if (loadSequence !== this.state.cmapLoadSequence) return;
|
|
const derivedView = conceptMap.model.derivedView();
|
|
let sourceMap = null;
|
|
let editorModel = conceptMap.model;
|
|
if (derivedView && typeof derivedView === "object" &&
|
|
typeof derivedView.sourceCmapSlug === "string" && derivedView.sourceCmapSlug &&
|
|
Number.isInteger(Number(derivedView.rootItemId))) {
|
|
sourceMap = await this.repository.load(derivedView.sourceCmapSlug);
|
|
if (loadSequence !== this.state.cmapLoadSequence) return;
|
|
editorModel = sourceMap.model;
|
|
}
|
|
console.info("[racket-wiki:cmap-host 0.2.122] stored CMap received", {
|
|
slug: conceptMap.slug,
|
|
version: conceptMap.currentVersion,
|
|
itemCount: conceptMap.model.conceptMap.items().length,
|
|
connectorCount: conceptMap.model.conceptMap.connectors().length
|
|
});
|
|
this.state.currentConceptMap = conceptMap;
|
|
this.state.currentConceptMapSource = sourceMap;
|
|
this.renderSelector();
|
|
this.resetEditor(editorModel, false);
|
|
if (sourceMap) this.openDerivedView(conceptMap, derivedView);
|
|
this.markSaved();
|
|
const editor = this.getEditor();
|
|
console.info("[racket-wiki:cmap-host 0.2.122] stored CMap loaded", {
|
|
slug: conceptMap.slug,
|
|
editorAvailable: Boolean(editor),
|
|
itemCount: editor ? editor.itemCount() : 0,
|
|
connectorCount: editor ? editor.connectorCount() : 0
|
|
});
|
|
this.status(this.translate("concept-map-loaded", "CMap loaded"), true);
|
|
}
|
|
|
|
openDerivedView(conceptMap, derivedView) {
|
|
const editor = this.getEditor();
|
|
const root = editor.itemRecord(derivedView.rootItemId);
|
|
if (!root || root.kind !== "submap") {
|
|
throw new Error("The source sub-CMap no longer exists.");
|
|
}
|
|
root.separateMap = true;
|
|
root.cmapSlug = conceptMap.slug;
|
|
root.childMap = conceptMap.title;
|
|
if (!root.mapReference) {
|
|
root.mapReference = {
|
|
id: `cmap-${root.id}`,
|
|
title: conceptMap.title,
|
|
rootItemId: root.id,
|
|
itemIds: editor.descendantItemRecords(root).map((item) => item.id)
|
|
};
|
|
editor.setConceptMapReference(root.mapReference);
|
|
}
|
|
editor.openSubmapMap(root);
|
|
}
|
|
|
|
async loadHistoricalVersion(version) {
|
|
const conceptMap = this.getCurrentStorageMap();
|
|
if (!conceptMap) return;
|
|
const historical = await this.repository.loadVersion(conceptMap, version);
|
|
const currentSnapshot = JSON.stringify(conceptMap.toDocument());
|
|
this.resetEditor(historical.model, false);
|
|
this.state.cmapSavedSnapshot = currentSnapshot;
|
|
this.status(
|
|
this.translate("concept-map-version-loaded", "Version {version} loaded; save to make it current.")
|
|
.replace("{version}", String(historical.version)),
|
|
true);
|
|
}
|
|
|
|
async create() {
|
|
const title = window.prompt(this.translate("concept-map-name", "Concept map name"), "");
|
|
if (!title || !title.trim()) return;
|
|
const conceptMap = await this.repository.create(title.trim(), new CmapModel());
|
|
await this.loadMaps();
|
|
location.hash = this.cmapRoute(conceptMap.slug);
|
|
}
|
|
|
|
async promoteSelectedSubmap() {
|
|
const editor = this.getEditor();
|
|
const record = editor ? editor.selected() : null;
|
|
if (!record || record.kind !== "submap") return false;
|
|
const hasConcepts = editor.descendantItemRecords(record)
|
|
.some((item) => item.kind !== "phrase");
|
|
if (!hasConcepts) {
|
|
this.status(this.translate("empty-submap", "This sub-CMap has no concepts to move."));
|
|
return false;
|
|
}
|
|
|
|
const sourceMap = this.getCurrentStorageMap();
|
|
let linkedMap = null;
|
|
let title = null;
|
|
if (record.cmapSlug) {
|
|
linkedMap = this.state.currentConceptMap?.slug === record.cmapSlug ?
|
|
this.state.currentConceptMap : await this.repository.load(record.cmapSlug);
|
|
const derivedView = linkedMap.model.derivedView();
|
|
const matchesSource = sourceMap && derivedView &&
|
|
derivedView.sourceCmapSlug === sourceMap.slug &&
|
|
Number(derivedView.rootItemId) === Number(record.id);
|
|
if (!matchesSource) {
|
|
this.status(this.translate("submap-already-independent",
|
|
"This linked CMap is already independent."), true);
|
|
await this.navigateToMap(record.cmapSlug);
|
|
return true;
|
|
}
|
|
} else {
|
|
title = window.prompt(
|
|
this.translate("submap-name", "Name of the new concept map"),
|
|
record.childMap || record.label);
|
|
if (!title || !title.trim()) return false;
|
|
}
|
|
|
|
const buttons = [document.getElementById("cmap-promote-submap"),
|
|
document.getElementById("cmap-extract-selected")];
|
|
for (const button of buttons) button.disabled = true;
|
|
try {
|
|
const sourceSaved = await this.save({
|
|
force: true,
|
|
snapshotVersion: true,
|
|
summary: this.translate("before-submap-extraction", "Before extracting sub-CMap")
|
|
});
|
|
if (!sourceSaved) return false;
|
|
|
|
let storedMap = linkedMap;
|
|
let extraction;
|
|
if (storedMap) {
|
|
extraction = editor.prepareStoredSubmapExtraction(
|
|
record, storedMap.slug, storedMap.model.metadata());
|
|
storedMap = await this.repository.save(storedMap, extraction.childModel, {
|
|
summary: this.translate("submap-extracted", "Sub-CMap moved to a separate CMap"),
|
|
saveKind: "manual"
|
|
});
|
|
} else {
|
|
const prepared = editor.prepareStoredSubmapExtraction(record, null);
|
|
if (!prepared) return false;
|
|
storedMap = await this.repository.create(title.trim(), prepared.childModel);
|
|
extraction = editor.prepareStoredSubmapExtraction(record, storedMap.slug);
|
|
}
|
|
|
|
editor.replaceModel(extraction.parentModel);
|
|
const parentSaved = await this.save({
|
|
force: true,
|
|
historyMode: "autosave",
|
|
summary: this.translate("submap-extracted", "Sub-CMap moved to a separate CMap")
|
|
});
|
|
if (!parentSaved) {
|
|
this.status(this.translate("submap-created-parent-unsaved",
|
|
"The new CMap was created, but the parent CMap still needs to be saved."));
|
|
return false;
|
|
}
|
|
await this.navigateToMap(storedMap.slug);
|
|
return true;
|
|
} finally {
|
|
const selected = editor.selected();
|
|
const canExtractSubmap = selected && selected.kind === "submap";
|
|
for (const button of buttons) button.disabled = !canExtractSubmap;
|
|
document.getElementById("cmap-extract-selected")
|
|
.classList.toggle("hidden", !canExtractSubmap);
|
|
}
|
|
}
|
|
|
|
async rename() {
|
|
this.cancelAutosave();
|
|
if (this.hasUnsavedChanges() && !await this.save({ automatic: true })) return false;
|
|
const conceptMap = this.state.currentConceptMap;
|
|
if (!conceptMap) return false;
|
|
const title = window.prompt(
|
|
this.translate("rename-concept-map", "Rename CMap"), conceptMap.title);
|
|
if (!title || !title.trim() || title.trim() === conceptMap.title) return false;
|
|
try {
|
|
this.state.currentConceptMap = await this.repository.rename(conceptMap, title.trim());
|
|
await this.loadMaps();
|
|
this.status(this.translate("concept-map-renamed", "CMap renamed"), true);
|
|
return true;
|
|
} catch (error) {
|
|
this.status(error.message);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
activeMetadata() {
|
|
const currentModel = this.state.currentConceptMap?.model;
|
|
if (currentModel?.derivedView()) {
|
|
const metadata = currentModel.metadata();
|
|
return {
|
|
namespace: metadata.namespace || "",
|
|
tags: Array.isArray(metadata.tags) ? metadata.tags : [],
|
|
summary: metadata.summary || "",
|
|
explanationPageSlug: metadata.explanationPageSlug || ""
|
|
};
|
|
}
|
|
const editor = this.getEditor();
|
|
return editor?.getDocumentMetadata ? editor.getDocumentMetadata() :
|
|
{ tags: [], summary: "", explanationPageSlug: "" };
|
|
}
|
|
|
|
async saveMetadata(metadata) {
|
|
const conceptMap = this.state.currentConceptMap;
|
|
const editor = this.getEditor();
|
|
if (!conceptMap || !editor) return false;
|
|
const legacyExplanation = `cmap:${conceptMap.slug}`;
|
|
if (metadata.namespace && metadata.explanationPageSlug === legacyExplanation) {
|
|
metadata = { ...metadata, explanationPageSlug: `${metadata.namespace}:${conceptMap.slug}` };
|
|
}
|
|
if (conceptMap.model.derivedView()) {
|
|
const updatedModel = conceptMap.model.withMetadata(metadata);
|
|
const updated = await this.repository.save(conceptMap, updatedModel, {
|
|
summary: this.translate("updated-concept-map-details", "Updated CMap details"),
|
|
saveKind: "manual"
|
|
});
|
|
this.state.currentConceptMap = updated;
|
|
this.updateSummary(updated);
|
|
} else {
|
|
editor.setDocumentMetadata(metadata);
|
|
if (!await this.save({
|
|
force: true,
|
|
summary: this.translate("updated-concept-map-details", "Updated CMap details")
|
|
})) return false;
|
|
}
|
|
this.status(this.translate("concept-map-details-saved", "CMap details saved"), true);
|
|
return true;
|
|
}
|
|
|
|
async archive() {
|
|
this.cancelAutosave();
|
|
const conceptMap = this.state.currentConceptMap;
|
|
if (!conceptMap) return false;
|
|
const question = this.translate(
|
|
"archive-concept-map-confirm",
|
|
"Archive the entire concept map \"{title}\"? It will disappear from normal navigation, but an administrator can restore it.")
|
|
.replace("{title}", conceptMap.title);
|
|
if (!window.confirm(question)) return false;
|
|
const typedTitle = window.prompt(
|
|
this.translate("archive-concept-map-type-title",
|
|
"Type the complete CMap name to confirm: {title}").replace("{title}", conceptMap.title), "");
|
|
if (typedTitle === null) return false;
|
|
if (typedTitle !== conceptMap.title) {
|
|
this.status(this.translate("archive-concept-map-title-mismatch", "The CMap name did not match; nothing was archived."));
|
|
return false;
|
|
}
|
|
try {
|
|
await this.repository.archive(conceptMap, typedTitle);
|
|
this.markSaved();
|
|
this.state.currentConceptMap = null;
|
|
this.state.currentConceptMapSource = null;
|
|
await this.loadMaps();
|
|
const target = this.state.conceptMaps.length ?
|
|
this.cmapRoute(this.state.conceptMaps[0].slug) : "#cmaps";
|
|
await this.navigateToHash(target);
|
|
this.status(this.translate("concept-map-archived", "CMap archived"), true);
|
|
return true;
|
|
} catch (error) {
|
|
this.status(error.message);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
async createSnapshot() {
|
|
if (!this.getCurrentStorageMap()) return false;
|
|
const description = window.prompt(this.translate("snapshot-description", "Snapshot description"), "");
|
|
if (description === null) return false;
|
|
return this.save({
|
|
force: true,
|
|
summary: description.trim() || this.translate("snapshot", "Snapshot"),
|
|
snapshotVersion: true
|
|
});
|
|
}
|
|
}
|