solid-logic 1.3.17-9d25ceb7 → 1.3.17-a849582e

package/lib/typeIndex/typeIndexLogic.js

@@ -58,311 +58,666 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerInTypeIndex = exports.ensureTypeIndexes = exports.loadTypeIndexes = exports.loadIndex = exports.ns = void 0;
+exports.createTypeIndexLogic = void 0;
+var rdf = __importStar(require("rdflib"));
 var rdflib_1 = require("rdflib");
 var debug = __importStar(require("../util/debug"));
-var solid_namespace_1 = __importDefault(require("solid-namespace"));
-var $rdf = __importStar(require("rdflib"));
-var uri_1 = require("../util/uri");
-var solidLogicSingleton_1 = require("../logic/solidLogicSingleton");
-// import { ensureLoadedPreferences } from '../logic/logic'
-var discoveryLogic_1 = require("../discovery/discoveryLogic");
-exports.ns = (0, solid_namespace_1.default)($rdf);
-var store = solidLogicSingleton_1.solidLogicSingleton.store;
-function ensureLoadedPreferences(context) {
-    return __awaiter(this, void 0, void 0, function () {
-        var _a, _b;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    if (!context.me)
-                        throw new Error('@@ ensureLoadedPreferences: no user specified');
-                    _a = context;
-                    return [4 /*yield*/, (0, discoveryLogic_1.loadProfile)(store, context.me)];
-                case 1:
-                    _a.publicProfile = _c.sent();
-                    _b = context;
-                    return [4 /*yield*/, (0, discoveryLogic_1.loadPreferences)(store, context.me)];
-                case 2:
-                    _b.preferencesFile = _c.sent();
-                    return [2 /*return*/, context];
-            }
+var ns_1 = require("../util/ns");
+var utils_1 = require("../util/utils");
+function createTypeIndexLogic(store, authn, profileLogic, utilityLogic) {
+    var ns = ns_1.ns;
+    function updatePromise(del, ins) {
+        if (ins === void 0) { ins = []; }
+        return new Promise(function (resolve, reject) {
+            store.updater.update(del, ins, function (_uri, ok, errorBody) {
+                if (!ok) {
+                    reject(new Error(errorBody));
+                }
+                else {
+                    resolve();
+                }
+            }); // callback
+        }); // promise
+    }
+    /**
+     * Resolves with the same context, outputting
+     * @see https://github.com/solidos/solid/blob/main/proposals/data-discovery.md#discoverability
+     */
+    function ensureTypeIndexes(context, agent) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!context.me) {
+                            throw new Error("ensureTypeIndexes: @@ no user");
+                        }
+                        return [4 /*yield*/, ensureOneTypeIndex(context, true, agent)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, ensureOneTypeIndex(context, false, agent)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, context];
+                }
+            });
         });
-    });
-}
-/**
- * Resolves with the same context, outputting
- * output: index.public, index.private
- *  @@ This is a very bizare function
- * @see https://github.com/solidos/solid/blob/main/proposals/data-discovery.md#discoverability
- */
-function loadIndex(context, isPublic) {
-    return __awaiter(this, void 0, void 0, function () {
-        var indexes;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, solidLogicSingleton_1.solidLogicSingleton.loadIndexes(context.me, (isPublic ? context.publicProfile || null : null), (isPublic ? null : context.preferencesFile || null), 
-                    // async (err: Error) => widgets.complain(context, err.message)
-                    function (err) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
-                        return [2 /*return*/, debug.error(err.message)];
-                    }); }); })];
-                case 1:
-                    indexes = _a.sent();
-                    context.index = context.index || {};
-                    context.index.private = indexes.private.concat(context.index.private || []); // otherwise concat will wrongly add 'undefined' as a private index
-                    context.index.public = indexes.public.concat(context.index.public || []); // otherwise concat will wrongly add 'undefined' as a public index
-                    return [2 /*return*/, context];
-            }
+    }
+    function loadTypeIndexes(context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_1, indexes, error_2;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, profileLogic.silencedLoadPreferences(context.me)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_1 = _a.sent();
+                        debug.warn(error_1.message);
+                        return [3 /*break*/, 3];
+                    case 3:
+                        _a.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, loadIndexes(context.me, context.publicProfile || null, context.preferencesFile || null)];
+                    case 4:
+                        indexes = _a.sent();
+                        context.index = context.index || {};
+                        context.index.private = indexes.private || context.index.private;
+                        context.index.public = indexes.public || context.index.public;
+                        return [2 /*return*/, context];
+                    case 5:
+                        error_2 = _a.sent();
+                        (function (error) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, debug.warn(error.message)];
+                        }); }); });
+                        return [3 /*break*/, 6];
+                    case 6: return [2 /*return*/];
+                }
+            });
         });
