@coasys/hooks-helpers 0.8.2-prerelease → 0.9.0-rc2

package/package.json

@@ -1,24 +1,22 @@
-{
-    "name": "@coasys/hooks-helpers",
-    "version": "0.8.2-prerelease",
-    "description": "",
-    "main": "./src/index.ts",
-    "module": "./src/index.ts",
-    "private": false,
-    "type": "module",
-    "files": [
-      "dist",
-      "src"
-    ],
-    "scripts": {
-      "test": "echo \"Error: no test specified\" && exit 1"
-    },
-    "keywords": [],
-    "author": "",
-    "license": "ISC",
-    "dependencies": {
-      "@coasys/ad4m": "*",
-      "@coasys/ad4m-connect": "*",
-      "uuid": "*"
-    }
-  }
+{
+  "name": "@coasys/hooks-helpers",
+  "version": "0.9.0-rc2",
+  "description": "",
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
+  "private": false,
+  "type": "module",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {},
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@coasys/ad4m": "*",
+    "@coasys/ad4m-connect": "*",
+    "uuid": "*"
+  }
+}

package/src/cache.ts

@@ -1,70 +1,70 @@
-import { PerspectiveProxy } from "@coasys/ad4m";
-
-const cache: Map<string, any> = new Map();
-const subscribers: Map<string, Function[]> = new Map();
-
-export function getCache<T>(key: string) {
-  const match: T | undefined = cache.get(key);
-  return match;
-}
-
-export function setCache<T>(key: string, value: T) {
-  cache.set(key, value);
-  getSubscribers(key).forEach((cb) => cb());
-}
-
-export function subscribe(key: string, callback: Function) {
-  getSubscribers(key).push(callback);
-}
-
-export function unsubscribe(key: string, callback: Function) {
-  const subs = getSubscribers(key);
-  const index = subs.indexOf(callback);
-  if (index >= 0) {
-    subs.splice(index, 1);
-  }
-}
-
-export function getSubscribers(key: string) {
-  if (!subscribers.has(key)) subscribers.set(key, []);
-  return subscribers.get(key)!;
-}
-
-export function subscribeToPerspective(
-  perspective: PerspectiveProxy,
-  added: Function,
-  removed: Function
-) {
-  const addedKey = `perspective-${perspective.uuid}-added`;
-  const removedKey = `perspective-${perspective.uuid}-removed`;
-
-  if (!subscribers.has(addedKey)) {
-    console.log("subscribing!");
-    perspective.addListener("link-added", (link) => {
-      subscribers.get(addedKey).forEach((cb) => cb(link));
-      return null;
-    });
-  }
-
-  if (!subscribers.has(removedKey)) {
-    perspective.addListener("link-removed", (link) => {
-      subscribers.get(removedKey).forEach((cb) => cb(link));
-      return null;
-    });
-  }
-
-  subscribe(addedKey, added);
-  subscribe(removedKey, removed);
-}
-
-export function unsubscribeToPerspective(
-  perspective: PerspectiveProxy,
-  added: Function,
-  removed: Function
-) {
-  const addedKey = `perspective-${perspective.uuid}-added`;
-  const removedKey = `perspective-${perspective.uuid}-removed`;
-
-  unsubscribe(addedKey, added);
-  unsubscribe(removedKey, removed);
-}
+import { PerspectiveProxy } from "@coasys/ad4m";
+
+const cache: Map<string, any> = new Map();
+const subscribers: Map<string, Function[]> = new Map();
+
+export function getCache<T>(key: string) {
+  const match: T | undefined = cache.get(key);
+  return match;
+}
+
+export function setCache<T>(key: string, value: T) {
+  cache.set(key, value);
+  getSubscribers(key).forEach((cb) => cb());
+}
+
+export function subscribe(key: string, callback: Function) {
+  getSubscribers(key).push(callback);
+}
+
+export function unsubscribe(key: string, callback: Function) {
+  const subs = getSubscribers(key);
+  const index = subs.indexOf(callback);
+  if (index >= 0) {
+    subs.splice(index, 1);
+  }
+}
+
+export function getSubscribers(key: string) {
+  if (!subscribers.has(key)) subscribers.set(key, []);
+  return subscribers.get(key)!;
+}
+
+export function subscribeToPerspective(
+  perspective: PerspectiveProxy,
+  added: Function,
+  removed: Function
+) {
+  const addedKey = `perspective-${perspective.uuid}-added`;
+  const removedKey = `perspective-${perspective.uuid}-removed`;
+
+  if (!subscribers.has(addedKey)) {
+    console.log("subscribing!");
+    perspective.addListener("link-added", (link) => {
+      subscribers.get(addedKey).forEach((cb) => cb(link));
+      return null;
+    });
+  }
+
+  if (!subscribers.has(removedKey)) {
+    perspective.addListener("link-removed", (link) => {
+      subscribers.get(removedKey).forEach((cb) => cb(link));
+      return null;
+    });
+  }
+
+  subscribe(addedKey, added);
+  subscribe(removedKey, removed);
+}
+
+export function unsubscribeFromPerspective(
+  perspective: PerspectiveProxy,
+  added: Function,
+  removed: Function
+) {
+  const addedKey = `perspective-${perspective.uuid}-added`;
+  const removedKey = `perspective-${perspective.uuid}-removed`;
+
+  unsubscribe(addedKey, added);
+  unsubscribe(removedKey, removed);
+}

