solid-logic 3.0.9-f51524a8 → 3.0.9-ff53d0a

package/src/index.ts

@@ -1,21 +0,0 @@
-// Make these variables directly accessible as it is what you need most of the time
-// This also makes these variable globaly accesible in mashlib
-import { solidLogicSingleton } from './logic/solidLogicSingleton'
-
-const authn = solidLogicSingleton.authn
-const authSession = solidLogicSingleton.authn.authSession
-const store = solidLogicSingleton.store
-
-export { ACL_LINK } from './acl/aclLogic'
-export { offlineTestID, appContext } from './authn/authUtil'
-export { getSuggestedIssuers } from './issuer/issuerLogic'
-export type { AppDetails, SolidNamespace, AuthenticationContext, SolidLogic } from './types'
-export { UnauthorizedError, CrossOriginForbiddenError, SameOriginForbiddenError, NotFoundError, FetchError, NotEditableError, WebOperationError } from './logic/CustomError'
-
-export {
-  solidLogicSingleton, // solidLogicSingleton is exported entirely because it is used in solid-panes
-  store,
-  authn,
-  authSession
-}
-

package/src/issuer/issuerLogic.ts

@@ -1,40 +0,0 @@
-const DEFAULT_ISSUERS = [
-  {
-    name: 'Solid Community',
-    uri: 'https://solidcommunity.net'
-  },
-  {
-    name: 'Solid Web',
-    uri: 'https://solidweb.org'
-  },
-  {
-    name: 'Inrupt.net',
-    uri: 'https://inrupt.net'
-  },
-  {
-    name: 'pod.Inrupt.com',
-    uri: 'https://login.inrupt.com'
-  }
-]
-
-/**
- * @returns - A list of suggested OIDC issuers
- */
-export function getSuggestedIssuers (): { name: string, uri: string }[] {
-    // Suggest a default list of OIDC issuers
-    const issuers = [...DEFAULT_ISSUERS]
-  
-    // Suggest the current host if not already included
-    const { host, origin } = new URL(location.href)
-    const hosts = issuers.map(({ uri }) => new URL(uri).host)
-    if (!hosts.includes(host) && !hosts.some(existing => isSubdomainOf(host, existing))) {
-      issuers.unshift({ name: host, uri: origin })
-    }
-  
-    return issuers
-  }
-  
-function isSubdomainOf (subdomain: string, domain: string): boolean {
-    const dot = subdomain.length - domain.length - 1
-    return dot > 0 && subdomain[dot] === '.' && subdomain.endsWith(domain)
-}

package/src/logic/CustomError.ts

@@ -1,29 +0,0 @@
-class CustomError extends Error {
-    constructor(message?: string) {
-        super(message)
-        // see: typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html
-        Object.setPrototypeOf(this, new.target.prototype) // restore prototype chain
-        this.name = new.target.name // stack traces display correctly now
-    }
-}
-
-export class UnauthorizedError extends CustomError {}
-
-export class CrossOriginForbiddenError extends CustomError {}
-
-export class SameOriginForbiddenError extends CustomError {}
-
-export class NotFoundError extends CustomError {}
-
-export class NotEditableError extends CustomError { }
-
-export class WebOperationError extends CustomError {}
-
-export class FetchError extends CustomError {
-    status: number
-
-    constructor(status: number, message?: string) {
-        super(message)
-        this.status = status
-    }
-}

package/src/logic/solidLogic.ts

