solid-logic 1.3.17-80b4d030 → 1.3.17-81536f11

package/test/typeIndexLogic.test.ts

@@ -1,69 +1,499 @@
+/**
+* @jest-environment jsdom
+* 
+*/
 import { Fetcher, Store, sym, UpdateManager } from "rdflib";
 import { createAclLogic } from "../src/acl/aclLogic";
 import { createProfileLogic } from "../src/profile/profileLogic";
-import { createTypeIndexLogic } from "../src/typeIndex/typeIndexLogic";
-import { AuthenticationContext } from "../src/types";
+import { createTypeIndexLogic} from "../src/typeIndex/typeIndexLogic";
 import { createContainerLogic } from "../src/util/containerLogic";
+import { ns } from "../src/util/ns";
 import { createUtilityLogic } from "../src/util/utilityLogic";
-import { alice } from "./helpers/dataSetup";
+import { uniqueNodes } from "../src/util/utils";
+import { alice, AlicePhotoFolder, AlicePhotos, AlicePreferences, AlicePreferencesFile, AlicePrivateTypeIndex, AlicePrivateTypes, AliceProfile, AlicePublicTypeIndex, AlicePublicTypes, bob, BobProfile, club, ClubPreferences, ClubPreferencesFile, ClubPrivateTypeIndex, ClubPrivateTypes, ClubProfile, ClubPublicTypeIndex, ClubPublicTypes } from "./helpers/dataSetup";
 
-let store;
-let options;
+const prefixes = Object.keys(ns).map(prefix => `@prefix ${prefix}: ${ns[prefix]('')}.\n`).join('') // In turtle
+window.$SolidTestEnvironment = { username: alice.uri }
+
+const Tracker = ns.wf('Tracker')
+const Image = ns.schema('Image')
+
+//let web = {}
+//web = loadWebObject()
+const user = alice
+const profile = user.doc()
+const web = {}
+web[profile.uri] = AliceProfile
+web[AlicePreferencesFile.uri] = AlicePreferences
+web[AlicePrivateTypeIndex.uri] = AlicePrivateTypes
+web[AlicePublicTypeIndex.uri] = AlicePublicTypes
+web[AlicePhotoFolder.uri] = AlicePhotos
+web[bob.doc().uri] = BobProfile
+
+web[club.doc().uri] = ClubProfile
+web[ClubPreferencesFile.uri] = ClubPreferences
+web[ClubPrivateTypeIndex.uri] = ClubPrivateTypes
+web[ClubPublicTypeIndex.uri] = ClubPublicTypes
+let requests = []
+let statustoBeReturned = 200
 let typeIndexLogic