-    });
-}
-exports.loadIndex = loadIndex;
-function loadTypeIndexes(context) {
-    return __awaiter(this, void 0, void 0, function () {
-        var error_1, indexes, error_2;
+    }
+    /**
+     * Register a new app in a type index
+     * used in chat in bookmark.js (solid-ui)
+     */
+    function registerInTypeIndex(context, instance, theClass, isPublic, agent // Defaults to current user
+    ) {
+        return __awaiter(this, void 0, void 0, function () {
+            var indexes, index, registration, ins, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureOneTypeIndex(context, isPublic, agent)];
+                    case 1:
+                        _a.sent();
+                        if (!context.index) {
+                            throw new Error('registerInTypeIndex: No type index found');
+                        }
+                        indexes = isPublic ? context.index.public : context.index.private;
+                        if (!indexes.length) {
+                            throw new Error('registerInTypeIndex: What no type index?');
+                        }
+                        index = indexes[0];
+                        registration = (0, utils_1.newThing)(index);
+                        ins = [
+                            // See https://github.com/solidos/solid/blob/main/proposals/data-discovery.md
+                            (0, rdflib_1.st)(registration, ns.rdf('type'), ns.solid('TypeRegistration'), index),
+                            (0, rdflib_1.st)(registration, ns.solid('forClass'), theClass, index),
+                            (0, rdflib_1.st)(registration, ns.solid('instance'), instance, index)
+                        ];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, updatePromise([], ins)];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        e_1 = _a.sent();
+                        debug.log(e_1);
+                        alert(e_1);
+                        return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/, context];
+                }
+            });
+        });
+    }
+    /**
+     * Resolves with the same context, outputting
+     * output: index.public, index.private
+     *  @@ This is a very bizare function
+     * @see https://github.com/solidos/solid/blob/main/proposals/data-discovery.md#discoverability
+     */
+    function loadIndex(context, isPublic) {
+        return __awaiter(this, void 0, void 0, function () {
+            var indexes;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, loadIndexes(context.me, (isPublic ? context.publicProfile || null : null), (isPublic ? null : context.preferencesFile || null), 
+                        // async (err: Error) => widgets.complain(context, err.message)
+                        function (err) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, debug.error(err.message)];
+                        }); }); })];
+                    case 1:
+                        indexes = _a.sent();
+                        context.index = context.index || {};
+                        context.index.private = indexes.private.concat(context.index.private || []); // otherwise concat will wrongly add 'undefined' as a private index
+                        context.index.public = indexes.public.concat(context.index.public || []); // otherwise concat will wrongly add 'undefined' as a public index
+                        return [2 /*return*/, context];
+                }
+            });
+        });
+    }
+    /**
+     * Load or create ONE type index
+     * Find one or make one or fail
+     * Many reasons for failing including script not having permission etc
+     *
+     * Adds its output to the context
+     * @see https://github.com/solidos/solid/blob/main/proposals/data-discovery.md#discoverability
+     */
+    function ensureOneTypeIndex(context, isPublic, agent) {
+        return __awaiter(this, void 0, void 0, function () {
+            var context2, relevant, pp, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, profileLogic.ensureLoadedPreferences(context)];
+                    case 1:
+                        context2 = _a.sent();
+                        if (!context2.publicProfile)
+                            throw new Error("@@ type index: no publicProfile");
+                        if (!context2.preferencesFile)
+                            throw new Error("@@ type index: no preferencesFile for profile  ".concat(context2.publicProfile));
+                        relevant = isPublic ? context2.publicProfile : context2.preferencesFile;
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 5, , 7]);
+                        return [4 /*yield*/, loadIndex(context2, isPublic)];
+                    case 3:
+                        _a.sent();
+                        pp = isPublic ? 'public' : 'private';
+                        if (context2.index && context2.index[pp] && context2.index[pp].length > 0) {
+                            debug.log("ensureOneTypeIndex: Type index exists already ".concat(context2.index[pp]));
+                            return [2 /*return*/, context2];
+                        }
+                        return [4 /*yield*/, makeIndexIfNecessary(context2, isPublic, store, ns)];
+                    case 4:
+                        _a.sent();
+                        return [3 /*break*/, 7];
+                    case 5:
+                        error_3 = _a.sent();
+                        return [4 /*yield*/, makeIndexIfNecessary(context2, isPublic, store, ns)
+                            // widgets.complain(context2, 'calling loadIndex:' + error)
+                        ];
+                    case 6:
+                        _a.sent();
+                        return [3 /*break*/, 7];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    }
+    function putIndex(newIndex, context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var e_2, msg;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, utilityLogic.createEmptyRdfDoc(newIndex, 'Blank initial Type index')];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, context];
+                    case 2:
+                        e_2 = _a.sent();
+                        msg = "Error creating new index ".concat(e_2);
+                        // widgets.complain(context, msg)
+                        debug.warn(msg);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    } // putIndex
+    function makeIndexIfNecessary(context, isPublic, store, ns) {
+        return __awaiter(this, void 0, void 0, function () {
+            var relevant, visibility, newIndex, addMe, err_1, msg, ixs, err_2, msg;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        relevant = isPublic ? context.publicProfile : context.preferencesFile;
+                        if (!relevant)
+                            alert('@@@@ relevent null');
+                        visibility = isPublic ? 'public' : 'private';
+                        context.index = context.index || {};
+                        context.index[visibility] = context.index[visibility] || [];
+                        if (!(context.index[visibility].length === 0)) return [3 /*break*/, 6];
+                        if (!store.updater.editable(relevant)) {
+                            debug.log("Not adding new type index as ".concat(relevant, " is not editable"));
+                            return [2 /*return*/];
+                        }
+                        newIndex = rdf.sym("".concat(relevant.dir().uri + visibility, "TypeIndex.ttl"));
+                        debug.log("Linking to new fresh type index ".concat(newIndex));
+                        if (!confirm("OK to create a new empty index file at ".concat(newIndex, ", overwriting anything that is now there?"))) {
+                            throw new Error('cancelled by user');
+                        }
+                        debug.log("Linking to new fresh type index ".concat(newIndex));
+                        addMe = [
+                            (0, rdflib_1.st)(context.me, ns.solid("".concat(visibility, "TypeIndex")), newIndex, relevant)
+                        ];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, updatePromise([], addMe)];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_1 = _a.sent();
+                        msg = "Error saving type index link saving back ".concat(newIndex, ": ").concat(err_1);
+                        //widgets.complain(context, msg)
+                        debug.warn(msg);
+                        return [2 /*return*/, context];
+                    case 4:
+                        debug.log("Creating new fresh type index file".concat(newIndex));
+                        return [4 /*yield*/, putIndex(newIndex, context)];
+                    case 5:
+                        _a.sent();
+                        context.index[visibility].push(newIndex); // @@ wait
+                        return [3 /*break*/, 10];
+                    case 6:
+                        ixs = context.index[visibility];
+                        _a.label = 7;
+                    case 7:
+                        _a.trys.push([7, 9, , 10]);
+                        return [4 /*yield*/, store.fetcher.load(ixs)];
+                    case 8:
+                        _a.sent();
+                        return [3 /*break*/, 10];
+                    case 9:
+                        err_2 = _a.sent();
+                        msg = "ensureOneTypeIndex: loading indexes ".concat(err_2);
+                        debug.warn(msg);
+                        return [3 /*break*/, 10];
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    } // makeIndexIfNecessary
+    function loadIndexes(me, publicProfile, preferencesFile, onWarning) {
         var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, (0, discoveryLogic_1.loadPreferences)(solidLogicSingleton_1.solidLogicSingleton.store, context.me)];
-                case 1:
-                    _a.sent();
-                    return [3 /*break*/, 3];
-                case 2:
-                    error_1 = _a.sent();
-                    debug.warn(error_1.message);
-                    return [3 /*break*/, 3];
-                case 3:
-                    _a.trys.push([3, 5, , 6]);
-                    return [4 /*yield*/, solidLogicSingleton_1.solidLogicSingleton.loadIndexes(context.me, context.publicProfile || null, context.preferencesFile || null)];
-                case 4:
-                    indexes = _a.sent();
-                    context.index = context.index || {};
-                    context.index.private = indexes.private || context.index.private;
-                    context.index.public = indexes.public || context.index.public;
-                    return [2 /*return*/, context];
-                case 5:
-                    error_2 = _a.sent();
-                    (function (error) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
-                        return [2 /*return*/, debug.warn(error.message)];
-                    }); }); });
-                    return [3 /*break*/, 6];
-                case 6: return [2 /*return*/];
-            }
+        if (onWarning === void 0) { onWarning = function (_err) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, undefined];
+            });
+        }); }; }
+        return __awaiter(this, void 0, void 0, function () {
+            var privateIndexes, publicIndexes, err_3, err_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        privateIndexes = [];
+                        publicIndexes = [];
+                        if (!publicProfile) return [3 /*break*/, 4];
+                        publicIndexes = getTypeIndex(me, publicProfile, true);
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, store.fetcher.load(publicIndexes)];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_3 = _a.sent();
+                        onWarning(new Error("loadIndex: loading public type index(es) ".concat(err_3)));
+                        return [3 /*break*/, 4];
+                    case 4:
+                        if (!preferencesFile) return [3 /*break*/, 9];
+                        privateIndexes = getTypeIndex(me, preferencesFile, false);
+                        if (!(privateIndexes.length === 0)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, onWarning(new Error("Your preference file ".concat(preferencesFile, " does not point to a private type index.")))];
+                    case 5:
+                        _a.sent();
+                        return [3 /*break*/, 9];
+                    case 6:
+                        _a.trys.push([6, 8, , 9]);
+                        return [4 /*yield*/, store.fetcher.load(privateIndexes)];
+                    case 7:
+                        _a.sent();
+                        return [3 /*break*/, 9];
+                    case 8:
+                        err_4 = _a.sent();
+                        onWarning(new Error("loadIndex: loading private type index(es) ".concat(err_4)));
+                        return [3 /*break*/, 9];
+                    case 9: return [2 /*return*/, {
+                            private: privateIndexes,
+                            public: publicIndexes,
+                        }];
+                }
+            });
         });
