profile-pane 3.1.4 → 3.2.0

package/lib/sections/languages/mutations.js

@@ -0,0 +1,296 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.processLanguageMutations = processLanguageMutations;
+var _rdflib = require("rdflib");
+var _solidUi = require("solid-ui");
+var _selectors = require("./selectors");
+var _rdfList = require("../shared/rdfList");
+var _idNodeFactory = require("../shared/idNodeFactory");
+var _texts = require("../../texts");
+// Language entries are serialized as an ordered rdf:List of id nodes, where
+// each id node points to an IANA URI via solid:publicId.
+const LANGUAGE_IANA_NS = 'https://www.w3.org/ns/iana/language-code/';
+function ensureLanguagePrefix(store) {
+  const registerPrefix = target => {
+    if (!target) return;
+    if (typeof target.setPrefixForURI === 'function') {
+      target.setPrefixForURI('l', LANGUAGE_IANA_NS);
+      return;
+    }
+    if (!target.namespaces) {
+      target.namespaces = {};
+    }
+    target.namespaces.l = LANGUAGE_IANA_NS;
+  };
+  const anyStore = store;
+  registerPrefix(anyStore);
+  registerPrefix(anyStore?.updater?.store);
+}
+function normalizeText(value) {
+  return (value || '').trim();
+}
+function normalizeLanguageCode(value) {
+  const normalized = normalizeText(value).toLowerCase();
+  if (!normalized) return '';
+  if (normalized.startsWith(LANGUAGE_IANA_NS)) {
+    return normalized.slice(LANGUAGE_IANA_NS.length);
+  }
+  return normalized;
+}
+function rowsFromOrderedInput(orderedRows) {
+  return (orderedRows || []).filter(row => row.status !== 'deleted').filter(row => Boolean(normalizeText(row.publicId) || normalizeText(row.name) || normalizeText(row.entryNode))).map(row => ({
+    ...row,
+    name: normalizeText(row.name),
+    publicId: normalizeText(row.publicId),
+    proficiency: normalizeText(row.proficiency),
+    entryNode: normalizeText(row.entryNode)
+  }));
+}
+function buildRdfListStatements(items, doc) {
+  if (!items.length) {
+    return {
+      head: _solidUi.ns.rdf('nil'),
+      statements: []
+    };
+  }
+  const listNodes = items.map(() => (0, _rdflib.blankNode)());
+  const statements = [];
+  items.forEach((item, index) => {
+    const current = listNodes[index];
+    const next = listNodes[index + 1] || _solidUi.ns.rdf('nil');
+    statements.push((0, _rdflib.st)(current, _solidUi.ns.rdf('first'), item, doc));
+    statements.push((0, _rdflib.st)(current, _solidUi.ns.rdf('rest'), next, doc));
+  });
+  return {
+    head: listNodes[0],
+    statements
+  };
+}
+function buildLanguageStatements(subject, doc, rows) {
+  const languageRows = rows.map(row => ({
+    name: normalizeText(row.name),
+    publicId: normalizeLanguageCode(row.publicId)
+  })).filter(row => Boolean(row.publicId));
+  if (languageRows.length === 0) return [];
+  const entryNodes = languageRows.map(() => (0, _idNodeFactory.createIdNode)(doc));
+  const statements = [];
+  const rdfList = buildRdfListStatements(entryNodes, doc);
+  statements.push((0, _rdflib.st)(subject, _solidUi.ns.schema('knowsLanguage'), rdfList.head, doc));
+  statements.push(...rdfList.statements);
+  entryNodes.forEach((entryNode, index) => {
+    const publicIdNode = (0, _rdflib.sym)(`${LANGUAGE_IANA_NS}${languageRows[index].publicId}`);
+    statements.push((0, _rdflib.st)(entryNode, _solidUi.ns.solid('publicId'), publicIdNode, doc));
+    if (languageRows[index].name) {
+      statements.push((0, _rdflib.st)(publicIdNode, _solidUi.ns.schema('name'), (0, _rdflib.literal)(languageRows[index].name, 'en'), doc));
+    }
+  });
+  return statements;
+}
+function collectListChainNodes(store, listHead, doc) {
+  const visited = new Set();
+  const nodes = [];
+  let current = listHead;
+  while (current) {
+    const key = `${current.termType}:${current.value}`;
+    if (visited.has(key)) break;
+    visited.add(key);
+    nodes.push(current);
+    const rest = store.any(current, _solidUi.ns.rdf('rest'), null, doc);
+    if (!rest || rest.termType === 'NamedNode' && rest.value === _solidUi.ns.rdf('nil').value) {
+      break;
+    }
+    current = rest;
+  }
+  return nodes;
+}
+function isPatchFailure(message) {
+  const text = (message || '').toLowerCase();
+  // Different pods surface PATCH incompatibility with different status codes/messages.
+  return text.includes(' on patch ') || text.includes('web error: 501') || text.includes('web error: 405') || text.includes('web error: 400');
+}
+function isMissingGetRecordError(message) {
+  return (message || '').toLowerCase().includes('no record of our http get request for document');
+}
+function statementKey(statement) {
+  return `${statement.subject?.toNT?.() || statement.subject?.value} ${statement.predicate?.toNT?.() || statement.predicate?.value} ${statement.object?.toNT?.() || statement.object?.value} ${statement.why?.toNT?.() || statement.why?.value}`;
+}
+function sanitizePatchStatements(store, deletions, insertions) {
+  const safeDeletions = Array.from(new Map((deletions || []).filter(statement => {
+    if (!statement || !statement.subject || !statement.predicate || !statement.object) return false;
+    if (store.holds(statement.subject, statement.predicate, statement.object, statement.why)) return true;
+    return store.statementsMatching(statement.subject, statement.predicate, statement.object, statement.why).length > 0;
+  }).map(statement => [statementKey(statement), statement])).values());
+  const safeInsertions = Array.from(new Map((insertions || []).filter(statement => Boolean(statement && statement.subject && statement.predicate && statement.object)).map(statement => [statementKey(statement), statement])).values());
+  return {
+    safeDeletions,
+    safeInsertions
+  };
+}
+async function runPutFallback(store, doc, deletions, insertions) {
+  const updater = store.updater;
+  const fetcher = store.fetcher;
+  if (!updater || typeof updater.serialize !== 'function' || !fetcher || typeof fetcher.webOperation !== 'function') {
+    throw new Error('Language updates are not supported by this store updater.');
+  }
+  const currentStatements = store.statementsMatching(undefined, undefined, undefined, doc).slice();
+  const deletionKeys = new Set((deletions || []).map(statement => statementKey(statement)));
+  // Rebuild full document state for PUT when patch-oriented flows cannot be used.
+  const nextStatements = currentStatements.filter(statement => !deletionKeys.has(statementKey(statement))).concat(insertions || []);
+  const contentType = 'text/turtle';
+  const body = updater.serialize(doc.value, nextStatements, contentType);
+  const response = await fetcher.webOperation('PUT', doc.value, {
+    noMeta: true,
+    contentType,
+    body
+  });
+  if (!response || response.ok !== true) {
+    const status = response?.status || 'unknown';
+    throw new Error(`Web error: ${status} on PUT of <${doc.value}>`);
+  }
+
+  // PUT bypasses UpdateManager's local-store patching, so apply the same changes locally.
+  store.remove(deletions);
+  insertions.forEach(statement => {
+    store.add(statement.subject, statement.predicate, statement.object, statement.why);
+  });
+}
+async function runUpdateWithDavFallback(store, doc, deletions, insertions) {
+  const updater = store.updater;
+  if (!updater || typeof updater.update !== 'function') {
+    throw new Error('Language updates are not supported by this store updater.');
+  }
+  const {
+    safeDeletions,
+    safeInsertions
+  } = sanitizePatchStatements(store, deletions, insertions);
+  if (safeDeletions.length === 0 && safeInsertions.length === 0) {
+    return;
+  }
+  const tryUpdate = () => new Promise((resolve, reject) => {
+    updater.update(safeDeletions, safeInsertions, (_uri, ok, message) => {
+      if (ok === true) {
+        resolve();
+        return;
+      }
+      reject(new Error(message || 'Failed to save languages'));
+    });
+  });
+  try {
+    // Preferred path: let rdflib pick the server-supported update protocol.
+    await tryUpdate();
+    return;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!isPatchFailure(message) || typeof updater.updateDav !== 'function') {
+      throw error;
+    }
+    if (store.fetcher && typeof store.fetcher.load === 'function') {
+      try {
+        await store.fetcher.load(doc);
+      } catch {
+        // Continue; updateDav may still fail and we handle that below.
+      }
+    }
+    try {
+      // First fallback for PATCH failures: DAV-style whole-document update.
+      await new Promise((resolve, reject) => {
+        updater.updateDav(doc, safeDeletions, safeInsertions, (_uri, ok, body) => {
+          if (ok === true) {
+            resolve();
+            return;
+          }
+          reject(new Error(body || message || 'Failed to save languages'));
+        });
+      });
+    } catch (davError) {
+      const davMessage = davError instanceof Error ? davError.message : String(davError);
+      if (!isMissingGetRecordError(davMessage)) {
+        throw davError;
+      }
+      // Some stores cannot run updateDav without prior fetch metadata; use direct PUT.
+      await runPutFallback(store, doc, safeDeletions, safeInsertions);
+    }
+  }
+}
+function mergeLanguageOps(existingRows, languageOps) {
+  const byEntryNode = new Map();
+  existingRows.forEach(row => {
+    byEntryNode.set(row.entryNode, row);
+  });
+  languageOps.remove.forEach(row => {
+    if (!row.entryNode) return;
+    byEntryNode.delete(row.entryNode);
+  });
+  languageOps.update.forEach(row => {
+    if (!row.entryNode) return;
+    if (!byEntryNode.has(row.entryNode)) return;
+    byEntryNode.set(row.entryNode, row);
+  });
+  languageOps.create.forEach(row => {
+    if (!normalizeText(row.publicId)) return;
+    byEntryNode.set(`new:${row.name}:${Math.random()}`, {
+      ...row,
+      publicId: normalizeText(row.publicId),
+      proficiency: normalizeText(row.proficiency)
+    });
+  });
+  const dedupedByLanguage = new Map();
+  Array.from(byEntryNode.values()).forEach(row => {
+    const publicId = normalizeText(row.publicId);
+    if (!publicId) return;
+    if (!dedupedByLanguage.has(publicId)) {
+      dedupedByLanguage.set(publicId, {
+        ...row,
+        publicId,
+        proficiency: normalizeText(row.proficiency)
+      });
+    }
+  });
+  return Array.from(dedupedByLanguage.values());
+}
+async function mutateLanguageEntries(store, subject, languageOps, orderedRows) {
+  ensureLanguagePrefix(store);
+  const doc = subject.doc();
+  const existingRows = (0, _selectors.presentLanguages)(subject, store).map(detail => ({
+    name: normalizeText(detail.name),
+    publicId: normalizeText(detail.publicId),
+    proficiency: normalizeText(detail.proficiency),
+    entryNode: detail.entryNode.value,
+    status: 'existing'
+  }));
+  const nextRows = orderedRows && orderedRows.length ? rowsFromOrderedInput(orderedRows) : mergeLanguageOps(existingRows, languageOps);
+  const listObjects = store.each(subject, _solidUi.ns.schema('knowsLanguage'), null, doc);
+  const existingListHeads = listObjects.filter(node => node.termType === 'BlankNode' || node.termType === 'NamedNode');
+  const existingListNodes = Array.from(new Map(existingListHeads.flatMap(node => collectListChainNodes(store, node, doc)).map(node => [`${node.termType}:${node.value}`, node])).values());
+  const existingLanguageNodes = Array.from(new Set(listObjects.flatMap(node => (0, _rdfList.expandRdfList)(store, node)).filter(node => node.termType === 'NamedNode' || node.termType === 'BlankNode').map(node => `${node.termType}:${node.value}`))).map(key => {
+    const [termType, ...rest] = key.split(':');
+    const value = rest.join(':');
+    return termType === 'BlankNode' ? store.bnode(value) : store.sym(value);
+  });
+  const existingPublicIdNodes = Array.from(new Map(existingLanguageNodes.map(node => store.any(node, _solidUi.ns.solid('publicId'), null, doc)).filter(node => Boolean(node && node.termType === 'NamedNode')).map(node => [`${node.termType}:${node.value}`, node])).values());
+  const deletions = store.statementsMatching(subject, _solidUi.ns.schema('knowsLanguage'), null, doc);
+  existingListNodes.forEach(node => {
+    deletions.push(...store.statementsMatching(node, null, null, doc));
+  });
+  existingLanguageNodes.forEach(node => {
+    // Remove old language-entry statements so save always rewrites canonical shape.
+    deletions.push(...store.statementsMatching(node, null, null, doc));
+  });
+  existingPublicIdNodes.forEach(node => {
+    // Language labels are attached to the publicId resource (l:xx) and should be removed for deleted rows.
+    deletions.push(...store.statementsMatching(node, _solidUi.ns.schema('name'), null, doc));
+  });
+  const insertions = buildLanguageStatements(subject, doc, nextRows);
+  await runUpdateWithDavFallback(store, doc, deletions, insertions);
+}
+async function processLanguageMutations(store, subject, mutationPlan, orderedRows) {
+  try {
+    await mutateLanguageEntries(store, subject, mutationPlan, orderedRows);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${_texts.mutationSaveLanguagesFailedPrefixText} ${message}`);
+  }
+}

package/lib/sections/languages/selectors.d.ts

@@ -0,0 +1,5 @@
+import { NamedNode, Store, Node, LiveStore } from 'rdflib';
+import { LanguageDetails } from './types';
+export declare function languageAsText(store: Store, lan: Node): string;
+export declare function presentLanguages(subject: NamedNode, store: LiveStore): LanguageDetails[];
+//# sourceMappingURL=selectors.d.ts.map

package/lib/sections/languages/selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../../src/sections/languages/selectors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAO,MAAM,QAAQ,CAAA;AAE/D,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAwIzC,wBAAgB,cAAc,CAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,GAAE,MAAM,CAO9D;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,GAAG,eAAe,EAAE,CA8BxF"}

package/lib/sections/languages/selectors.js

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.languageAsText = languageAsText;
+exports.presentLanguages = presentLanguages;
+var _rdflib = require("rdflib");
+var _solidUi = require("solid-ui");
+var _rdfList = require("../shared/rdfList");
+const IANA_LANGUAGE_BASE = 'https://www.w3.org/ns/iana/language-code/';
+function normalizeText(value) {
+  return value.replace(/\s+/g, ' ').trim();
+}
+function isRdfListNode(store, node) {
+  const hasCollectionElements = Array.isArray(node?.elements);
+  if (hasCollectionElements) return true;
+  if (node.termType !== 'BlankNode' && node.termType !== 'NamedNode') return false;
+  return Boolean(store.any(node, _solidUi.ns.rdf('first')));
+}
+function normalizeLanguageCode(value) {
+  return (value || '').trim().toLowerCase();
+}
+function languageNameFromCode(code) {
+  const normalized = (code || '').trim().toLowerCase();
+  if (!normalized) return '';
+  try {
+    const DisplayNamesCtor = Intl?.DisplayNames;
+    if (typeof DisplayNamesCtor === 'function') {
+      const displayNames = new DisplayNamesCtor(['en'], {
+        type: 'language'
+      });
+      const localized = displayNames.of(normalized);
+      if (localized) return localized;
+    }
+  } catch {
+    // Fallback below.
+  }
+  return normalized;
+}
+function languageNameFromPublicId(publicIdValue) {
+  const value = (publicIdValue || '').trim();
+  if (!value) return '';
+  if (value.startsWith(IANA_LANGUAGE_BASE)) {
+    const code = normalizeLanguageCode(value.slice(IANA_LANGUAGE_BASE.length));
+    return languageNameFromCode(code);
+  }
+  return languageNameFromCode(value);
+}
+function englishOrAnyLiteralValue(store, subject, predicate) {
+  const values = store.statementsMatching(subject, predicate);
+  const english = values.find(statement => {
+    const language = statement.object?.lang || '';
+    return language.toLowerCase().startsWith('en');
+  });
+  if (english && typeof english.object?.value === 'string') {
+    return english.object.value;
+  }
+  const firstLiteral = values.find(statement => statement.object?.termType === 'Literal');
+  if (firstLiteral && typeof firstLiteral.object?.value === 'string') {
+    return firstLiteral.object.value;
+  }
+  return '';
+}
+function englishLabelForNode(store, node) {
+  const labels = store.statementsMatching(node, _solidUi.ns.rdfs('label'));
+  const english = labels.find(statement => {
+    const language = statement.object?.lang || '';
+    return language.toLowerCase().startsWith('en');
+  });
+  if (english && english.object && typeof english.object.value === 'string') {
+    return english.object.value;
+  }
+  return '';
+}
+function languageNameFromIanaNode(store, node) {
+  const schemaName = englishOrAnyLiteralValue(store, node, _solidUi.ns.schema('name'));
+  if (schemaName) return normalizeText(schemaName);
+  const localLabel = englishLabelForNode(store, node);
+  if (localLabel) return normalizeText(localLabel);
+  if (node.value.startsWith(IANA_LANGUAGE_BASE)) {
+    return languageNameFromPublicId(node.value);
+  }
+  return '';
+}
+function toStoredPublicIdValue(lan, publicIdNode) {
+  if (publicIdNode?.termType === 'NamedNode') {
+    return publicIdNode.value;
+  }
+  if (publicIdNode?.termType === 'Literal') {
+    const code = normalizeLanguageCode(publicIdNode.value);
+    return code || undefined;
+  }
+  if (lan.termType === 'NamedNode' && lan.value.startsWith(IANA_LANGUAGE_BASE)) {
+    return lan.value;
+  }
+  return undefined;
+}
+function languageNameFromLanguageNode(store, lan, publicIdNode) {
+  if (publicIdNode?.termType === 'NamedNode') {
+    const nodeName = languageNameFromIanaNode(store, publicIdNode);
+    if (nodeName) return nodeName;
+    return languageNameFromPublicId(publicIdNode.value);
+  }
+  if (publicIdNode?.termType === 'Literal') {
+    const code = normalizeLanguageCode(publicIdNode.value);
+    if (!code) return '';
+    const ianaNode = (0, _rdflib.sym)(`${IANA_LANGUAGE_BASE}${code}`);
+    const nodeName = languageNameFromIanaNode(store, ianaNode);
+    if (nodeName) return nodeName;
+    return languageNameFromCode(code);
+  }
+  if (lan.termType === 'NamedNode') {
+    const nodeName = languageNameFromIanaNode(store, lan);
+    if (nodeName) return nodeName;
+  }
+  return '';
+}
+function languageAsText(store, lan) {
+  if (lan.termType === 'Literal') return lan.value; // Not normal but allow this
+
+  if (lan.termType !== 'NamedNode' && lan.termType !== 'BlankNode') return '';
+  const publicIdNode = store.any(lan, _solidUi.ns.solid('publicId')) || undefined;
+  return languageNameFromLanguageNode(store, lan, publicIdNode);
+}
+function presentLanguages(subject, store) {
+  const languageObjects = store.each(subject, _solidUi.ns.schema('knowsLanguage'));
+  const expandedLists = languageObjects.filter(node => isRdfListNode(store, node)).map(node => (0, _rdfList.expandRdfList)(store, node));
+  const longestList = expandedLists.sort((a, b) => b.length - a.length)[0] || [];
+  const standaloneNodes = languageObjects.filter(node => !isRdfListNode(store, node));
+  const languageNodes = [...longestList, ...standaloneNodes];
+  const details = languageNodes.map(lan => ({
+    name: languageAsText(store, lan),
+    publicId: toStoredPublicIdValue(lan, store.any(lan, _solidUi.ns.solid('publicId')) || undefined),
+    proficiency: store.anyValue(lan, _solidUi.ns.schema('proficiencyLevel')) || undefined,
+    entryNode: lan
+  })).filter(item => Boolean(item.name));
+  const dedupedByLanguage = new Map();
+  details.forEach(item => {
+    const key = item.publicId || item.name;
+    if (!dedupedByLanguage.has(key)) {
+      dedupedByLanguage.set(key, item);
+    }
+  });
+  return Array.from(dedupedByLanguage.values());
+}

package/lib/sections/languages/types.d.ts

@@ -0,0 +1,15 @@
+import { Node } from 'rdflib';
+import { RowStatus } from '../shared/types';
+export interface LanguageFields {
+    name: string;
+    publicId?: string;
+    proficiency?: string;
+}
+export interface LanguageDetails extends LanguageFields {
+    entryNode: Node;
+}
+export interface LanguageRow extends LanguageFields {
+    entryNode: string;
+    status: RowStatus;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/sections/languages/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/sections/languages/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,eAAgB,SAAQ,cAAc;IACrD,SAAS,EAAE,IAAI,CAAA;CAChB;AAED,MAAM,WAAW,WAAY,SAAQ,cAAc;IACjD,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,SAAS,CAAA;CAClB"}

package/lib/sections/languages/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/sections/projects/ProjectEditDialog.d.ts

@@ -0,0 +1,7 @@
+import { ProjectDetails } from './types';
+import '../../styles/EditDialogs.css';
+import '../../styles/ContactInfoEditDialog.css';
+import { LiveStore, NamedNode } from 'rdflib';
+import { ViewerMode } from '../../types';
+export declare function createProjectsEditDialog(event: Event, store: LiveStore, subject: NamedNode, projects: ProjectDetails[], viewerMode: ViewerMode, onSaved?: () => Promise<void> | void): Promise<void>;
+//# sourceMappingURL=ProjectEditDialog.d.ts.map

package/lib/sections/projects/ProjectEditDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectEditDialog.d.ts","sourceRoot":"","sources":["../../../src/sections/projects/ProjectEditDialog.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAc,MAAM,SAAS,CAAA;AACpD,OAAO,8BAA8B,CAAA;AACrC,OAAO,wCAAwC,CAAA;AAC/C,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AA0JxC,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,SAAS,EAClB,QAAQ,EAAE,cAAc,EAAE,EAC1B,UAAU,EAAE,UAAU,EACtB,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,iBAmDrC"}

package/lib/sections/projects/ProjectEditDialog.js

@@ -0,0 +1,182 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createProjectsEditDialog = createProjectsEditDialog;
+var _dialog = require("../../ui/dialog");
+var _litHtml = require("lit-html");
+require("../../styles/EditDialogs.css");
+require("../../styles/ContactInfoEditDialog.css");
+var _rowState = require("../shared/rowState");
+var _textUtils = require("../../textUtils");
+var _mutations = require("./mutations");
+var _profileIcons = require("../../icons-svg/profileIcons");
+var _texts = require("../../texts");
+function sanitizeProjectFieldValue(value) {
+  return (0, _textUtils.sanitizeTextValue)(value);
+}
+function isValidProjectUrl(value) {
+  const text = sanitizeProjectFieldValue(value);
+  if (!text) return false;
+  try {
+    const parsed = new URL(text);
+    return parsed.protocol === 'https:' && parsed.pathname === '/profile/card' && parsed.hash === '#me';
+  } catch {
+    return false;
+  }
+}
+function rowHasContent(row) {
+  return [row.url, row.entryNode].some(_textUtils.hasNonEmptyText);
+}
+async function pasteWebIdIntoRow(row) {
+  const clipboardText = await navigator.clipboard.readText();
+  const url = sanitizeProjectFieldValue(clipboardText);
+  if (!url) return '';
+  (0, _rowState.applyRowFieldChange)(row, 'url', url, rowHasContent);
+  return url;
+}
+function toFormState(_details) {
+  return {
+    project: {
+      url: '',
+      entryNode: '',
+      status: 'new'
+    }
+  };
+}
+function validateProjectBeforeSave(row) {
+  if (!(0, _textUtils.hasNonEmptyText)(row.url) && !(0, _textUtils.hasNonEmptyText)(row.entryNode)) {
+    return 'Add a project WebID.';
+  }
+  if (!(0, _textUtils.hasNonEmptyText)(row.url)) {
+    return 'WebID is required.';
+  }
+  if (!isValidProjectUrl(row.url)) {
+    return 'Please enter a valid WebID in the form https://example.com/profile/card#me.';
+  }
+  return null;
+}
+function renderProjectInputRow(row, onChange) {
+  const projectUrl = 'project-0';
+  const handleUrlInput = e => {
+    const target = e.target;
+    const nextValue = sanitizeProjectFieldValue(target.value);
+    (0, _rowState.applyRowFieldChange)(row, 'url', nextValue, rowHasContent);
+  };
+  const handlePaste = async event => {
+    event.preventDefault();
+    try {
+      const url = await pasteWebIdIntoRow(row);
+      onChange();
+      if (!isValidProjectUrl(url)) return;
+      const dom = event.currentTarget?.ownerDocument || document;
+      const saveButton = dom.querySelector('#profile-modal #modal-buttons .btn-primary');
+      saveButton?.click();
+    } catch {
+      // Clipboard access may fail due to browser permissions; keep dialog usable.
+    }
+  };
+  return (0, _litHtml.html)`
+    <div class="profile-edit-dialog__row profile-edit-dialog__row--project">
+      <label aria-label="Project or community WebID" class="label profile-edit-dialog__field profile-edit-dialog__field--full">
+      <p>Type or paste a project or community WebID.</p>  
+      <div class="profile-edit-dialog__input-wrap">
+          <input
+            class="input profile-edit-dialog__input--with-action"
+            type="text"
+            name=${projectUrl}
+            .value=${row?.url || ''}
+            required
+            data-contact-field="url"
+            data-entry-node=${row?.entryNode || ''}
+            data-row-status=${row?.status || 'n/a'}
+            placeholder="Type or paste project/community WebID here"
+            autocomplete="off"
+            inputmode="text"
+            @input=${handleUrlInput}
+          />
+          <button
+            type="button"
+            class="profile-edit-dialog__paste-button rounded-sm gap-xxs"
+            aria-label="Paste project or community URL from clipboard"
+            title=${_texts.pasteEntryButtonTitleText}
+            @click=${handlePaste}
+          >
+            <span class="profile-edit-dialog__paste-icon" aria-hidden="true">${_profileIcons.pasteIcon}</span>
+            Paste
+          </button>
+        </div>
+      </label>
+    </div>
+  `;
+}
+function renderProjectsEditTemplate(form, formState, viewerMode) {
+  const rerender = () => renderProjectsEditTemplate(form, formState, viewerMode);
+  (0, _litHtml.render)((0, _litHtml.html)`
+    ${renderProjectInputRow(formState.project, rerender)}
+    ${viewerMode !== 'owner' ? (0, _litHtml.html)`<p class="profile-edit-dialog__login-message">${_texts.ownerLoginRequiredDialogMessageText}</p>` : null}
+  `, form);
+}
+function createProjectsEditForm(details, viewerMode) {
+  const form = document.createElement('form');
+  form.classList.add('profile__edit-form');
+  form.classList.add('profile__edit-form--projects');
+  const formState = toFormState(details);
+  renderProjectsEditTemplate(form, formState, viewerMode);
+  return {
+    form,
+    formState
+  };
+}
+async function createProjectsEditDialog(event, store, subject, projects, viewerMode, onSaved) {
+  const dom = event.currentTarget?.ownerDocument || document;
+  const {
+    form,
+    formState
+  } = createProjectsEditForm(projects, viewerMode);
+  const dialogPromise = (0, _dialog.openInputDialog)({
+    title: _texts.editProjectsDialogTitleText,
+    dom,
+    form,
+    headerAction: {
+      type: 'close'
+    },
+    validate: () => {
+      if (viewerMode !== 'owner') {
+        return _texts.ownerLoginRequiredDialogMessageText;
+      }
+      return validateProjectBeforeSave(formState.project);
+    },
+    onSave: async () => {
+      const projectOps = (0, _rowState.summarizeRowOps)([formState.project], rowHasContent);
+      const plan = {
+        create: projectOps.create,
+        update: projectOps.update,
+        remove: projectOps.remove
+      };
+      await (0, _mutations.processProjectsMutations)(store, subject, plan);
+    },
+    formatSaveError: error => {
+      const message = error instanceof Error ? error.message : String(error);
+      return `${_texts.saveProjectsUpdatesFailedPrefixText} ${message}`;
+    }
+  });
+  const modalButtons = dom.querySelector('#profile-modal #modal-buttons');
+  const previousButtonsDisplay = modalButtons?.style.display;
+  if (modalButtons) {
+    modalButtons.style.display = 'none';
+  }
+  let result = null;
+  try {
+    result = await dialogPromise;
+  } finally {
+    if (modalButtons) {
+      modalButtons.style.display = previousButtonsDisplay || '';
+    }
+  }
+  if (!result) return;
+  if (onSaved) {
+    await onSaved();
+  }
+}

package/lib/sections/projects/ProjectSection.d.ts

@@ -0,0 +1,6 @@
+import { LiveStore, NamedNode } from 'rdflib';
+import { ViewerMode } from '../../types';
+import { ProjectDetails } from './types';
+import '../../styles/ProjectsCard.css';
+export declare function renderProjectSection(store: LiveStore, subject: NamedNode, projects: ProjectDetails[], viewerMode: ViewerMode, onSaved?: () => Promise<void> | void): import("lit-html").TemplateResult<1> | "";
+//# sourceMappingURL=ProjectSection.d.ts.map