-const authn = {
-    currentUser: () => {
-        return alice;
-    },
-};
-describe('typeIndexLogic', () => { 
-  beforeEach(() => {
-      options = { fetch: fetch };
-      store = new Store()
-      store.fetcher = new Fetcher(store, options);
-      store.updater = new UpdateManager(store);
-      const util = createUtilityLogic(store, createAclLogic(store), createContainerLogic(store))
-      typeIndexLogic = createTypeIndexLogic(store, authn, createProfileLogic(store, authn, util), util)
-
-  })
-  describe('loadIndex', () => {
-    it('loadIndex', async () => {
-      const context = {
-        index: {}
-      }
-
-      const result = await typeIndexLogic.loadIndex(context, true)
-      expect(result).toEqual({
-        index: {
-          private: [],
-          public: []
-        },
-      })
+
+describe("TypeIndex logic NEW", () => {
+    let store;
+    const authn = {
+        currentUser: () => {
+            return alice;
+        },
+    };
+    
+    beforeEach(() => {
+        fetchMock.resetMocks();
+        requests = []
+        statustoBeReturned = 200
+        const init = { headers: { "Content-Type": "text/turtle" } } // Fetch options tend to be called this
+
+        fetchMock.mockIf(/^https?.*$/, async req => {
+
+        if (req.method !== 'GET') {
+            requests.push(req)
+            if (req.method === 'PUT') {
+            const contents = await req.text()
+            web[req.url] = contents // Update our dummy web
+            console.log(`Tetst: Updated ${req.url} on PUT to <<<${web[req.url]}>>>`)
+            }
+            return { status: statustoBeReturned }
+        }
+        const contents = web[req.url]
+        if (contents !== undefined) { //
+            return {
+            body: prefixes + contents, // Add namespaces to anything
+            status: 200,
+            headers: {
+                "Content-Type": "text/turtle",
+                "WAC-Allow": 'user="write", public="read"',
+                "Accept-Patch": "application/sparql-update"
+            }
+            }
+        } // if contents
+        return {
+            status: 404,
+            body: 'Not Found'
+        }
+        })
+        
+        store = new Store()
+        store.fetcher = new Fetcher(store, { fetch: fetch });
+        store.updater = new UpdateManager(store);
+        const util = createUtilityLogic(store, createAclLogic(store), createContainerLogic(store))
+        typeIndexLogic = createTypeIndexLogic(store, authn, createProfileLogic(store, authn, util), util)
+    });
+
+    describe('loadAllTypeIndexes', () => {
+        it('exists', () => {
+        expect(typeIndexLogic.loadAllTypeIndexes).toBeInstanceOf(Function)
+        })
     })
-  })
 
-  describe('loadTypeIndexes', () => {
-    it('exists', () => {
-      expect(typeIndexLogic.loadTypeIndexes).toBeInstanceOf(Function)
+    const AliceScopes = [{
+        "agent": {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/profile/card.ttl#me",
+        },
+        "index": {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/profile/public-type-index.ttl",
+        },
+        "label": "public",
+    },
+    {
+        "agent": {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/profile/card.ttl#me",
+        },
+        "index": {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/settings/private-type-index.ttl",
+        },
+        "label": "private",
+    }
+    ];
+
+    describe('loadTypeIndexesFor', () => {
+        it('exists', () => {
+            expect(typeIndexLogic.loadTypeIndexesFor).toBeInstanceOf(Function)
+        })
+        it('loads data', async () => {
+            const result = await typeIndexLogic.loadTypeIndexesFor(alice)
+            expect(result).toEqual(AliceScopes)
+            expect(store.statementsMatching(null, null, null, AlicePrivateTypeIndex).length).toEqual(8)
+            expect(store.statementsMatching(null, null, null, AlicePublicTypeIndex).length).toEqual(8)
+        })
     })
-    it('runs', async () => {
-      const result = await typeIndexLogic.loadTypeIndexes({})
-      expect(result).toBeInstanceOf(Object)
+
+    const ClubScopes =
+        [
+        {
+            "agent": {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/profile/card.ttl#it",
+            },
+            "index": {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/profile/public-type-index.ttl",
+            },
+            "label": "public",
+        },
+        {
+            "agent": {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/profile/card.ttl#it",
+            },
+            "index": {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/settings/private-type-index.ttl",
+            },
+            "label": "private",
+        }
+        ]
+    describe('loadCommunityTypeIndexes', () => {
+        it('exists', () => {
+        expect(typeIndexLogic.loadCommunityTypeIndexes).toBeInstanceOf(Function)
+        })
+        it('loads data', async () => {
+        const result = await typeIndexLogic.loadCommunityTypeIndexes(alice)
+        expect(result).toEqual(ClubScopes)
+        })
     })
-  })
 
-  describe('registerInTypeIndex', () => {
-    it('exists', () => {
-      expect(typeIndexLogic.registerInTypeIndex).toBeInstanceOf(Function)
+    const AliceAndClubScopes =
+    [
+    {
+        "instance":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/publicStuff/actionItems.ttl#this",
+        },
+        "scope":  {
+        "agent":  {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://alice.example.com/profile/card.ttl#me",
+        },
+        "index":  {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://alice.example.com/profile/public-type-index.ttl",
+        },
+        "label": "public",
+        },
+    },
+    {
+        "instance":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/project4/issues.ttl#this",
+        },
+        "scope": {
+        "agent":  {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://alice.example.com/profile/card.ttl#me",
+        },
+        "index": {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://alice.example.com/profile/public-type-index.ttl",
+        },
+        "label": "public",
+        },
+    },
+    {
+        "instance":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/privateStuff/ToDo.ttl#this",
+        },
+        "scope":  {
+        "agent": {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://alice.example.com/profile/card.ttl#me",
+        },
+        "index":  {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://alice.example.com/settings/private-type-index.ttl",
+        },
+        "label": "private",
+        },
+    },
+    {
+        "instance":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/privateStuff/Goals.ttl#this",
+        },
+        "scope": {
+        "agent":  {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://alice.example.com/profile/card.ttl#me",
+        },
+        "index":  {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://alice.example.com/settings/private-type-index.ttl",
+        },
+        "label": "private",
+        },
+    },
+    {
+        "instance":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/privateStuff/workingOn.ttl#this",
+        },
+        "scope":  {
+        "agent":  {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://alice.example.com/profile/card.ttl#me",
+        },
+        "index":  {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://alice.example.com/settings/private-type-index.ttl",
+        },
+        "label": "private",
+        },
+    },
+    {
+        "instance":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/publicStuff/actionItems.ttl#this",
+        },
+        "scope": {
+        "agent":  {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/profile/card.ttl#it",
+        },
+        "index":  {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/profile/public-type-index.ttl",
+        },
+        "label": "public",
+        },
+    },
+    {
+        "instance":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/project4/clubIssues.ttl#this",
+        },
+        "scope":  {
+        "agent": {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/profile/card.ttl#it",
+        },
+        "index":  {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/profile/public-type-index.ttl",
+        },
+        "label": "public",
+        },
+    },
+    {
+        "instance": {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/privateStuff/ToDo.ttl#this",
+        },
+        "scope":  {
+        "agent":  {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/profile/card.ttl#it",
+        },
+        "index":  {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/settings/private-type-index.ttl",
+        },
+        "label": "private",
+        },
+    },
+    {
+        "instance":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/privateStuff/Goals.ttl#this",
+        },
+        "scope":  {
+        "agent":  {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/profile/card.ttl#it",
+        },
+        "index":  {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/settings/private-type-index.ttl",
+        },
+        "label": "private",
+        },
+    },
+    {
+        "instance":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/privateStuff/tasks.ttl#this",
+        },
+        "scope":  {
+        "agent":  {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/profile/card.ttl#it",
+        },
+        "index":  {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/settings/private-type-index.ttl",
+        },
+        "label": "private",
+        },
+    },
+    ]
+
+    describe('getScopedAppInstances', () => {
+        it('exists', () => {
+        expect(typeIndexLogic.getScopedAppInstances).toBeInstanceOf(Function)
+        })
+        it('pulls in users scopes and also community ones', async () => {
+        const result = await typeIndexLogic.getScopedAppInstances(Tracker, alice)
+        expect(result).toEqual(AliceAndClubScopes)
+        })
+        it('creates new preferenceFile and typeIndex files where they dont exist', async () => {
+        const result = await typeIndexLogic.getScopedAppInstances(Tracker, bob)
+
+        expect(requests[0].method).toEqual('PATCH') // Add preferrencesFile link to profile
+        expect(requests[0].url).toEqual('https://bob.example.com/profile/card.ttl')
+
+        expect(requests[1].method).toEqual('PUT') // create publiTypeIndex
+        expect(requests[1].url).toEqual('https://bob.example.com/profile/publicTypeIndex.ttl')
+
+        expect(requests[2].method).toEqual('PATCH') // Add link of publiTypeIndex to profile
+        expect(requests[2].url).toEqual('https://bob.example.com/profile/card.ttl')
+
+        expect(requests[3].method).toEqual('PUT') // create preferenceFile
+        expect(requests[3].url).toEqual('https://bob.example.com/Settings/Preferences.ttl')
+
+        expect(requests[4].method).toEqual('PATCH') // Add privateTypeIndex link preference file
+        expect(requests[4].url).toEqual('https://bob.example.com/Settings/Preferences.ttl')
+
+        expect(requests[5].method).toEqual('PUT') //create privatTypeIndex
+        expect(requests[5].url).toEqual('https://bob.example.com/Settings/privateTypeIndex.ttl')
+
+        expect(requests.length).toEqual(6)
+
+        })
     })
-    it('throws error', async () => {
-      expect(typeIndexLogic.registerInTypeIndex(
-        {} as AuthenticationContext,
-        sym('https://test.test#'),
-        sym('https://test.test#'),
-        false
-      )).rejects
-        .toThrow('@@ ensureLoadedPreferences: no user specified')
+
+    const TRACKERS =
+        [
+        {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://alice.example.com/publicStuff/actionItems.ttl#this",
+        },
+        {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://alice.example.com/project4/issues.ttl#this",
+        },
+        {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://alice.example.com/privateStuff/ToDo.ttl#this",
+        },
+        {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://alice.example.com/privateStuff/Goals.ttl#this",
+        },
+        {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://alice.example.com/privateStuff/workingOn.ttl#this",
+        },
+        {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/publicStuff/actionItems.ttl#this",
+        },
+        {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/project4/clubIssues.ttl#this",
+        },
+        {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/privateStuff/ToDo.ttl#this",
+        },
+        {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/privateStuff/Goals.ttl#this",
+        },
+        {
+            "classOrder": 5,
+            "termType": "NamedNode",
+            "value": "https://club.example.com/privateStuff/tasks.ttl#this",
+        },
+        ]
+
+    describe('getAppInstances', () => {
+        it('exists', () => {
+        expect(typeIndexLogic.getAppInstances).toBeInstanceOf(Function)
+        })
+        it('finds trackers', async () => {
+        const result = await typeIndexLogic.getAppInstances(Tracker)
+        expect(result).toEqual(TRACKERS)
+        expect(result).toEqual(uniqueNodes(result)) // shoud have no dups
+        })
+        it('finds images in containers', async () => {
+        const result = await typeIndexLogic.getAppInstances(Image)
+        expect(result.length).toEqual(3)
+        expect(result).toEqual(uniqueNodes(result)) // shoud have no dups
+        expect(result.map(x => x.uri).join()).toEqual("https://alice.example.com/profile/Photos/photo1.png,https://alice.example.com/profile/Photos/photo2.png,https://alice.example.com/profile/Photos/photo3.png")
+        })
     })
-  })
 
-})
+    describe('registerInTypeIndex', () => {
+        it('exists', () => {
+            expect(typeIndexLogic.registerInTypeIndex).toBeInstanceOf(Function)
+        })
+        it('throws error', async () => {
+            const result = await typeIndexLogic.registerInTypeIndex(
+                sym('https://test.test#'),
+                sym('https://test.test#'),
+                sym('https://test.test/TheClass')
+            )
+            console.log(result)
+            expect(result).toEqual(null)
+        })
+    })
+})

package/lib/logic/SolidLogic.d.ts

@@ -1,22 +0,0 @@
-import { Session } from "@inrupt/solid-client-authn-browser";
-import { LiveStore, NamedNode, Statement } from "rdflib";
-import { AuthnLogic } from "../types";
-export declare class SolidLogic {
-    store: LiveStore;
-    me: string | undefined;
-    authn: AuthnLogic;
-    aclLogic: any;
-    utilityLogic: any;
-    containerLogic: any;
-    profileLogic: any;
-    inboxLogic: any;
-    typeIndexLogic: any;
-    chatLogic: any;
-    constructor(specialFetch: {
-        fetch: (url: any, requestInit: any) => any;
-    }, session: Session);
-    load(doc: NamedNode | NamedNode[] | string): Promise<Response> | Promise<Response[]>;
-    updatePromise(del: Array<Statement>, ins?: Array<Statement>): Promise<void>;
-    clearStore(): void;
-}
-//# sourceMappingURL=SolidLogic.d.ts.map

package/lib/logic/SolidLogic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SolidLogic.d.ts","sourceRoot":"","sources":["../../src/logic/SolidLogic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAE7D,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AASzD,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAQtC,qBAAa,UAAU;IAEnB,KAAK,EAAE,SAAS,CAAC;IACjB,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;IACvB,KAAK,EAAE,UAAU,CAAC;IAElB,QAAQ,MAAA;IACR,YAAY,MAAA;IACZ,cAAc,MAAA;IACd,YAAY,MAAA;IACZ,UAAU,MAAA;IACV,cAAc,MAAA;IACd,SAAS,MAAA;gBAGG,YAAY,EAAE;QAAE,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,KAAK,GAAG,CAAA;KAAE,EAAE,OAAO,EAAE,OAAO;IAuB1F,IAAI,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,EAAE,GAAG,MAAM;IAK1C,aAAa,CACT,GAAG,EAAE,KAAK,CAAC,SAAS,CAAC,EACrB,GAAG,GAAE,KAAK,CAAC,SAAS,CAAM,GAC3B,OAAO,CAAC,IAAI,CAAC;IAYhB,UAAU;CAGb"}

package/lib/logic/SolidLogic.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SolidLogic.js","sourceRoot":"","sources":["../../src/logic/SolidLogic.ts"],"names":[],"mappings":"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"}

package/lib/logic/solidLogicSingletonNew.d.ts

@@ -1,80 +0,0 @@
-import * as rdf from "rdflib";
-import { SolidAuthnLogic } from "../authn/SolidAuthnLogic";
-export declare function solidLogicSingleton(): {
-    store: rdf.LiveStore;
-    authn: SolidAuthnLogic;
-    authSession: import("@inrupt/solid-client-authn-browser").Session;
-    recursiveDelete: (url: string) => Promise<any>;
-    setSinglePeerAccess: (options: {
-        ownerWebId: string;
-        peerWebId: string;
-        accessToModes?: string | undefined;
-        defaultModes?: string | undefined;
-        target: string;
-    }) => Promise<any>;
-    createEmptyRdfDoc: (doc: rdf.NamedNode, comment: string) => Promise<void>;
-    followOrCreateLink: (subject: rdf.NamedNode, predicate: rdf.NamedNode, object: rdf.NamedNode, doc: rdf.NamedNode) => Promise<rdf.NamedNode | null>;
-    loadOrCreateIfNotExists: (doc: rdf.NamedNode) => Promise<any>;
-    isContainer: (url: string) => boolean;
-    createContainer: (url: string) => Promise<void>;
-    getContainerElements: (containerNode: rdf.NamedNode) => rdf.NamedNode[];
-    getContainerMembers: (containerUrl: string) => Promise<string[]>;
-    ensureTypeIndexes: (context: import("..").AuthenticationContext, agent?: rdf.NamedNode | undefined) => Promise<import("..").AuthenticationContext>;
-    loadTypeIndexes: (context: import("..").AuthenticationContext) => Promise<import("..").AuthenticationContext | undefined>;
-    registerInTypeIndex: (context: import("..").AuthenticationContext, instance: rdf.NamedNode, theClass: rdf.NamedNode, isPublic: boolean, agent?: rdf.NamedNode | undefined) => Promise<import("..").AuthenticationContext>;
-    loadIndex: (context: import("..").AuthenticationContext, isPublic: boolean) => Promise<import("..").AuthenticationContext>;
-    ensureOneTypeIndex: (context: import("..").AuthenticationContext, isPublic: boolean, agent?: rdf.NamedNode | undefined) => Promise<void | import("..").AuthenticationContext>;
-    putIndex: (newIndex: any, context: any) => Promise<any>;
-    makeIndexIfNecessary: (context: any, isPublic: any, store: any, ns: any) => Promise<any>;
-    loadIndexes: (me: string | rdf.NamedNode, publicProfile: string | rdf.NamedNode | null, preferencesFile: string | rdf.NamedNode | null, onWarning?: (_err: Error) => Promise<undefined>) => Promise<{
-        private: any;
-        public: any;
-    }>;
-    getTypeIndex: (me: string | rdf.NamedNode, preferencesFile: string | rdf.NamedNode, isPublic: boolean) => rdf.NamedNode[];
-    getRegistrations: (instance: any, theClass: any) => any;
-    loadTypeIndexesFor: (user: rdf.NamedNode) => Promise<import("../types").TypeIndexScope[]>;
-    loadCommunityTypeIndexes: (user: rdf.NamedNode) => Promise<import("../types").TypeIndexScope[][]>;
-    loadAllTypeIndexes: (user: rdf.NamedNode) => Promise<import("../types").TypeIndexScope[]>;
-    getScopedAppInstances: (klass: rdf.NamedNode, user: rdf.NamedNode) => Promise<import("../types").ScopedApp[]>;
-    getAppInstances: (klass: rdf.NamedNode) => Promise<rdf.NamedNode[]>;
-    suggestPublicTypeIndex: (me: rdf.NamedNode) => rdf.NamedNode;
-    suggestPrivateTypeIndex: (preferencesFile: rdf.NamedNode) => rdf.NamedNode;
-    registerInstanceInTypeIndex: (instance: rdf.NamedNode, index: rdf.NamedNode, theClass: rdf.NamedNode) => Promise<rdf.NamedNode | null>;
-    deleteTypeIndexRegistration: (item: any) => Promise<void>;
-    getScopedAppsFromIndex: (scope: any, theClass: rdf.NamedNode | null) => Promise<{
-        instance: rdf.NamedNode;
-        scope: any;
-    }[]>;
-    ensureLoadedPreferences: (context: import("..").AuthenticationContext) => Promise<import("..").AuthenticationContext>;
-    loadMe: () => Promise<rdf.NamedNode>;
-    getPodRoot: (user: rdf.NamedNode) => rdf.NamedNode;
-    getMainInbox: (user: rdf.NamedNode) => Promise<rdf.NamedNode>;
-    findStorage: (me: rdf.NamedNode) => any;
-    loadPreferences: (user: rdf.NamedNode) => Promise<rdf.NamedNode>;
-    loadProfile: (user: rdf.NamedNode) => Promise<rdf.NamedNode>;
-    silencedLoadPreferences: (user: rdf.NamedNode) => Promise<rdf.NamedNode | undefined>;
-    createInboxFor: (peerWebId: string, nick: string) => Promise<string>;
-    getNewMessages: (user?: rdf.NamedNode | undefined) => Promise<string[]>;
-    markAsRead: (url: string, date: Date) => Promise<void>;
-    setAcl: (chatContainer: rdf.NamedNode, me: rdf.NamedNode, invitee: rdf.NamedNode) => Promise<void>;
-    addToPrivateTypeIndex: (chatThing: any, me: any) => Promise<void>;
-    findChat: (invitee: rdf.NamedNode) => Promise<{
-        me: any;
-        chatContainer: rdf.NamedNode;
-        exists: boolean;
-    }>;
-    createChatThing: (chatContainer: rdf.NamedNode, me: rdf.NamedNode) => Promise<rdf.NamedNode>;
-    getChat: (invitee: rdf.NamedNode, createIfMissing?: boolean) => Promise<rdf.NamedNode | null>;
-    sendInvite: (invitee: rdf.NamedNode, chatThing: rdf.NamedNode) => Promise<void>;
-    mintNew: (newPaneOptions: import("../types").NewPaneOptions) => Promise<import("../types").CreatedPaneOptions>;
-    findAclDocUrl: (url: string) => Promise<any>;
-    setACLUserPublic: (docURI: string, me: rdf.NamedNode, options: {
-        defaultForNew?: boolean | undefined;
-        public?: [] | undefined;
-    }) => Promise<rdf.NamedNode>;
-    genACLText: (docURI: string, me: rdf.NamedNode, aclURI: string, options?: {
-        defaultForNew?: boolean | undefined;
-        public?: [] | undefined;
-    }) => string | undefined;
-};
-//# sourceMappingURL=solidLogicSingletonNew.d.ts.map

package/lib/logic/solidLogicSingletonNew.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"solidLogicSingletonNew.d.ts","sourceRoot":"","sources":["../../src/logic/solidLogicSingletonNew.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,QAAQ,CAAA;AAC7B,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAW1D,wBAAgB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkKlC"}