-    });
-}
-exports.loadTypeIndexes = loadTypeIndexes;
-/**
- * Resolves with the same context, outputting
- * @see https://github.com/solidos/solid/blob/main/proposals/data-discovery.md#discoverability
- */
-function ensureTypeIndexes(context, agent) {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!context.me) {
-                        throw new Error("ensureTypeIndexes: @@ no user");
-                    }
-                    return [4 /*yield*/, ensureOneTypeIndex(context, true, agent)];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, ensureOneTypeIndex(context, false, agent)];
-                case 2:
-                    _a.sent();
-                    return [2 /*return*/, context];
-            }
+    }
+    function getTypeIndex(me, preferencesFile, isPublic) {
+        // console.log('getTypeIndex', store.each(me, undefined, undefined, preferencesFile), isPublic, preferencesFile)
+        return store.each(me, isPublic ? ns.solid("publicTypeIndex") : ns.solid("privateTypeIndex"), undefined, preferencesFile);
+    }
+    function getRegistrations(instance, theClass) {
+        return store
+            .each(undefined, ns.solid("instance"), instance)
+            .filter(function (r) {
+            return store.holds(r, ns.solid("forClass"), theClass);
         });
-    });
-}
-exports.ensureTypeIndexes = ensureTypeIndexes;
-/**
- * Load or create ONE type index
- * Find one or make one or fail
- * Many reasons for failing including script not having permission etc
- *
- * Adds its output to the context
- * @see https://github.com/solidos/solid/blob/main/proposals/data-discovery.md#discoverability
- */
-function ensureOneTypeIndex(context, isPublic, agent) {
-    return __awaiter(this, void 0, void 0, function () {
-        function makeIndexIfNecessary(context, isPublic) {
-            return __awaiter(this, void 0, void 0, function () {
-                function putIndex(newIndex) {
-                    return __awaiter(this, void 0, void 0, function () {
-                        var e_1, msg;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    _a.trys.push([0, 2, , 3]);
-                                    return [4 /*yield*/, solidLogicSingleton_1.solidLogicSingleton.createEmptyRdfDoc(newIndex, 'Blank initial Type index')];
-                                case 1:
-                                    _a.sent();
-                                    return [2 /*return*/, context];
-                                case 2:
-                                    e_1 = _a.sent();
-                                    msg = "Error creating new index ".concat(e_1);
-                                    // widgets.complain(context, msg)
-                                    debug.warn(msg);
-                                    return [3 /*break*/, 3];
-                                case 3: return [2 /*return*/];
-                            }
-                        });
-                    });
-                } // putIndex
-                var relevant, visibility, newIndex, addMe, err_1, msg, ixs, err_2, msg;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            relevant = isPublic ? context.publicProfile : context.preferencesFile;
-                            if (!relevant)
-                                alert('@@@@ relevent null');
-                            visibility = isPublic ? 'public' : 'private';
-                            context.index = context.index || {};
-                            context.index[visibility] = context.index[visibility] || [];
-                            if (!(context.index[visibility].length === 0)) return [3 /*break*/, 6];
-                            if (!store.updater.editable(relevant)) {
-                                debug.log("Not adding new type index as ".concat(relevant, " is not editable"));
-                                return [2 /*return*/];
-                            }
-                            newIndex = (0, rdflib_1.sym)("".concat(relevant.dir().uri + visibility, "TypeIndex.ttl"));
-                            debug.log("Linking to new fresh type index ".concat(newIndex));
-                            if (!confirm("OK to create a new empty index file at ".concat(newIndex, ", overwriting anything that is now there?"))) {
-                                throw new Error('cancelled by user');
-                            }
-                            debug.log("Linking to new fresh type index ".concat(newIndex));
-                            addMe = [
-                                (0, rdflib_1.st)(context.me, exports.ns.solid("".concat(visibility, "TypeIndex")), newIndex, relevant)
-                            ];
-                            _a.label = 1;
-                        case 1:
-                            _a.trys.push([1, 3, , 4]);
-                            return [4 /*yield*/, solidLogicSingleton_1.solidLogicSingleton.updatePromise([], addMe)];
-                        case 2:
-                            _a.sent();
-                            return [3 /*break*/, 4];
-                        case 3:
-                            err_1 = _a.sent();
-                            msg = "Error saving type index link saving back ".concat(newIndex, ": ").concat(err_1);
-                            //widgets.complain(context, msg)
-                            debug.warn(msg);
-                            return [2 /*return*/, context];
-                        case 4:
-                            debug.log("Creating new fresh type index file".concat(newIndex));
-                            return [4 /*yield*/, putIndex(newIndex)];
-                        case 5:
-                            _a.sent();
-                            context.index[visibility].push(newIndex); // @@ wait
-                            return [3 /*break*/, 10];
-                        case 6:
-                            ixs = context.index[visibility];
-                            _a.label = 7;
-                        case 7:
-                            _a.trys.push([7, 9, , 10]);
-                            return [4 /*yield*/, solidLogicSingleton_1.solidLogicSingleton.load(ixs)];
-                        case 8:
-                            _a.sent();
-                            return [3 /*break*/, 10];
-                        case 9:
-                            err_2 = _a.sent();
-                            msg = "ensureOneTypeIndex: loading indexes ".concat(err_2);
-                            debug.warn(msg);
-                            return [3 /*break*/, 10];
-                        case 10: return [2 /*return*/];
-                    }
-                });
+    }
+    function loadTypeIndexesFor(user) {
+        return __awaiter(this, void 0, void 0, function () {
+            var profile, suggestion, publicTypeIndex, err_5, message, publicScopes, preferencesFile, err_6, privateScopes, suggestedPrivateTypeIndex, privateTypeIndex, _a, err_7, message, scopes, files, err_8;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!user)
+                            throw new Error("loadTypeIndexesFor: No user given");
+                        return [4 /*yield*/, profileLogic.loadProfile(user)];
+                    case 1:
+                        profile = _b.sent();
+                        suggestion = suggestPublicTypeIndex(user);
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, utilityLogic.followOrCreateLink(user, ns.solid('publicTypeIndex'), suggestion, profile)];
+                    case 3:
+                        publicTypeIndex = _b.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        err_5 = _b.sent();
+                        message = "User ".concat(user, " has no pointer in profile to publicTypeIndex file.");
+                        debug.warn(message);
+                        return [3 /*break*/, 5];
+                    case 5:
+                        publicScopes = publicTypeIndex ? [{ label: 'public', index: publicTypeIndex, agent: user }] : [];
+                        _b.label = 6;
+                    case 6:
+                        _b.trys.push([6, 8, , 9]);
+                        return [4 /*yield*/, profileLogic.silencedLoadPreferences(user)];
+                    case 7:
+                        preferencesFile = _b.sent();
+                        return [3 /*break*/, 9];
+                    case 8:
+                        err_6 = _b.sent();
+                        preferencesFile = null;
+                        return [3 /*break*/, 9];
+                    case 9:
+                        if (!preferencesFile) return [3 /*break*/, 15];
+                        suggestedPrivateTypeIndex = suggestPrivateTypeIndex(preferencesFile);
+                        privateTypeIndex = void 0;
+                        _b.label = 10;
+                    case 10:
+                        _b.trys.push([10, 13, , 14]);
+                        _a = store.any(user, ns.solid('privateTypeIndex'), undefined, profile);
+                        if (_a) return [3 /*break*/, 12];
+                        return [4 /*yield*/, utilityLogic.followOrCreateLink(user, ns.solid('privateTypeIndex'), suggestedPrivateTypeIndex, preferencesFile)];
+                    case 11:
+                        _a = (_b.sent());
+                        _b.label = 12;
+                    case 12:
+                        privateTypeIndex = _a;
+                        return [3 /*break*/, 14];
+                    case 13:
+                        err_7 = _b.sent();
+                        message = "User ".concat(user, " has no pointer in preference file to privateTypeIndex file.");
+                        debug.warn(message);
+                        return [3 /*break*/, 14];
+                    case 14:
+                        privateScopes = privateTypeIndex ? [{ label: 'private', index: privateTypeIndex, agent: user }] : [];
+                        return [3 /*break*/, 16];
+                    case 15:
+                        privateScopes = [];
+                        _b.label = 16;
+                    case 16:
+                        scopes = publicScopes.concat(privateScopes);
+                        if (scopes.length === 0)
+                            return [2 /*return*/, scopes];
+                        files = scopes.map(function (scope) { return scope.index; });
+                        _b.label = 17;
+                    case 17:
+                        _b.trys.push([17, 19, , 20]);
+                        return [4 /*yield*/, store.fetcher.load(files)];
+                    case 18:
+                        _b.sent();
+                        return [3 /*break*/, 20];
+                    case 19:
+                        err_8 = _b.sent();
+                        debug.warn('Problems loading type index: ', err_8);
+                        return [3 /*break*/, 20];
+                    case 20: return [2 /*return*/, scopes];
+                }
             });