@@ -1,76 +0,0 @@
-import { Session } from '@inrupt/solid-client-authn-browser'
-import * as rdf from 'rdflib'
-import { LiveStore, NamedNode, Statement } from 'rdflib'
-import { createAclLogic } from '../acl/aclLogic'
-import { SolidAuthnLogic } from '../authn/SolidAuthnLogic'
-import { createChatLogic } from '../chat/chatLogic'
-import { createInboxLogic } from '../inbox/inboxLogic'
-import { createProfileLogic } from '../profile/profileLogic'
-import { createTypeIndexLogic } from '../typeIndex/typeIndexLogic'
-import { createContainerLogic } from '../util/containerLogic'
-import { createUtilityLogic } from '../util/utilityLogic'
-import { AuthnLogic, SolidLogic } from '../types'
-import * as debug from '../util/debug'
-/*
-** It is important to distinquish `fetch`, a function provided by the browser
-** and `Fetcher`, a helper object for the rdflib Store which turns it
-** into a `ConnectedStore` or a `LiveStore`.  A Fetcher object is
-** available at store.fetcher, and `fetch` function at `store.fetcher._fetch`,
-*/
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function createSolidLogic(specialFetch: { fetch: (url: any, requestInit: any) => any }, session: Session): SolidLogic {
-
-    debug.log('SolidLogic: Unique instance created.  There should only be one of these.')
-    const store: LiveStore = rdf.graph() as LiveStore
-    rdf.fetcher(store, {fetch: specialFetch.fetch}) // Attach a web I/O module, store.fetcher
-    store.updater = new rdf.UpdateManager(store) // Add real-time live updates store.updater
-    store.features = [] // disable automatic node merging on store load
-
-    const authn: AuthnLogic = new SolidAuthnLogic(session)
-    
-    const acl = createAclLogic(store)
-    const containerLogic = createContainerLogic(store)
-    const utilityLogic = createUtilityLogic(store, acl, containerLogic)
-    const profile = createProfileLogic(store, authn, utilityLogic)
-    const chat = createChatLogic(store, profile)
-    const inbox = createInboxLogic(store, profile, utilityLogic, containerLogic, acl)
-    const typeIndex = createTypeIndexLogic(store, authn, profile, utilityLogic)
-    debug.log('SolidAuthnLogic initialized')
-
-    function load(doc: NamedNode | NamedNode[] | string) {
-        return store.fetcher.load(doc)
-    }
-
-    // @@@@ use the one in rdflib.js when it is available and delete this
-    function updatePromise(
-        del: Array<Statement>,
-        ins: Array<Statement> = []
-    ): Promise<void> {
-        return new Promise((resolve, reject) => {
-        store.updater.update(del, ins, function (_uri, ok, errorBody) {
-            if (!ok) {
-            reject(new Error(errorBody))
-            } else {
-            resolve()
-            }
-        }) // callback
-        }) // promise
-    }
-
-    function clearStore() {
-        store.statements.slice().forEach(store.remove.bind(store))
-    }
-
-    return {
-        store,
-        authn,
-        acl,
-        inbox,
-        chat,
-        profile,
-        typeIndex,
-        load,
-        updatePromise,
-        clearStore
-    }
-}

package/src/logic/solidLogicSingleton.ts

@@ -1,20 +0,0 @@
-import * as debug from '../util/debug'
-import { authSession } from '../authSession/authSession'
-import { createSolidLogic } from './solidLogic'
-
-const _fetch = async (url, requestInit) => {
-    const omitCreds = requestInit && requestInit.credentials && requestInit.credentials == 'omit'
-    if (authSession.info.webId && !omitCreds) { // see https://github.com/solidos/solidos/issues/114
-        // In fact fetch should respect credentials omit itself
-        return authSession.fetch(url, requestInit)
-    } else {
-        return window.fetch(url, requestInit)
-    }
-}
-
-//this const makes solidLogicSingleton global accessible in mashlib
-const solidLogicSingleton = createSolidLogic({ fetch: _fetch }, authSession)
-
-debug.log('Unique quadstore initialized.')
-
-export { solidLogicSingleton }

package/src/profile/profileLogic.ts