package/src/factory/SubjectRepository.ts

@@ -1,257 +1,257 @@
-import {
-  PerspectiveProxy,
-  Link,
-  Subject,
-  Literal,
-  LinkQuery,
-} from "@coasys/ad4m";
-import { setProperties } from "./model";
-import { v4 as uuidv4 } from "uuid";
-
-export const SELF = "ad4m://self";
-
-export type ModelProps = {
-  perspective: PerspectiveProxy;
-  source?: string;
-};
-
-export class SubjectRepository<SubjectClass extends { [x: string]: any }> {
-  source = SELF;
-  subject: SubjectClass | string;
-  perspective: PerspectiveProxy;
-  tempSubject: any | string;
-
-  constructor(subject: { new (): SubjectClass } | string, props: ModelProps) {
-    this.perspective = props.perspective;
-    this.source = props.source || this.source;
-    this.subject = typeof subject === "string" ? subject : new subject();
-    this.tempSubject = subject;
-  }
-
-  get className(): string {
-    return typeof this.subject === "string"
-      ? this.subject
-      : this.subject.className;
-  }
-
-  async ensureSubject() {
-    if (typeof this.tempSubject === "string") return;
-    await this.perspective.ensureSDNASubjectClass(this.tempSubject);
-  }
-
-  async create(
-    data: SubjectClass,
-    id?: string,
-    source?: string
-  ): Promise<SubjectClass> {
-    await this.ensureSubject();
-    const base = id || Literal.from(uuidv4()).toUrl();
-
-    let newInstance = await this.perspective.createSubject(this.subject, base);
-
-    if (!newInstance) {
-      throw "Failed to create new instance of " + this.subject;
-    }
-
-    // Connect new instance to source
-    await this.perspective.add(
-      new Link({
-        source: source || this.source,
-        predicate: "ad4m://has_child",
-        target: base,
-      })
-    );
-
-    Object.keys(data).forEach((key) =>
-      data[key] === undefined || data[key] === null ? delete data[key] : {}
-    );
-
-    setProperties(newInstance, data);
-
-    // @ts-ignore
-    return this.getSubjectData(newInstance);
-  }
-
-  async update(id: string, data: QueryPartialEntity<SubjectClass>) {
-    await this.ensureSubject();
-
-    const instance = await this.get(id);
-
-    if (!instance) {
-      throw "Failed to find instance of " + this.subject + " with id " + id;
-    }
-
-    Object.keys(data).forEach((key) =>
-      data[key] === undefined ? delete data[key] : {}
-    );
-
-    // @ts-ignore
-    setProperties(instance, data);
-
-    return this.getSubjectData(instance);
-  }
-
-  async remove(id: string) {
-    if (this.perspective) {
-      const linksTo = await this.perspective.get(new LinkQuery({ target: id }));
-      const linksFrom = await this.perspective.get(
-        new LinkQuery({ source: id })
-      );
-      this.perspective.removeLinks([...linksFrom, ...linksTo]);
-    }
-  }
-
-  async get(id: string): Promise<SubjectClass | null> {
-    await this.ensureSubject();
-    if (id) {
-      const subjectProxy = await this.perspective.getSubjectProxy(
-        id,
-        this.subject
-      );
-
-      // @ts-ignore
-      return subjectProxy || null;
-    } else {
-      const all = await this.getAll();
-      return all[0] || null;
-    }
-  }
-
-  async getData(id: string): Promise<SubjectClass | string | null> {
-    await this.ensureSubject();
-    const entry = await this.get(id);
-    if (entry) {
-      // @ts-ignore
-      return await this.getSubjectData(entry);
-    }
-
-    return null;
-  }
-
-  private async getSubjectData(entry: any) {
-    let links = await this.perspective.get(
-      new LinkQuery({ source: entry.baseExpression })
-    );
-
-    const getters = Object.entries(Object.getOwnPropertyDescriptors(entry))
-      .filter(([key, descriptor]) => typeof descriptor.get === "function")
-      .map(([key]) => key);
-
-    const promises = getters.map((getter) => entry[getter]);
-    return Promise.all(promises).then((values) => {
-      return getters.reduce((acc, getter, index) => {
-        let value = values[index];
-        if (this.tempSubject.prototype?.__properties[getter]?.transform) {
-          value =
-            this.tempSubject.prototype.__properties[getter].transform(value);
-        }
-
-        return {
-          ...acc,
-          id: entry.baseExpression,
-          timestamp: links[0].timestamp,
-          author: links[0].author,
-          [getter]: value,
-        };
-      }, {});
-    });
-  }
-
-  async getAll(source?: string, query?: QueryOptions): Promise<SubjectClass[]> {
-    await this.ensureSubject();
-
-    const tempSource = source || this.source;
-
-    let res = [];
-
-    if (query) {
-      try {
-        const queryResponse = (
-          await this.perspective.infer(
-            `findall([Timestamp, Base], (subject_class("${this.className}", C), instance(C, Base), link("${tempSource}", Predicate, Base, Timestamp, Author)), AllData), length(AllData, DataLength), sort(AllData, SortedData).`
-          )
-        )[0];
-
-        if (queryResponse.SortedData >= query.size) {
-          const isOutofBound =
-            query.size * query.page > queryResponse.DataLength;
-
-          const newPageSize = isOutofBound
-            ? queryResponse.DataLength - query.size * (query.page - 1)
-            : query.size;
-
-          const mainQuery = `findall([Timestamp, Base], (subject_class("${this.className}", C), instance(C, Base), link("${tempSource}", Predicate, Base, Timestamp, Author)), AllData), sort(AllData, SortedData), reverse(SortedData, ReverseSortedData), paginate(ReverseSortedData, ${query.page}, ${newPageSize}, PageData).`;
-          res = await this.perspective.infer(mainQuery);
-
-          res = res[0].PageData.map((r) => ({
-            Base: r[1],
-            Timestamp: r[0],
-          }));
-        } else {
-          res = await this.perspective.infer(
-            `subject_class("${this.className}", C), instance(C, Base), triple("${tempSource}", Predicate, Base).`
-          );
-        }
-      } catch (e) {
-        console.log("Query failed", e);
-      }
-    } else {
-      res = await this.perspective.infer(
-        `subject_class("${this.className}", C), instance(C, Base), triple("${tempSource}", Predicate, Base).`
-      );
-    }
-
-    const results =
-      res &&
-      res.filter(
-        (obj, index, self) =>
-          index === self.findIndex((t) => t.Base === obj.Base)
-      );
-
-    if (!res) return [];
-
-    const data = await Promise.all(
-      results.map(async (result) => {
-        let subject = new Subject(
-          this.perspective!,
-          result.Base,
-          this.className
-        );
-
-        await subject.init();
-
-        return subject;
-      })
-    );
-
-    // @ts-ignore
-    return data;
-  }
-
-  async getAllData(
-    source?: string,
-    query?: QueryOptions
-  ): Promise<SubjectClass[]> {
-    await this.ensureSubject();
-
-    const subjects = await this.getAll(source, query);
-
-    const entries = await Promise.all(
-      subjects.map((e) => this.getSubjectData(e))
-    );
-
-    // @ts-ignore
-    return entries;
-  }
-}
-
-export type QueryPartialEntity<T> = {
-  [P in keyof T]?: T[P] | (() => string);
-};
-
-export type QueryOptions = {
-  page: number;
-  size: number;
-  infinite: boolean;
-  uniqueKey: string;
-};
+import {
+  PerspectiveProxy,
+  Link,
+  Subject,
+  Literal,
+  LinkQuery,
+} from "@coasys/ad4m";
+import { setProperties } from "./model";
+import { v4 as uuidv4 } from "uuid";
+
+export const SELF = "ad4m://self";
+
+export type ModelProps = {
+  perspective: PerspectiveProxy;
+  source?: string;
+};
+
+export class SubjectRepository<SubjectClass extends { [x: string]: any }> {
+  source = SELF;
+  subject: SubjectClass | string;
+  perspective: PerspectiveProxy;
+  tempSubject: any | string;
+
+  constructor(subject: { new (): SubjectClass } | string, props: ModelProps) {
+    this.perspective = props.perspective;
+    this.source = props.source || this.source;
+    this.subject = typeof subject === "string" ? subject : new subject();
+    this.tempSubject = subject;
+  }
+
+  get className(): string {
+    return typeof this.subject === "string"
+      ? this.subject
+      : this.subject.className;
+  }
+
+  async ensureSubject() {
+    if (typeof this.tempSubject === "string") return;
+    await this.perspective.ensureSDNASubjectClass(this.tempSubject);
+  }
+
+  async create(
+    data: SubjectClass,
+    id?: string,
+    source?: string
+  ): Promise<SubjectClass> {
+    await this.ensureSubject();
+    const base = id || Literal.from(uuidv4()).toUrl();
+
+    let newInstance = await this.perspective.createSubject(this.subject, base);
+
+    if (!newInstance) {
+      throw "Failed to create new instance of " + this.subject;
+    }
+
+    // Connect new instance to source
+    await this.perspective.add(
+      new Link({
+        source: source || this.source,
+        predicate: "ad4m://has_child",
+        target: base,
+      })
+    );
+
+    Object.keys(data).forEach((key) =>
+      data[key] === undefined || data[key] === null ? delete data[key] : {}
+    );
+
+    setProperties(newInstance, data);
+
+    // @ts-ignore
+    return this.getSubjectData(newInstance);
+  }
+
+  async update(id: string, data: QueryPartialEntity<SubjectClass>) {
+    await this.ensureSubject();
+
+    const instance = await this.get(id);
+
+    if (!instance) {
+      throw "Failed to find instance of " + this.subject + " with id " + id;
+    }
+
+    Object.keys(data).forEach((key) =>
+      data[key] === undefined ? delete data[key] : {}
+    );
+
+    // @ts-ignore
+    setProperties(instance, data);
+
+    return this.getSubjectData(instance);
+  }
+
+  async remove(id: string) {
+    if (this.perspective) {
+      const linksTo = await this.perspective.get(new LinkQuery({ target: id }));
+      const linksFrom = await this.perspective.get(
+        new LinkQuery({ source: id })
+      );
+      this.perspective.removeLinks([...linksFrom, ...linksTo]);
+    }
+  }
+
+  async get(id: string): Promise<SubjectClass | null> {
+    await this.ensureSubject();
+    if (id) {
+      const subjectProxy = await this.perspective.getSubjectProxy(
+        id,
+        this.subject
+      );
+
+      // @ts-ignore
+      return subjectProxy || null;
+    } else {
+      const all = await this.getAll();
+      return all[0] || null;
+    }
+  }
+
+  async getData(id: string): Promise<SubjectClass | string | null> {
+    await this.ensureSubject();
+    const entry = await this.get(id);
+    if (entry) {
+      // @ts-ignore
+      return await this.getSubjectData(entry);
+    }
+
+    return null;
+  }
+
+  private async getSubjectData(entry: any) {
+    let links = await this.perspective.get(
+      new LinkQuery({ source: entry.baseExpression })
+    );
+
+    const getters = Object.entries(Object.getOwnPropertyDescriptors(entry))
+      .filter(([key, descriptor]) => typeof descriptor.get === "function")
+      .map(([key]) => key);
+
+    const promises = getters.map((getter) => entry[getter]);
+    return Promise.all(promises).then((values) => {
+      return getters.reduce((acc, getter, index) => {
+        let value = values[index];
+        if (this.tempSubject.prototype?.__properties[getter]?.transform) {
+          value =
+            this.tempSubject.prototype.__properties[getter].transform(value);
+        }
+
+        return {
+          ...acc,
+          id: entry.baseExpression,
+          timestamp: links[0].timestamp,
+          author: links[0].author,
+          [getter]: value,
+        };
+      }, {});
+    });
+  }
+
+  async getAll(source?: string, query?: QueryOptions): Promise<SubjectClass[]> {
+    await this.ensureSubject();
+
+    const tempSource = source || this.source;
+
+    let res = [];
+
+    if (query) {
+      try {
+        const queryResponse = (
+          await this.perspective.infer(
+            `findall([Timestamp, Base], (subject_class("${this.className}", C), instance(C, Base), link("${tempSource}", Predicate, Base, Timestamp, Author)), AllData), length(AllData, DataLength), sort(AllData, SortedData).`
+          )
+        )[0];
+
+        if (queryResponse.SortedData >= query.size) {
+          const isOutofBound =
+            query.size * query.page > queryResponse.DataLength;
+
+          const newPageSize = isOutofBound
+            ? queryResponse.DataLength - query.size * (query.page - 1)
+            : query.size;
+
+          const mainQuery = `findall([Timestamp, Base], (subject_class("${this.className}", C), instance(C, Base), link("${tempSource}", Predicate, Base, Timestamp, Author)), AllData), sort(AllData, SortedData), reverse(SortedData, ReverseSortedData), paginate(ReverseSortedData, ${query.page}, ${newPageSize}, PageData).`;
+          res = await this.perspective.infer(mainQuery);
+
+          res = res[0].PageData.map((r) => ({
+            Base: r[1],
+            Timestamp: r[0],
+          }));
+        } else {
+          res = await this.perspective.infer(
+            `subject_class("${this.className}", C), instance(C, Base), triple("${tempSource}", Predicate, Base).`
+          );
+        }
+      } catch (e) {
+        console.log("Query failed", e);
+      }
+    } else {
+      res = await this.perspective.infer(
+        `subject_class("${this.className}", C), instance(C, Base), triple("${tempSource}", Predicate, Base).`
+      );
+    }
+
+    const results =
+      res &&
+      res.filter(
+        (obj, index, self) =>
+          index === self.findIndex((t) => t.Base === obj.Base)
+      );
+
+    if (!res) return [];
+
+    const data = await Promise.all(
+      results.map(async (result) => {
+        let subject = new Subject(
+          this.perspective!,
+          result.Base,
+          this.className
+        );
+
+        await subject.init();
+
+        return subject;
+      })
+    );
+
+    // @ts-ignore
+    return data;
+  }
+
+  async getAllData(
+    source?: string,
+    query?: QueryOptions
+  ): Promise<SubjectClass[]> {
+    await this.ensureSubject();
+
+    const subjects = await this.getAll(source, query);
+
+    const entries = await Promise.all(
+      subjects.map((e) => this.getSubjectData(e))
+    );
+
+    // @ts-ignore
+    return entries;
+  }
+}
+
+export type QueryPartialEntity<T> = {
+  [P in keyof T]?: T[P] | (() => string);
+};
+
+export type QueryOptions = {
+  page: number;
+  size: number;
+  infinite: boolean;
+  uniqueKey: string;
+};