-        } // makeIndexIfNecessary
-        var context2, relevant, pp, error_3;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, ensureLoadedPreferences(context)];
-                case 1:
-                    context2 = _a.sent();
-                    if (!context2.publicProfile)
-                        throw new Error("@@ type index: no publicProfile");
-                    if (!context2.preferencesFile)
-                        throw new Error("@@ type index: no preferencesFile for profile  ".concat(context2.publicProfile));
-                    relevant = isPublic ? context2.publicProfile : context2.preferencesFile;
-                    _a.label = 2;
-                case 2:
-                    _a.trys.push([2, 5, , 7]);
-                    return [4 /*yield*/, loadIndex(context2, isPublic)];
-                case 3:
-                    _a.sent();
-                    pp = isPublic ? 'public' : 'private';
-                    if (context2.index && context2.index[pp] && context2.index[pp].length > 0) {
-                        debug.log("ensureOneTypeIndex: Type index exists already ".concat(context2.index[pp]));
-                        return [2 /*return*/, context2];
-                    }
-                    return [4 /*yield*/, makeIndexIfNecessary(context2, isPublic)];
-                case 4:
-                    _a.sent();
-                    return [3 /*break*/, 7];
-                case 5:
-                    error_3 = _a.sent();
-                    return [4 /*yield*/, makeIndexIfNecessary(context2, isPublic)
-                        // widgets.complain(context2, 'calling loadIndex:' + error)
-                    ];
-                case 6:
-                    _a.sent();
-                    return [3 /*break*/, 7];
-                case 7: return [2 /*return*/];
-            }
         });