@@ -1,125 +0,0 @@
-import { NamedNode } from 'rdflib'
-import { CrossOriginForbiddenError, FetchError, NotEditableError, SameOriginForbiddenError, UnauthorizedError, WebOperationError } from '../logic/CustomError'
-import * as debug from '../util/debug'
-import { ns as namespace } from '../util/ns'
-import { differentOrigin, suggestPreferencesFile } from '../util/utils'
-import { ProfileLogic } from '../types'
-
-export function createProfileLogic(store, authn, utilityLogic): ProfileLogic {
-    const ns = namespace
-
-    /**
-     * loads the preference without throwing errors - if it can create it it does so.
-     * remark: it still throws error if it cannot load profile.
-     * @param user
-     * @returns undefined if preferenceFile cannot be returned or NamedNode if it can find it or create it
-     */
-    async function silencedLoadPreferences(user: NamedNode): Promise <NamedNode | undefined> {
-        try {
-            return await loadPreferences(user)
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        } catch (err) {
-            return undefined
-        }
-    }
-
-    /**
-     * loads the preference without returning different errors if it cannot create or load it.
-     * remark: it also throws error if it cannot load profile.
-     * @param user
-     * @returns undefined if preferenceFile cannot be an Error or NamedNode if it can find it or create it
-     */
-    async function loadPreferences (user: NamedNode): Promise <NamedNode> {
-        await loadProfile(user)
-
-        const possiblePreferencesFile = suggestPreferencesFile(user)
-        let preferencesFile
-        try {
-            preferencesFile = await utilityLogic.followOrCreateLink(user, ns.space('preferencesFile') as NamedNode, possiblePreferencesFile, user.doc())
-        } catch (err) {
-            const message = `User ${user} has no pointer in profile to preferences file.`
-            debug.warn(message)
-            // we are listing the possible errors
-            if (err instanceof NotEditableError) { throw err }
-            if (err instanceof WebOperationError) { throw err }
-            if (err instanceof UnauthorizedError) { throw err }
-            if (err instanceof CrossOriginForbiddenError) { throw err }
-            if (err instanceof SameOriginForbiddenError) { throw err }
-            if (err instanceof FetchError) { throw err }
-            throw err
-        }
-
-        try {
-            await store.fetcher.load(preferencesFile as NamedNode)
-        } catch (err) { // Maybe a permission problem or origin problem
-            const msg = `Unable to load preference of user ${user}: ${err}`
-            debug.warn(msg)
-            if (err.response.status === 401) {
-                throw new UnauthorizedError()
-            }
-            if (err.response.status === 403) {
-                if (differentOrigin(preferencesFile)) {
-                throw new CrossOriginForbiddenError()
-                }
-                throw new SameOriginForbiddenError()
-            }
-            /*if (err.response.status === 404) {
-                throw new NotFoundError();
-            }*/
-            throw new Error(msg)
-        }
-        return preferencesFile as NamedNode
-    }
-
-    async function loadProfile (user: NamedNode):Promise <NamedNode> {
-        if (!user) {
-            throw new Error('loadProfile: no user given.')
-        }
-        try {
-            await store.fetcher.load(user.doc())
-        } catch (err) {
-            throw new Error(`Unable to load profile of user ${user}: ${err}`)
-        }
-        return user.doc()
-    }
-
-    async function loadMe(): Promise<NamedNode> {
-        const me = authn.currentUser()
-        if (me === null) {
-            throw new Error('Current user not found! Not logged in?')
-        }
-        await store.fetcher.load(me.doc())
-        return me
-    }
-
-    function getPodRoot(user: NamedNode): NamedNode {
-        const podRoot = findStorage(user)
-        if (!podRoot) {
-            throw new Error('User pod root not found!')
-        }
-        return podRoot as NamedNode
-    }
-
-    async function getMainInbox(user: NamedNode): Promise<NamedNode> {
-        await store.fetcher.load(user)
-        const mainInbox = store.any(user, ns.ldp('inbox'), undefined, user.doc())
-        if (!mainInbox) {
-            throw new Error('User main inbox not found!')
-        }
-        return mainInbox as NamedNode
-    }
-
-    function findStorage(me: NamedNode) {
-        return store.any(me, ns.space('storage'), undefined, me.doc())
-    }
-
-    return {
-        loadMe,
-        getPodRoot,
-        getMainInbox,
-        findStorage,
-        loadPreferences,
-        loadProfile,
-        silencedLoadPreferences
-    }
-}

package/src/typeIndex/typeIndexLogic.ts