package/src/factory/index.ts

@@ -1 +1 @@
-export * from "./SubjectRepository";
+export * from "./SubjectRepository";

package/src/factory/model.ts

@@ -1,57 +1,57 @@
-type Target = String;
-
-export type PropertyValueMap = {
-  [property: string]: Target | Target[];
-};
-
-export function capitalize(str: string) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-
-// e.g. "name" -> "setName"
-export function propertyNameToSetterName(property: string): string {
-  return `set${capitalize(property)}`;
-}
-
-export function pluralToSingular(plural: string): string {
-  if (plural.endsWith("ies")) {
-    return plural.slice(0, -3) + "y";
-  } else if (plural.endsWith("s")) {
-    return plural.slice(0, -1);
-  } else {
-    return plural;
-  }
-}
-
-// e.g. "comments" -> "addComment"
-export function collectionToAdderName(collection: string): string {
-  return `add${capitalize(collection)}`;
-}
-
-export function collectionToSetterName(collection: string): string {
-  return `setCollection${capitalize(collection)}`;
-}
-
-export function setProperties(subject: any, properties: PropertyValueMap) {
-  Object.keys(properties).forEach((key) => {
-    if (Array.isArray(properties[key])) {
-      // it's a collection
-      const adderName = collectionToAdderName(key);
-      const adderFunction = subject[adderName];
-      if (adderFunction) {
-        adderFunction(properties[key]);
-      } else {
-        throw "No adder function found for collection: " + key;
-      }
-    } else {
-      // it's a property
-      const setterName = propertyNameToSetterName(key);
-      const setterFunction = subject[setterName];
-      if (setterFunction) {
-        setterFunction(properties[key]);
-      } else {
-        throw "No setter function found for property: " + key;
-      }
-    }
-  });
-}
+type Target = String;
+
+export type PropertyValueMap = {
+  [property: string]: Target | Target[];
+};
+
+export function capitalize(str: string) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// e.g. "name" -> "setName"
+export function propertyNameToSetterName(property: string): string {
+  return `set${capitalize(property)}`;
+}
+
+export function pluralToSingular(plural: string): string {
+  if (plural.endsWith("ies")) {
+    return plural.slice(0, -3) + "y";
+  } else if (plural.endsWith("s")) {
+    return plural.slice(0, -1);
+  } else {
+    return plural;
+  }
+}
+
+// e.g. "comments" -> "addComment"
+export function collectionToAdderName(collection: string): string {
+  return `add${capitalize(collection)}`;
+}
+
+export function collectionToSetterName(collection: string): string {
+  return `setCollection${capitalize(collection)}`;
+}
+
+export function setProperties(subject: any, properties: PropertyValueMap) {
+  Object.keys(properties).forEach((key) => {
+    if (Array.isArray(properties[key])) {
+      // it's a collection
+      const adderName = collectionToAdderName(key);
+      const adderFunction = subject[adderName];
+      if (adderFunction) {
+        adderFunction(properties[key]);
+      } else {
+        throw "No adder function found for collection: " + key;
+      }
+    } else {
+      // it's a property
+      const setterName = propertyNameToSetterName(key);
+      const setterFunction = subject[setterName];
+      if (setterFunction) {
+        setterFunction(properties[key]);
+      } else {
+        throw "No setter function found for property: " + key;
+      }
+    }
+  });
+}