-    });
-}
-/**
- * Register a new app in a type index
- * used in chat in bookmark.js (solid-ui)
- */
-function registerInTypeIndex(context, instance, theClass, isPublic, agent // Defaults to current user
-) {
-    return __awaiter(this, void 0, void 0, function () {
-        var indexes, index, registration, ins, e_2;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, ensureOneTypeIndex(context, isPublic, agent)];
-                case 1:
-                    _a.sent();
-                    if (!context.index) {
-                        throw new Error('registerInTypeIndex: No type index found');
-                    }
-                    indexes = isPublic ? context.index.public : context.index.private;
-                    if (!indexes.length) {
-                        throw new Error('registerInTypeIndex: What no type index?');
-                    }
-                    index = indexes[0];
-                    registration = (0, uri_1.newThing)(index);
-                    ins = [
-                        // See https://github.com/solidos/solid/blob/main/proposals/data-discovery.md
-                        (0, rdflib_1.st)(registration, exports.ns.rdf('type'), exports.ns.solid('TypeRegistration'), index),
-                        (0, rdflib_1.st)(registration, exports.ns.solid('forClass'), theClass, index),
-                        (0, rdflib_1.st)(registration, exports.ns.solid('instance'), instance, index)
-                    ];
-                    _a.label = 2;
-                case 2:
-                    _a.trys.push([2, 4, , 5]);
-                    return [4 /*yield*/, solidLogicSingleton_1.solidLogicSingleton.updatePromise([], ins)];
-                case 3:
-                    _a.sent();
-                    return [3 /*break*/, 5];
-                case 4:
-                    e_2 = _a.sent();
-                    debug.log(e_2);
-                    alert(e_2);
-                    return [3 /*break*/, 5];
-                case 5: return [2 /*return*/, context];
-            }
+    }
+    function loadCommunityTypeIndexes(user) {
+        return __awaiter(this, void 0, void 0, function () {
+            var preferencesFile, err_9, message, communities, result, _i, communities_1, org, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _c.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, profileLogic.silencedLoadPreferences(user)];
+                    case 1:
+                        preferencesFile = _c.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        err_9 = _c.sent();
+                        message = "User ".concat(user, " has no pointer in profile to preferences file.");
+                        debug.warn(message);
+                        return [3 /*break*/, 3];
+                    case 3:
+                        if (!preferencesFile) return [3 /*break*/, 8];
+                        communities = store.each(user, ns.solid('community'), undefined, preferencesFile).concat(store.each(user, ns.solid('community'), undefined, user.doc()));
+                        result = [];
+                        _i = 0, communities_1 = communities;
+                        _c.label = 4;
+                    case 4:
+                        if (!(_i < communities_1.length)) return [3 /*break*/, 7];
+                        org = communities_1[_i];
+                        _b = (_a = result).concat;
+                        return [4 /*yield*/, loadTypeIndexesFor(org)];
+                    case 5:
+                        result = _b.apply(_a, [_c.sent()]);
+                        _c.label = 6;
+                    case 6:
+                        _i++;
+                        return [3 /*break*/, 4];
+                    case 7: return [2 /*return*/, result];
+                    case 8: return [2 /*return*/, []]; // No communities
+                }
+            });
         });
