@pod-os/core 0.12.1-eddb6ac.0 → 0.12.1-facecbd.0

package/dist/{dist-762OQHAF.js → dist-F3EUFQHU.js}

@@ -4,11 +4,11 @@ import {
   lit,
   namedNode,
   st
-} from "./chunk-7C7N3OSJ.js";
+} from "./chunk-7VQUARYZ.js";
 import {
   __commonJS,
   __toESM
-} from "./chunk-5NEDDTD5.js";
+} from "./chunk-U67V476Y.js";
 
 // ../node_modules/short-unique-id/dist/short-unique-id.js
 var require_short_unique_id = __commonJS({
@@ -353,13 +353,10 @@ var require_short_unique_id = __commonJS({
 });
 
 // ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/namespaces.js
-var rdf = Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
 var vcard = Namespace("http://www.w3.org/2006/vcard/ns#");
-var solid = Namespace("http://www.w3.org/ns/solid/terms#");
-var pim = Namespace("http://www.w3.org/ns/pim/space#");
 var dc = Namespace("http://purl.org/dc/elements/1.1/");
 
-// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/generate-id.js
+// ../node_modules/@solid-data-modules/rdflib-utils/dist/identifier/generate-id.js
 var import_short_unique_id = __toESM(require_short_unique_id(), 1);
 var uid = new import_short_unique_id.default({ length: 10 });
 function generateId() {
@@ -475,6 +472,24 @@ function isTelNode(valueNode) {
   return isNamedNode(valueNode) && valueNode.value.startsWith(TEl_URI_SCHEME);
 }
 
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/GroupQuery.js
+var GroupQuery = class {
+  constructor(store, groupNode) {
+    this.store = store;
+    this.groupNode = groupNode;
+    this.groupDoc = groupNode.doc();
+  }
+  queryName() {
+    return this.store.anyValue(this.groupNode, vcard("fn"), void 0, this.groupDoc) ?? "";
+  }
+  queryMembers() {
+    return this.store.each(this.groupNode, vcard("hasMember"), null, this.groupDoc).filter((it) => isNamedNode(it)).map((node) => ({
+      uri: node.value,
+      name: this.store.anyValue(node, vcard("fn"), null, this.groupDoc) ?? ""
+    }));
+  }
+};
+
 // ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/createAddressBook.js
 function createAddressBook(container, name) {
   const id = generateId();
@@ -491,7 +506,152 @@ function createAddressBook(container, name) {
     uri,
     deletions: [],
     insertions,
-    filesToCreate: [{ uri: nameEmailIndexUri }, { uri: groupIndexUri }]
+    filesToCreate: [{ url: nameEmailIndexUri }, { url: groupIndexUri }]
+  };
+}
+
+// ../node_modules/@solid-data-modules/rdflib-utils/dist/web-operations/executeUpdate.js
+async function executeUpdate(fetcher, updater, operation) {
+  await updater.updateMany(operation.deletions, operation.insertions);
+  operation.filesToCreate.map((file) => {
+    createEmptyTurtleFile(fetcher, file.url);
+  });
+}
+function createEmptyTurtleFile(fetcher, url) {
+  return fetcher.webOperation("PUT", url, {
+    contentType: "text/turtle"
+  });
+}
+
+// ../node_modules/@solid-data-modules/rdflib-utils/dist/web-operations/fetchNode.js
+async function fetchNode(fetcher, node) {
+  if (node) {
+    await fetcher.load(node.value);
+  }
+}
+
+// ../node_modules/@solid-data-modules/rdflib-utils/dist/namespaces/index.js
+var rdf = Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
+var solid = Namespace("http://www.w3.org/ns/solid/terms#");
+var pim = Namespace("http://www.w3.org/ns/pim/space#");
+var ldp = Namespace("http://www.w3.org/ns/ldp#");
+
+// ../node_modules/@solid-data-modules/rdflib-utils/dist/queries/PreferencesQuery.js
+var PreferencesQuery = class {
+  constructor(store, webIdNode, preferencesDoc) {
+    this.store = store;
+    this.webIdNode = webIdNode;
+    this.preferencesDoc = preferencesDoc;
+  }
+  /**
+   * Look up the private type index. Returns null if none is found or if the predicated does not link to a proper named node
+   */
+  queryPrivateTypeIndex() {
+    const node = this.store.any(this.webIdNode, solid("privateTypeIndex"), null, this.preferencesDoc);
+    if (isNamedNode(node)) {
+      return node;
+    }
+    return null;
+  }
+};
+
+// ../node_modules/@solid-data-modules/rdflib-utils/dist/queries/ProfileQuery.js
+var ProfileQuery = class {
+  constructor(webIdNode, store) {
+    this.webIdNode = webIdNode;
+    this.store = store;
+  }
+  /**
+   * Look up the public type index. Returns null if none is found or if the predicated does not link to a proper named node
+   */
+  queryPublicTypeIndex() {
+    const predicate = solid("publicTypeIndex");
+    return this.queryNamedNode(predicate);
+  }
+  /**
+   * Look up the preferences file. Returns null if none is found or if the predicated does not link to a proper named node
+   */
+  queryPreferencesFile() {
+    const predicate = pim("preferencesFile");
+    return this.queryNamedNode(predicate);
+  }
+  queryNamedNode(predicate) {
+    const node = this.store.any(this.webIdNode, predicate, null, this.webIdNode.doc());
+    if (isNamedNode(node)) {
+      return node;
+    }
+    return null;
+  }
+};
+
+// ../node_modules/@solid-data-modules/rdflib-utils/dist/queries/TypeIndexQuery.js
+var TypeIndexQuery = class {
+  constructor(store, typeIndexDoc) {
+    this.store = store;
+    this.typeIndexDoc = typeIndexDoc;
+  }
+  /**
+   * Look up the instances in the type registration for the given RDF class
+   * @param type - The RDF class to look up
+   * @returns A list of the URIs of the found instances
+   */
+  queryInstancesForClass(type) {
+    const registrations = this.store.each(null, solid("forClass"), type, this.typeIndexDoc);
+    return registrations.flatMap((registration) => {
+      if (!isNamedNode(registration))
+        return [];
+      return this.getInstanceValues(registration);
+    });
+  }
+  getInstanceValues(registration) {
+    return this.store.each(registration, solid("instance"), null, this.typeIndexDoc).map((it) => it.value);
+  }
+};
+
+// ../node_modules/@solid-data-modules/rdflib-utils/dist/module/ModuleSupport.js
+var ModuleSupport = class {
+  constructor(config) {
+    this.store = config.store;
+    this.fetcher = config.fetcher;
+    this.updater = config.updater;
+  }
+  /**
+   * Nullsafe fetching of a node
+   * @param node - A node to fetch, or null to do nothing at all
+   */
+  async fetchNode(node) {
+    return fetchNode(this.fetcher, node);
+  }
+  /**
+   * Fetch all the given nodes in parallel
+   * @param nodes
+   */
+  async fetchAll(nodes) {
+    return Promise.all(nodes.map((it) => this.fetchNode(it)));
+  }
+  /**
+   * Checks whether the resource identified by the given URL is a LDP container
+   * @param storageUrl - The URL to check
+   * @returns true if it is a container, false otherwise
+   */
+  async isContainer(storageUrl) {
+    const storageNode = namedNode(storageUrl);
+    await this.fetcher.load(storageNode.value);
+    return this.store.holds(storageNode, rdf("type"), ldp("Container"), storageNode.doc());
+  }
+};
+
+// ../node_modules/@solid-data-modules/rdflib-utils/dist/update-operations/addInstanceToTypeIndex.js
+function addInstanceToTypeIndex(typeIndexDoc, instanceUri, type) {
+  const registrationNode = namedNode(`${typeIndexDoc.value}#${generateId()}`);
+  return {
+    deletions: [],
+    filesToCreate: [],
+    insertions: [
+      st(registrationNode, rdf("type"), solid("TypeRegistration"), typeIndexDoc),
+      st(registrationNode, solid("forClass"), type, typeIndexDoc),
+      st(registrationNode, solid("instance"), namedNode(instanceUri), typeIndexDoc)
+    ]
   };
 }
 
@@ -524,26 +684,6 @@ function createNewContact(addressBook, newContact) {
   };
 }
 
-// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/web-operations/executeUpdate.js
-async function executeUpdate(fetcher, updater, operation) {
-  await updater.updateMany(operation.deletions, operation.insertions);
-  operation.filesToCreate.map((file) => {
-    createEmptyTurtleFile(fetcher, file.uri);
-  });
-}
-function createEmptyTurtleFile(fetcher, uri) {
-  return fetcher.webOperation("PUT", uri, {
-    contentType: "text/turtle"
-  });
-}
-
-// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/web-operations/fetchNode.js
-async function fetchNode(fetcher, node) {
-  if (node) {
-    await fetcher.load(node.value);
-  }
-}
-
 // ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/createNewGroup.js
 function createNewGroup(addressBook, groupName) {
   const groupIndex = addressBook.queryGroupIndex();
@@ -565,29 +705,10 @@ function createNewGroup(addressBook, groupName) {
   };
 }
 
-// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/GroupQuery.js
-var GroupQuery = class {
-  constructor(store, groupNode) {
-    this.store = store;
-    this.groupNode = groupNode;
-    this.groupDoc = groupNode.doc();
-  }
-  queryName() {
-    return this.store.anyValue(this.groupNode, vcard("fn"), void 0, this.groupDoc) ?? "";
-  }
-  queryMembers() {
-    return this.store.each(this.groupNode, vcard("hasMember"), null, this.groupDoc).filter((it) => isNamedNode(it)).map((node) => ({
-      uri: node.value,
-      name: this.store.anyValue(node, vcard("fn"), null, this.groupDoc) ?? ""
-    }));
-  }
-};
-
 // ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/addContactToGroup.js
 function addContactToGroup(contactQuery, groupQuery) {
   const name = contactQuery.queryName();
   return {
-    uri: "",
     insertions: [
       st(groupQuery.groupNode, vcard("hasMember"), contactQuery.contactNode, groupQuery.groupNode.doc()),
       st(contactQuery.contactNode, vcard("fn"), lit(name), groupQuery.groupNode.doc())
@@ -597,20 +718,17 @@ function addContactToGroup(contactQuery, groupQuery) {
   };
 }
 
-// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/removeContactFromGroup.js
-function removeContactFromGroup(contactQuery, groupQuery) {
-  const contactUri = contactQuery.contactNode.uri;
-  const member = groupQuery.queryMembers().find((it) => it.uri === contactUri);
-  if (!member) {
-    throw new Error("member not found in group");
-  }
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/addNewEmailAddress.js
+function addNewEmailAddress(contactNode, emailAddress) {
+  const id = generateId();
+  const uri = `${contactNode.doc().uri}#${id}`;
   return {
-    uri: "",
-    insertions: [],
-    deletions: [
-      st(groupQuery.groupNode, vcard("hasMember"), contactQuery.contactNode, groupQuery.groupNode.doc()),
-      st(contactQuery.contactNode, vcard("fn"), lit(member.name), groupQuery.groupNode.doc())
+    uri,
+    insertions: [
+      st(contactNode, vcard("hasEmail"), namedNode(uri), contactNode.doc()),
+      st(namedNode(uri), vcard("value"), namedNode("mailto:" + emailAddress), contactNode.doc())
     ],
+    deletions: [],
     filesToCreate: []
   };
 }
@@ -630,17 +748,32 @@ function addNewPhoneNumber(contactNode, phoneNumber) {
   };
 }
 
-// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/addNewEmailAddress.js
-function addNewEmailAddress(contactNode, emailAddress) {
-  const id = generateId();
-  const uri = `${contactNode.doc().uri}#${id}`;
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/removeContactFromGroup.js
+function removeContactFromGroup(contactQuery, groupQuery) {
+  const contactUri = contactQuery.contactNode.uri;
+  const member = groupQuery.queryMembers().find((it) => it.uri === contactUri);
+  if (!member) {
+    throw new Error("member not found in group");
+  }
   return {
-    uri,
-    insertions: [
-      st(contactNode, vcard("hasEmail"), namedNode(uri), contactNode.doc()),
-      st(namedNode(uri), vcard("value"), namedNode("mailto:" + emailAddress), contactNode.doc())
+    insertions: [],
+    deletions: [
+      st(groupQuery.groupNode, vcard("hasMember"), contactQuery.contactNode, groupQuery.groupNode.doc()),
+      st(contactQuery.contactNode, vcard("fn"), lit(member.name), groupQuery.groupNode.doc())
+    ],
+    filesToCreate: []
+  };
+}
+
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/removeEmailAddress.js
+function removeEmailAddress(contactNode, emailNode, store) {
+  const emailStatements = store.statementsMatching(emailNode, null, null, emailNode.doc());
+  return {
+    insertions: [],
+    deletions: [
+      ...emailStatements,
+      st(contactNode, vcard("hasEmail"), emailNode, contactNode.doc())
     ],
-    deletions: [],
     filesToCreate: []
   };
 }
@@ -649,7 +782,6 @@ function addNewEmailAddress(contactNode, emailAddress) {
 function removePhoneNumber(contactNode, phoneNode, store) {
   const phoneStatements = store.statementsMatching(phoneNode, null, null, phoneNode.doc());
   return {
-    uri: "",
     insertions: [],
     deletions: [
       ...phoneStatements,
@@ -659,97 +791,62 @@ function removePhoneNumber(contactNode, phoneNode, store) {
   };
 }
 
-// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/removeEmailAddress.js
-function removeEmailAddress(contactNode, emailNode, store) {
-  const emailStatements = store.statementsMatching(emailNode, null, null, emailNode.doc());
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/renameContact.js
+function renameContact(store, contactNode, newName) {
+  const deletions = store.statementsMatching(contactNode, vcard("fn"), null, null);
+  const insertions = deletions.map((it) => st(it.subject, it.predicate, lit(newName), it.graph));
   return {
-    uri: "",
-    insertions: [],
-    deletions: [
-      ...emailStatements,
-      st(contactNode, vcard("hasEmail"), emailNode, contactNode.doc())
-    ],
+    insertions,
+    deletions,
     filesToCreate: []
   };
 }
 
-// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/ProfileQuery.js
-var ProfileQuery = class {
-  constructor(webIdNode, store) {
-    this.webIdNode = webIdNode;
-    this.store = store;
-  }
-  queryPublicTypeIndex() {
-    const predicate = solid("publicTypeIndex");
-    return this.queryNamedNode(predicate);
-  }
-  queryPreferencesFile() {
-    const predicate = pim("preferencesFile");
-    return this.queryNamedNode(predicate);
-  }
-  queryNamedNode(predicate) {
-    const node = this.store.any(this.webIdNode, predicate, null, this.webIdNode.doc());
-    if (isNamedNode(node)) {
-      return node;
-    }
-    return null;
-  }
-};
-
-// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/TypeIndexQuery.js
-var TypeIndexQuery = class {
-  constructor(store, typeIndexDoc) {
-    this.store = store;
-    this.typeIndexDoc = typeIndexDoc;
-  }
-  queryAddressBookInstances() {
-    const addressBookRegistrations = this.store.each(null, solid("forClass"), vcard("AddressBook"), this.typeIndexDoc);
-    return addressBookRegistrations.flatMap((registration) => {
-      if (!isNamedNode(registration))
-        return [];
-      return this.getInstanceValues(registration);
-    });
-  }
-  getInstanceValues(registration) {
-    return this.store.each(registration, solid("instance"), null, this.typeIndexDoc).map((it) => it.value);
-  }
-};
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/updateEmailAddress.js
+function updateEmailAddress(emailAddressNode, newEmailAddress, store) {
+  const oldValue = store.any(emailAddressNode, vcard("value"));
+  const deletions = oldValue ? [st(emailAddressNode, vcard("value"), oldValue, emailAddressNode.doc())] : [];
+  const insertions = [
+    st(emailAddressNode, vcard("value"), namedNode("mailto:" + newEmailAddress), emailAddressNode.doc())
+  ];
+  return {
+    insertions,
+    deletions,
+    filesToCreate: []
+  };
+}
 
-// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/PreferencesQuery.js
-var PreferencesQuery = class {
-  constructor(store, webIdNode, preferencesDoc) {
-    this.store = store;
-    this.webIdNode = webIdNode;
-    this.preferencesDoc = preferencesDoc;
-  }
-  queryPrivateTypeIndex() {
-    const node = this.store.any(this.webIdNode, solid("privateTypeIndex"), null, this.preferencesDoc);
-    if (isNamedNode(node)) {
-      return node;
-    }
-    return null;
-  }
-};
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/updatePhoneNumber.js
+function updatePhoneNumber(phoneNumberNode, newPhoneNumber, store) {
+  const oldValue = store.any(phoneNumberNode, vcard("value"));
+  const deletions = oldValue ? [st(phoneNumberNode, vcard("value"), oldValue, phoneNumberNode.doc())] : [];
+  const insertions = [
+    st(phoneNumberNode, vcard("value"), namedNode("tel:" + newPhoneNumber), phoneNumberNode.doc())
+  ];
+  return {
+    insertions,
+    deletions,
+    filesToCreate: []
+  };
+}
 
 // ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/ContactsModuleRdfLib.js
+var VCARD_ADDRESS_BOOK = vcard("AddressBook");
 var ContactsModuleRdfLib = class {
   constructor(config) {
+    this.support = new ModuleSupport(config);
     this.store = config.store;
     this.fetcher = config.fetcher;
     this.updater = config.updater;
   }
   async readAddressBook(uri) {
     const addressBookNode = namedNode(uri);
-    await this.fetchNode(addressBookNode);
+    await this.support.fetchNode(addressBookNode);
     const query = new AddressBookQuery(this.store, addressBookNode);
     const title = query.queryTitle();
     const nameEmailIndex = query.queryNameEmailIndex();
     const groupIndex = query.queryGroupIndex();
-    await Promise.allSettled([
-      this.fetchNode(nameEmailIndex),
-      this.fetchNode(groupIndex)
-    ]);
-    await this.fetchAll([nameEmailIndex, groupIndex]);
+    await this.support.fetchAll([nameEmailIndex, groupIndex]);
     const contacts = query.queryContacts();
     const groups = query.queryGroups();
     return {
@@ -759,17 +856,26 @@ var ContactsModuleRdfLib = class {
       groups
     };
   }
-  async fetchNode(node) {
-    return fetchNode(this.fetcher, node);
-  }
-  async fetchAll(nodes) {
-    return Promise.all(nodes.map((it) => this.fetchNode(it)));
-  }
-  async createAddressBook({ containerUri, name }) {
+  async createAddressBook({ containerUri, name, ownerWebId }) {
     const operation = createAddressBook(containerUri, name);
     await executeUpdate(this.fetcher, this.updater, operation);
+    if (ownerWebId) {
+      await this.updatePrivateTypeIndex(ownerWebId, operation.uri);
+    }
     return operation.uri;
   }
+  async updatePrivateTypeIndex(ownerWebId, addressBookUri) {
+    const profileNode = namedNode(ownerWebId);
+    await this.support.fetchNode(profileNode);
+    const profileQuery = new ProfileQuery(profileNode, this.store);
+    const preferencesFile = profileQuery.queryPreferencesFile();
+    const privateTypeIndex = await this.fetchPrivateTypeIndex(profileNode, preferencesFile);
+    if (!privateTypeIndex) {
+      throw new Error(`Private type not found for WebID ${ownerWebId}.`);
+    }
+    const operation = addInstanceToTypeIndex(privateTypeIndex, addressBookUri, VCARD_ADDRESS_BOOK);
+    await executeUpdate(this.fetcher, this.updater, operation);
+  }
   async createNewContact({ addressBookUri, contact, groupUris }) {
     const contactQuery = await this.executeCreateNewContact(addressBookUri, contact);
     await this.executeAddContactToGroups(groupUris, contactQuery);
@@ -777,7 +883,7 @@ var ContactsModuleRdfLib = class {
   }
   async executeAddContactToGroups(groupUris, contactQuery) {
     const groupNodes = (groupUris ?? []).map((it) => namedNode(it));
-    await this.fetchAll(groupNodes);
+    await this.support.fetchAll(groupNodes);
     const groupUpdates = groupNodes.map((groupNode) => {
       const groupQuery = new GroupQuery(this.store, groupNode);
       const operation = addContactToGroup(contactQuery, groupQuery);
@@ -787,14 +893,14 @@ var ContactsModuleRdfLib = class {
   }
   async executeCreateNewContact(addressBookUri, contact) {
     const addressBookNode = namedNode(addressBookUri);
-    await this.fetchNode(addressBookNode);
+    await this.support.fetchNode(addressBookNode);
     const operation = createNewContact(new AddressBookQuery(this.store, addressBookNode), contact);
     await executeUpdate(this.fetcher, this.updater, operation);
     return new ContactQuery(this.store, namedNode(operation.uri));
   }
   async readContact(uri) {
     const contactNode = namedNode(uri);
-    await this.fetchNode(contactNode);
+    await this.support.fetchNode(contactNode);
     const query = new ContactQuery(this.store, contactNode);
     const name = query.queryName();
     const emails = query.queryEmails();
@@ -808,7 +914,7 @@ var ContactsModuleRdfLib = class {
   }
   async createNewGroup({ addressBookUri, groupName }) {
     const addressBookNode = namedNode(addressBookUri);
-    await this.fetchNode(addressBookNode);
+    await this.support.fetchNode(addressBookNode);
     const query = new AddressBookQuery(this.store, addressBookNode);
     const operation = createNewGroup(query, groupName);
     await executeUpdate(this.fetcher, this.updater, operation);
@@ -816,7 +922,7 @@ var ContactsModuleRdfLib = class {
   }
   async readGroup(uri) {
     const groupNode = namedNode(uri);
-    await this.fetchNode(groupNode);
+    await this.support.fetchNode(groupNode);
     const query = new GroupQuery(this.store, groupNode);
     const name = query.queryName();
     const members = query.queryMembers();
@@ -829,7 +935,7 @@ var ContactsModuleRdfLib = class {
   async addContactToGroup({ contactUri, groupUri }) {
     const contactNode = namedNode(contactUri);
     const groupNode = namedNode(groupUri);
-    await this.fetchNode(contactNode);
+    await this.support.fetchNode(contactNode);
     const contactQuery = new ContactQuery(this.store, contactNode);
     const groupQuery = new GroupQuery(this.store, groupNode);
     const operation = addContactToGroup(contactQuery, groupQuery);
@@ -838,7 +944,7 @@ var ContactsModuleRdfLib = class {
   async removeContactFromGroup({ contactUri, groupUri }) {
     const contactNode = namedNode(contactUri);
     const groupNode = namedNode(groupUri);
-    await this.fetchNode(groupNode);
+    await this.support.fetchNode(groupNode);
     const contactQuery = new ContactQuery(this.store, contactNode);
     const groupQuery = new GroupQuery(this.store, groupNode);
     const operation = removeContactFromGroup(contactQuery, groupQuery);
@@ -859,20 +965,32 @@ var ContactsModuleRdfLib = class {
   async removePhoneNumber({ contactUri, phoneNumberUri }) {
     const contactNode = namedNode(contactUri);
     const phoneNumberNode = namedNode(phoneNumberUri);
-    await this.fetchNode(phoneNumberNode);
+    await this.support.fetchNode(phoneNumberNode);
     const operation = removePhoneNumber(contactNode, phoneNumberNode, this.store);
     await executeUpdate(this.fetcher, this.updater, operation);
   }
   async removeEmailAddress({ contactUri, emailAddressUri }) {
     const contactNode = namedNode(contactUri);
     const emailAddressNode = namedNode(emailAddressUri);
-    await this.fetchNode(emailAddressNode);
+    await this.support.fetchNode(emailAddressNode);
     const operation = removeEmailAddress(contactNode, emailAddressNode, this.store);
     await executeUpdate(this.fetcher, this.updater, operation);
   }
+  async updatePhoneNumber({ phoneNumberUri, newPhoneNumber }) {
+    const phoneNumberNode = namedNode(phoneNumberUri);
+    await this.support.fetchNode(phoneNumberNode);
+    const operation = updatePhoneNumber(phoneNumberNode, newPhoneNumber, this.store);
+    await executeUpdate(this.fetcher, this.updater, operation);
+  }
+  async updateEmailAddress({ emailAddressUri, newEmailAddress }) {
+    const emailAddressNode = namedNode(emailAddressUri);
+    await this.support.fetchNode(emailAddressNode);
+    const operation = updateEmailAddress(emailAddressNode, newEmailAddress, this.store);
+    await executeUpdate(this.fetcher, this.updater, operation);
+  }
   async listAddressBooks(webId) {
     const profileNode = namedNode(webId);
-    await this.fetchNode(profileNode);
+    await this.support.fetchNode(profileNode);
     const profileQuery = new ProfileQuery(profileNode, this.store);
     const publicTypeIndexNode = profileQuery.queryPublicTypeIndex();
     const preferencesFile = profileQuery.queryPreferencesFile();
@@ -892,17 +1010,23 @@ var ContactsModuleRdfLib = class {
     if (!publicTypeIndexNode) {
       return [];
     }
-    await this.fetchNode(publicTypeIndexNode);
-    return new TypeIndexQuery(this.store, publicTypeIndexNode).queryAddressBookInstances();
+    await this.support.fetchNode(publicTypeIndexNode);
+    return new TypeIndexQuery(this.store, publicTypeIndexNode).queryInstancesForClass(VCARD_ADDRESS_BOOK);
   }
   async fetchPrivateTypeIndex(profileNode, preferencesFile) {
     if (!preferencesFile) {
       return null;
     }
-    await this.fetchNode(preferencesFile);
+    await this.support.fetchNode(preferencesFile);
     const preferencesQuery = new PreferencesQuery(this.store, profileNode, preferencesFile);
     return preferencesQuery.queryPrivateTypeIndex();
   }
+  async renameContact({ contactUri, newName }) {
+    const contactNode = namedNode(contactUri);
+    await this.support.fetchNode(contactNode);
+    const operation = renameContact(this.store, contactNode, newName);
+    await executeUpdate(this.fetcher, this.updater, operation);
+  }
 };
 
 // ../node_modules/@solid-data-modules/contacts-rdflib/dist/index.js