package/src/getProfile.ts

@@ -1,26 +1,26 @@
-import { Ad4mClient } from "@coasys/ad4m";
-// @ts-ignore
-import { getAd4mClient } from "@coasys/ad4m-connect/utils";
-import { LinkExpression } from "@coasys/ad4m";
-
-export interface Payload {
-  url: string;
-  perspectiveUuid: string;
-}
-
-export async function getProfile<T>(did: string, formatter?: (links: LinkExpression[]) => T): Promise<T | any> {
-  const cleanedDid = did.replace("did://", "");
-  const client: Ad4mClient = await getAd4mClient();
-
-  const agentPerspective = await client.agent.byDID(cleanedDid);
-
-  if (agentPerspective) {
-    const links = agentPerspective!.perspective!.links;
-
-    if (formatter) {
-      return formatter(links);
-    }
-
-    return agentPerspective
-  }
-}
+import { Ad4mClient } from "@coasys/ad4m";
+// @ts-ignore
+import { getAd4mClient } from "@coasys/ad4m-connect/utils";
+import { LinkExpression } from "@coasys/ad4m";
+
+export interface Payload {
+  url: string;
+  perspectiveUuid: string;
+}
+
+export async function getProfile<T>(did: string, formatter?: (links: LinkExpression[]) => T): Promise<T | any> {
+  const cleanedDid = did.replace("did://", "");
+  const client: Ad4mClient = await getAd4mClient();
+
+  const agentPerspective = await client.agent.byDID(cleanedDid);
+
+  if (agentPerspective) {
+    const links = agentPerspective!.perspective!.links;
+
+    if (formatter) {
+      return formatter(links);
+    }
+
+    return agentPerspective
+  }
+}

package/src/index.ts

@@ -1,3 +1,3 @@
-export * from './cache'
-export * from './getProfile'
+export * from './cache'
+export * from './getProfile'
 export * from './factory'