-    });
+    }
+    function loadAllTypeIndexes(user) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, loadTypeIndexesFor(user)];
+                    case 1:
+                        _b = (_a = (_c.sent())).concat;
+                        return [4 /*yield*/, loadCommunityTypeIndexes(user)];
+                    case 2: return [2 /*return*/, _b.apply(_a, [(_c.sent()).flat()])];
+                }
+            });
+        });
+    }
+    function getScopedAppInstances(klass, user) {
+        return __awaiter(this, void 0, void 0, function () {
+            var scopes, scopedApps, _i, scopes_1, scope, scopedApps0;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, loadAllTypeIndexes(user)];
+                    case 1:
+                        scopes = _a.sent();
+                        scopedApps = [];
+                        _i = 0, scopes_1 = scopes;
+                        _a.label = 2;
+                    case 2:
+                        if (!(_i < scopes_1.length)) return [3 /*break*/, 5];
+                        scope = scopes_1[_i];
+                        return [4 /*yield*/, getScopedAppsFromIndex(scope, klass)];
+                    case 3:
+                        scopedApps0 = _a.sent();
+                        scopedApps = scopedApps.concat(scopedApps0);
+                        _a.label = 4;
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 5: return [2 /*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.
+    //
+    function getAppInstances(klass) {
+        return __awaiter(this, void 0, void 0, function () {
+            var user, scopedAppInstances;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        user = authn.currentUser();
+                        if (!user)
+                            throw new Error('getAppInstances: Must be logged in to find apps.');
+                        return [4 /*yield*/, getScopedAppInstances(klass, user)];
+                    case 1:
+                        scopedAppInstances = _a.sent();
+                        return [2 /*return*/, scopedAppInstances.map(function (scoped) { return scoped.instance; })];
+                }
+            });
+        });
+    }
+    function suggestPublicTypeIndex(me) {
+        var _a;
+        return (0, rdflib_1.sym)(((_a = me.doc().dir()) === null || _a === void 0 ? void 0 : _a.uri) + 'publicTypeIndex.ttl');
+    }
+    // Note this one is based off the pref file not the profile
+    function suggestPrivateTypeIndex(preferencesFile) {
+        var _a;
+        return (0, rdflib_1.sym)(((_a = preferencesFile.doc().dir()) === null || _a === void 0 ? void 0 : _a.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
+    */
+    function registerInstanceInTypeIndex(instance, index, theClass) {
+        return __awaiter(this, void 0, void 0, function () {
+            var registration, ins, err_10, msg;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        registration = (0, utils_1.newThing)(index);
+                        ins = [
+                            // See https://github.com/solid/solid/blob/main/proposals/data-discovery.md
+                            (0, rdflib_1.st)(registration, ns.rdf('type'), ns.solid('TypeRegistration'), index),
+                            (0, rdflib_1.st)(registration, ns.solid('forClass'), theClass, index),
+                            (0, rdflib_1.st)(registration, ns.solid('instance'), instance, index)
+                        ];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, store.updater.update([], ins)];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_10 = _a.sent();
+                        msg = "Unable to register ".concat(instance, " in index ").concat(index, ": ").concat(err_10);
+                        console.warn(msg);
+                        return [2 /*return*/, null];
+                    case 4: return [2 /*return*/, registration];
+                }
+            });
+        });
+    }
+    function deleteTypeIndexRegistration(item) {
+        return __awaiter(this, void 0, void 0, function () {
+            var reg, statements;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        reg = store.the(null, ns.solid('instance'), item.instance, item.scope.index);
+                        if (!reg)
+                            throw new Error("deleteTypeIndexRegistration: No registration found for ".concat(item.instance));
+                        statements = store.statementsMatching(reg, null, null, item.scope.index);
+                        return [4 /*yield*/, store.updater.update(statements, [])];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    function getScopedAppsFromIndex(scope, theClass) {
+        return __awaiter(this, void 0, void 0, function () {
+            var index, registrations, relevant, directInstances, instances, instanceContainers, containers, i, cont, contents;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        index = scope.index;
+                        registrations = store.statementsMatching(null, ns.solid('instance'), null, index)
+                            .concat(store.statementsMatching(null, ns.solid('instanceContainer'), null, index))
+                            .map(function (st) { return st.subject; });
+                        relevant = theClass ? registrations.filter(function (reg) { var _a; return (_a = store.any(reg, ns.solid('forClass'), null, index)) === null || _a === void 0 ? void 0 : _a.sameTerm(theClass); })
+                            : registrations;
+                        directInstances = relevant.map(function (reg) { return store.each(reg, ns.solid('instance'), null, index).map(function (one) { return (0, rdflib_1.sym)(one.value); }); }).flat();
+                        instances = (0, utils_1.uniqueNodes)(directInstances);
+                        instanceContainers = relevant.map(function (reg) { return store.each(reg, ns.solid('instanceContainer'), null, index).map(function (one) { return (0, rdflib_1.sym)(one.value); }); }).flat();
+                        containers = (0, utils_1.uniqueNodes)(instanceContainers);
+                        if (containers.length > 0) {
+                            console.log('@@ getScopedAppsFromIndex containers ', containers);
+                        }
+                        i = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(i < containers.length)) return [3 /*break*/, 4];
+                        cont = containers[i];
+                        return [4 /*yield*/, store.fetcher.load(cont)];
+                    case 2:
+                        _a.sent();
+                        contents = store.each(cont, ns.ldp('contains'), null, cont).map(function (one) { return (0, rdflib_1.sym)(one.value); });
+                        instances = instances.concat(contents);
+                        _a.label = 3;
+                    case 3:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, instances.map(function (instance) { return { instance: instance, scope: scope }; })];
+                }
+            });
+        });
+    }
+    return {
+        ensureTypeIndexes: ensureTypeIndexes,
+        loadTypeIndexes: loadTypeIndexes,
+        registerInTypeIndex: registerInTypeIndex,
+        loadIndex: loadIndex,
+        ensureOneTypeIndex: ensureOneTypeIndex,
+        putIndex: putIndex,
+        makeIndexIfNecessary: makeIndexIfNecessary,
+        loadIndexes: loadIndexes,
+        getTypeIndex: getTypeIndex,
+        getRegistrations: getRegistrations,
+        loadTypeIndexesFor: loadTypeIndexesFor,
+        loadCommunityTypeIndexes: loadCommunityTypeIndexes,
+        loadAllTypeIndexes: loadAllTypeIndexes,
+        getScopedAppInstances: getScopedAppInstances,
+        getAppInstances: getAppInstances,
+        suggestPublicTypeIndex: suggestPublicTypeIndex,
+        suggestPrivateTypeIndex: suggestPrivateTypeIndex,
+        registerInstanceInTypeIndex: registerInstanceInTypeIndex,
+        deleteTypeIndexRegistration: deleteTypeIndexRegistration,
+        getScopedAppsFromIndex: getScopedAppsFromIndex
+    };
 }
-exports.registerInTypeIndex = registerInTypeIndex;
+exports.createTypeIndexLogic = createTypeIndexLogic;
 //# sourceMappingURL=typeIndexLogic.js.map