@@ -1,198 +0,0 @@
-import { NamedNode, st, sym } from 'rdflib'
-import { ScopedApp, TypeIndexLogic, TypeIndexScope } from '../types'
-import * as debug from '../util/debug'
-import { ns as namespace } from '../util/ns'
-import { newThing } from '../util/utils'
-
-export function createTypeIndexLogic(store, authn, profileLogic, utilityLogic): TypeIndexLogic {
-    const ns = namespace
-
-    function getRegistrations(instance, theClass) {
-        return store
-            .each(undefined, ns.solid('instance'), instance)
-            .filter((r) => {
-                return store.holds(r, ns.solid('forClass'), theClass)
-            })
-    }
-
-    async function loadTypeIndexesFor(user: NamedNode): Promise<Array<TypeIndexScope>> {
-        if (!user) throw new Error('loadTypeIndexesFor: No user given')
-        const profile = await profileLogic.loadProfile(user)
-
-        const suggestion = suggestPublicTypeIndex(user)
-        let publicTypeIndex
-        try {
-            publicTypeIndex = await utilityLogic.followOrCreateLink(user, ns.solid('publicTypeIndex') as NamedNode, suggestion, profile)
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        } catch (err) {
-            const message = `User ${user} has no pointer in profile to publicTypeIndex file.`
-            debug.warn(message)
-        }
-        const publicScopes = publicTypeIndex ? [{ label: 'public', index: publicTypeIndex as NamedNode, agent: user }] : []
-
-        let preferencesFile
-        try {
-            preferencesFile = await profileLogic.silencedLoadPreferences(user)
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        } catch (err) {
-            preferencesFile = null
-        }
-
-        let privateScopes
-        if (preferencesFile) { // watch out - can be in either as spec was not clear.  Legacy is profile.
-            // If there is a legacy one linked from the profile, use that.
-            // Otherwiae use or make one linked from Preferences
-            const suggestedPrivateTypeIndex = suggestPrivateTypeIndex(preferencesFile)
-            let privateTypeIndex
-            try {
-                privateTypeIndex = store.any(user, ns.solid('privateTypeIndex'), undefined, profile) ||
-                    await utilityLogic.followOrCreateLink(user, ns.solid('privateTypeIndex') as NamedNode, suggestedPrivateTypeIndex, preferencesFile)
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                } catch (err) {
-                const message = `User ${user} has no pointer in preference file to privateTypeIndex file.`
-                debug.warn(message)
-            }
-            privateScopes = privateTypeIndex ? [{ label: 'private', index: privateTypeIndex as NamedNode, agent: user }] : []
-        } else {
-            privateScopes = []
-        }
-        const scopes = publicScopes.concat(privateScopes)
-        if (scopes.length === 0) return scopes
-        const files = scopes.map(scope => scope.index)
-        try {
-            await store.fetcher.load(files)
-        } catch (err) {
-            debug.warn('Problems loading type index: ', err)
-        }
-        return scopes
-    }
-
-    async function loadCommunityTypeIndexes(user: NamedNode): Promise<TypeIndexScope[][]> {
-        let preferencesFile
-        try {
-            preferencesFile = await profileLogic.silencedLoadPreferences(user)
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        } catch (err) {
-            const message = `User ${user} has no pointer in profile to preferences file.`
-            debug.warn(message)
-        }
-        if (preferencesFile) { // For now, pick up communities as simple links from the preferences file.
-            const communities = store.each(user, ns.solid('community'), undefined, preferencesFile as NamedNode).concat(
-                store.each(user, ns.solid('community'), undefined, user.doc() as NamedNode)
-            )
-            let result = []
-            for (const org of communities) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                result = result.concat(await loadTypeIndexesFor(org as NamedNode) as any)
-            }
-            return result
-        }
-        return [] // No communities
-    }
-
-    async function loadAllTypeIndexes(user: NamedNode) {
-        return (await loadTypeIndexesFor(user)).concat((await loadCommunityTypeIndexes(user)).flat())
-    }
-
-    async function getScopedAppInstances(klass: NamedNode, user: NamedNode): Promise<ScopedApp[]> {
-        const scopes = await loadAllTypeIndexes(user)
-        let scopedApps = []
-        for (const scope of scopes) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const scopedApps0 = await getScopedAppsFromIndex(scope, klass) as any
-            scopedApps = scopedApps.concat(scopedApps0)
-        }
-        return scopedApps
-    }
-
-    // This is the function signature which used to be in solid-ui/logic
-    // Recommended to use getScopedAppInstances instead as it provides more information.
-    //
-    async function getAppInstances(klass: NamedNode): Promise<NamedNode[]> {
-        const user = authn.currentUser()
-        if (!user) throw new Error('getAppInstances: Must be logged in to find apps.')
-        const scopedAppInstances = await getScopedAppInstances(klass, user)
-        return scopedAppInstances.map(scoped => scoped.instance)
-    }
-
-    function suggestPublicTypeIndex(me: NamedNode) {
-        return sym(me.doc().dir()?.uri + 'publicTypeIndex.ttl')
-    }
-    // Note this one is based off the pref file not the profile
-
-    function suggestPrivateTypeIndex(preferencesFile: NamedNode) {
-        return sym(preferencesFile.doc().dir()?.uri + 'privateTypeIndex.ttl')
-    }
-
-    /*
-    * Register a new app in a type index
-    * used in chat in bookmark.js (solid-ui)
-    * Returns the registration object if successful else null
-    */
-    async function registerInTypeIndex(
-        instance: NamedNode,
-        index: NamedNode,
-        theClass: NamedNode,
-        // agent: NamedNode
-    ): Promise<NamedNode | null> {
-        const registration = newThing(index)
-        const ins = [
-            // See https://github.com/solid/solid/blob/main/proposals/data-discovery.md
-            st(registration, ns.rdf('type'), ns.solid('TypeRegistration'), index),
-            st(registration, ns.solid('forClass'), theClass, index),
-            st(registration, ns.solid('instance'), instance, index)
-        ]
-        try {
-            await store.updater.update([], ins)
-        } catch (err) {
-            const msg = `Unable to register ${instance} in index ${index}: ${err}`
-            console.warn(msg)
-            return null
-        }
-        return registration
-    }
-
-    async function deleteTypeIndexRegistration(item) {
-        const reg = store.the(null, ns.solid('instance'), item.instance, item.scope.index) as NamedNode
-        if (!reg) throw new Error(`deleteTypeIndexRegistration: No registration found for ${item.instance}`)
-        const statements = store.statementsMatching(reg, null, null, item.scope.index)
-        await store.updater.update(statements, [])
-    }
-
-    async function getScopedAppsFromIndex(scope: TypeIndexScope, theClass: NamedNode | null): Promise<ScopedApp[]> {
-        const index = scope.index
-        const results: ScopedApp[] = []
-        const registrations = store.statementsMatching(null, ns.solid('instance'), null, index)
-            .concat(store.statementsMatching(null, ns.solid('instanceContainer'), null, index))
-            .map(st => st.subject)
-        for (const reg of registrations) {
-          const klass = store.any(reg, ns.solid('forClass'), null, index)
-          if (!theClass || klass.sameTerm(theClass)) {
-            const instances = store.each(reg, ns.solid('instance'), null, index)
-            for (const instance of instances) {
-              results.push({ instance, type: klass, scope })
-            }
-            const containers = store.each(reg, ns.solid('instanceContainer'), null, index)
-            for (const instance of containers) {
-                await store.fetcher.load(instance)
-                results.push({ instance: sym(instance.value), type: klass,  scope })
-            }
-          }
-        }
-        return results
-    }
-
-    return {
-        registerInTypeIndex,
-        getRegistrations,
-        loadTypeIndexesFor,
-        loadCommunityTypeIndexes,
-        loadAllTypeIndexes,
-        getScopedAppInstances,
-        getAppInstances,
-        suggestPublicTypeIndex,
-        suggestPrivateTypeIndex,
-        deleteTypeIndexRegistration,
-        getScopedAppsFromIndex
-    }
-}

package/src/types.ts

@@ -1,122 +0,0 @@
-import { Session } from '@inrupt/solid-client-authn-browser'
-import { LiveStore, NamedNode, Statement } from 'rdflib'
-
-export type AppDetails = {
-    noun: string
-    appPathSegment: string
-}
-
-export type AuthenticationContext = {
-    containers?: Array<NamedNode>
-    div?: HTMLElement
-    dom?: HTMLDocument
-    index?: { [key: string]: Array<NamedNode> }
-    instances?: Array<NamedNode>
-    me?: NamedNode | null
-    noun?: string
-    preferencesFile?: NamedNode
-    preferencesFileError?: string
-    publicProfile?: NamedNode
-    statusArea?: HTMLElement
-}
-
-export interface AuthnLogic {
-    authSession: Session //this needs to be deprecated in the future. Is only here to allow imports like panes.UI.authn.authSession prior to moving authn from ui to logic
-    currentUser: () => NamedNode | null
-    checkUser: <T>(setUserCallback?: (me: NamedNode | null) => T) => Promise<NamedNode | T | null>
-    saveUser: (webId: NamedNode | string | null,
-        context?: AuthenticationContext) => NamedNode | null
-}
-
-export interface SolidNamespace {
-    [key: string]: (term: string) => NamedNode
-}
-
-export type TypeIndexScope = { label: string, index: NamedNode, agent: NamedNode }
-export type ScopedApp = { instance: NamedNode, type: NamedNode, scope: TypeIndexScope }
-
-export interface NewPaneOptions {
-    me?: NamedNode;
-    newInstance?: NamedNode;
-    newBase: string;
-}
-
-export interface CreatedPaneOptions {
-newInstance: NamedNode;
-}
-
-export interface ChatLogic {
-    setAcl: (chatContainer: NamedNode, me: NamedNode, invitee: NamedNode) => Promise<void>,
-    addToPrivateTypeIndex: (chatThing, me) => void | Promise<void>,
-    findChat: (invitee: NamedNode) => Promise<Chat>,
-    createChatThing: (chatContainer: NamedNode, me: NamedNode) => Promise<NamedNode>,
-    mintNew: (newPaneOptions: NewPaneOptions) => Promise<CreatedPaneOptions>,
-    getChat: (invitee: NamedNode, boolean) => Promise<NamedNode | null>,
-    sendInvite: (invitee: NamedNode, chatThing: NamedNode) => void
-}
-
-export interface Chat {
-    me: NamedNode,
-    chatContainer: NamedNode,
-    exists: boolean
-}
-
-export interface ProfileLogic {
-    silencedLoadPreferences: (user: NamedNode) => Promise<NamedNode | undefined>,
-    loadPreferences: (user: NamedNode) => Promise<NamedNode>,
-    loadProfile: (user: NamedNode) => Promise<NamedNode>,
-    loadMe: () => Promise<NamedNode>,
-    getPodRoot: (user: NamedNode) => NamedNode,
-    getMainInbox: (user: NamedNode) => Promise<NamedNode>,
-    findStorage: (me: NamedNode) => Node | null
-}
-
-export interface AclLogic {
-    findAclDocUrl: (url: NamedNode) => Promise<string | undefined>,
-    setACLUserPublic: (docURI: string, me: NamedNode,
-        options: {
-            defaultForNew?: boolean,
-            public?: []
-        }
-    ) => Promise<NamedNode>,
-    genACLText: (docURI: string, me: NamedNode, aclURI: string,
-        options: {
-            defaultForNew?: boolean,
-            public?: []
-        }
-    ) => string | undefined
-}
-
-export interface InboxLogic {
-    createInboxFor: (peerWebId: string, nick: string) => Promise<string>,
-    getNewMessages: (user?: NamedNode) => Promise<NamedNode[]>,
-    markAsRead: (url: string, date: Date) => void
-}
-
-export interface TypeIndexLogic {
-    getRegistrations: (instance, theClass) => Node[],
-    loadTypeIndexesFor: (user: NamedNode) => Promise<Array<TypeIndexScope>>,
-    loadCommunityTypeIndexes: (user: NamedNode) => Promise<TypeIndexScope[][]>,
-    loadAllTypeIndexes: (user: NamedNode) => Promise<Array<TypeIndexScope>>,
-    getScopedAppInstances: (klass: NamedNode, user: NamedNode) => Promise<ScopedApp[]>,
-    getAppInstances: (klass: NamedNode) => Promise<NamedNode[]>,
-    suggestPublicTypeIndex: (me: NamedNode) => NamedNode,
-    suggestPrivateTypeIndex: (preferencesFile: NamedNode) => NamedNode,
-    registerInTypeIndex: (instance: NamedNode, index: NamedNode, theClass: NamedNode) => Promise<NamedNode | null>,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    deleteTypeIndexRegistration: (item: any) => Promise<void>
-    getScopedAppsFromIndex: (scope: TypeIndexScope, theClass: NamedNode | null) => Promise<ScopedApp[]>
-}
-
-export interface SolidLogic {
-    store: LiveStore,
-    authn: AuthnLogic,
-    acl: AclLogic,
-    profile: ProfileLogic,
-    inbox: InboxLogic,
-    typeIndex: TypeIndexLogic,
-    chat: ChatLogic,
-    load: (doc: NamedNode | NamedNode[] | string) => void,
-    updatePromise: (del: Array<Statement>, ins: Array<Statement>) => Promise<void>,
-    clearStore: () => void
-}

package/src/util/debug.ts

@@ -1,16 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export function log(...args: any[]): void {
-  console.log(...args)
-}
-
-export function warn(...args: any[]): void {
-  console.warn(...args)
-}
-
-export function error(...args: any[]): void {
-  console.error(...args)
-}
-
-export function trace(...args: any[]): void {
-  console.trace(...args)
-}

package/src/util/ns.ts

@@ -1,5 +0,0 @@
-// Namespaces we commonly use and have common prefixes for around Solid
-import solidNamespace from 'solid-namespace' // Delegate to this which takes RDFlib as param.
-import * as $rdf from 'rdflib'
-
-export const ns = solidNamespace($rdf)