solid-panes 4.4.2-7 → 4.5.0

package/dist/internal/internalPane.js

@@ -0,0 +1,183 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _solidUi = require("solid-ui");
+var _rdflib = require("rdflib");
+require("./internalPane.css");
+/*   Internal Pane
+ **
+ **  This outline pane contains the properties which are
+ ** internal to the user's interaction with the web, and are not normally displayed
+ */
+/* global alert confirm */
+
+const pane = {
+  icon: _solidUi.icons.originalIconBase + 'tango/22-emblem-system.png',
+  name: 'internal',
+  label: function () {
+    return 'under the hood'; // There is often a URI even of no statements
+  },
+  render: function (subject, context) {
+    const dom = context.dom;
+    // @ts-ignore
+    const store = context.session.store;
+    const canonizedSubject = store.canon(subject);
+    const types = store.findTypeURIs(canonizedSubject);
+    function filter(pred) {
+      if (types['http://www.w3.org/2007/ont/link#ProtocolEvent']) return true; // display everything for them
+      const view = context.session.paneRegistry.byName('internal');
+      return view && view.predicates && !!(typeof view.predicates[pred.uri] !== 'undefined');
+    }
+    const div = dom.createElement('div');
+    div.classList.add('internalPane', 'internalPaneContent');
+    function deleteRecursive(kb, folder) {
+      const fetcher = kb.fetcher;
+      if (!fetcher) {
+        console.error('No fetcher available');
+        return;
+      }
+      return new Promise(function (resolve, reject) {
+        fetcher.load(folder).then(function () {
+          const promises = kb.each(folder, _solidUi.ns.ldp('contains')).map(file => {
+            if (kb.holds(file, _solidUi.ns.rdf('type'), _solidUi.ns.ldp('BasicContainer'))) {
+              return deleteRecursive(kb, file);
+            } else {
+              console.log('deleteRecursive leaf file: ' + file);
+              return fetcher.webOperation('DELETE', file.uri);
+            }
+          });
+          Promise.all(promises).then(() => {
+            console.log('deleteRecursive empty folder: ' + folder);
+            fetcher.webOperation('DELETE', folder.uri).then(() => {
+              console.log('Deleted Ok: ' + folder);
+              resolve(undefined);
+            }).catch(err => {
+              const str = 'Unable to delete ' + folder + ': ' + err;
+              console.log(str);
+              reject(new Error(str));
+            });
+            resolve(undefined);
+          }, err => {
+            alert(err);
+            reject(err);
+          });
+        });
+      });
+    }
+    const isDocument = subject.uri && !subject.uri.includes('#');
+    if (isDocument) {
+      const controls = div.appendChild(dom.createElement('table'));
+      controls.classList.add('internalPaneControls');
+      const controlRow = controls.appendChild(dom.createElement('tr'));
+      const deleteCell = controlRow.appendChild(dom.createElement('td'));
+      const isFolder = subject.uri && subject.uri.endsWith('/') || store.holds(subject, _solidUi.ns.rdf('type'), _solidUi.ns.ldp('Container'));
+      const noun = isFolder ? 'folder' : 'file';
+      if (!isProtectedUri(subject)) {
+        console.log(subject);
+        const deleteButton = _solidUi.widgets.deleteButtonWithCheck(dom, deleteCell, noun, function () {
+          if (!confirm(`Are you sure you want to delete ${subject}? This cannot be undone.`)) {
+            return;
+          }
+          // @@ TODO Remove casing of store.fetcher
+          if (!store.fetcher) {
+            throw new Error('Store has no fetcher');
+          }
+          const promise = isFolder ? deleteRecursive(store, subject) || Promise.resolve() : store.fetcher.webOperation('DELETE', subject.uri) || Promise.resolve();
+          promise.then(() => {
+            const str = 'Deleted: ' + subject;
+            console.log(str);
+          }).catch(err => {
+            const str = 'Unable to delete ' + subject + ': ' + err;
+            console.log(str);
+            alert(str);
+          });
+        });
+        deleteButton.removeAttribute('class'); // Remove hover hide
+        deleteButton.classList.add('internalPaneDeleteButton');
+        deleteCell.appendChild(deleteButton);
+      }
+      const refreshCell = controlRow.appendChild(dom.createElement('td'));
+      const refreshButton = _solidUi.widgets.button(dom, _solidUi.icons.iconBase + 'noun_479395.svg', 'refresh');
+      refreshCell.appendChild(refreshButton);
+      refreshButton.addEventListener('click', () => {
+        if (!store.fetcher) {
+          throw new Error('Store has no fetcher');
+        }
+        store.fetcher.refresh(subject, function (ok, errm) {
+          let str;
+          if (ok) {
+            str = 'Refreshed OK: ' + subject;
+          } else {
+            str = 'Error refreshing: ' + subject + ': ' + errm;
+          }
+          console.log(str);
+          alert(str);
+        });
+      });
+    }
+    let plist = store.statementsMatching(subject);
+    let docURI = '';
+    if (!store.fetcher) {
+      throw new Error('Store has no fetcher');
+    }
+    if (subject.uri) {
+      plist.push((0, _rdflib.st)(subject, (0, _rdflib.sym)('http://www.w3.org/2007/ont/link#uri'), subject.uri,
+      // @@ TODO Remove casting
+      store.fetcher.appNode));
+      if (subject.uri.indexOf('#') >= 0) {
+        docURI = subject.uri.split('#')[0];
+        plist.push((0, _rdflib.st)(subject, (0, _rdflib.sym)('http://www.w3.org/2007/ont/link#documentURI'), subject.uri.split('#')[0],
+        // @@ TODO Remove casting
+        store.fetcher.appNode));
+        plist.push((0, _rdflib.st)(subject, (0, _rdflib.sym)('http://www.w3.org/2007/ont/link#document'), (0, _rdflib.sym)(subject.uri.split('#')[0]), store.fetcher.appNode));
+      } else {
+        docURI = subject.uri;
+      }
+    }
+    if (docURI) {
+      if (!store.updater) {
+        throw new Error('Store has no updater');
+      }
+      const ed = store.updater.editable(docURI);
+      if (ed) {
+        plist.push((0, _rdflib.st)(subject, (0, _rdflib.sym)('http://www.w3.org/ns/rww#editable'), (0, _rdflib.literal)(ed.toString()), store.fetcher.appNode));
+      }
+    }
+    // @@ TODO get a proper type
+    const outliner = context.getOutliner(dom);
+    outliner.appendPropertyTRs(div, plist, false, filter);
+    plist = store.statementsMatching(undefined, undefined, subject);
+    outliner.appendPropertyTRs(div, plist, true, filter);
+    return div;
+  },
+  predicates: {
+    // Predicates used for inner workings. Under the hood
+    'http://www.w3.org/2007/ont/link#request': 1,
+    'http://www.w3.org/2007/ont/link#requestedBy': 1,
+    'http://www.w3.org/2007/ont/link#source': 1,
+    'http://www.w3.org/2007/ont/link#session': 2,
+    // 2=  test neg but display
+    'http://www.w3.org/2007/ont/link#uri': 1,
+    'http://www.w3.org/2007/ont/link#documentURI': 1,
+    'http://www.w3.org/2007/ont/link#document': 1,
+    'http://www.w3.org/2007/ont/link#all': 1,
+    // From userinput.js
+    'http://www.w3.org/2007/ont/link#Document': 1,
+    'http://www.w3.org/ns/rww#editable': 1,
+    'http://www.w3.org/2000/01/rdf-schema#seeAlso': 1,
+    'http://www.w3.org/2002/07/owl#': 1
+  },
+  classes: {
+    // Things which are inherently already undercover
+    'http://www.w3.org/2007/ont/link#ProtocolEvent': 1
+  }
+};
+function isProtectedUri(subject) {
+  // TODO: Could make the code below smarter by removing some of the redundancy by creating a recursive function, but did not bother now
+  const siteUri = subject.site().uri;
+  return subject.uri === siteUri || subject.uri === siteUri + 'profile/' || subject.uri === siteUri + 'profile/card' || subject.uri === siteUri + 'settings/' || subject.uri === siteUri + 'settings/prefs.ttl' || subject.uri === siteUri + 'settings/privateTypeIndex.ttl' || subject.uri === siteUri + 'settings/publicTypeIndex.ttl' || subject.uri === siteUri + 'settings/serverSide.ttl';
+}
+var _default = exports.default = pane; // ends

package/dist/mainPage/footer.d.ts

@@ -0,0 +1,15 @@
+import 'solid-ui/components/footer';
+import type { LiveStore } from 'rdflib';
+declare module 'solid-ui/components/footer';
+import 'solid-ui/components/footer';
+type FooterElement = HTMLElement & {
+    store?: LiveStore | null;
+    position?: 'static' | 'absolute' | 'relative' | 'fixed' | 'sticky';
+    top?: string;
+    right?: string;
+    bottom?: string;
+    left?: string;
+};
+export declare function createFooter(store: LiveStore): FooterElement;
+export {};
+//# sourceMappingURL=footer.d.ts.map

package/dist/mainPage/footer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"footer.d.ts","sourceRoot":"","sources":["../../src/mainPage/footer.ts"],"names":[],"mappings":"AAAA,OAAO,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAEvC,OAAO,QAAQ,4BAA4B,CAAA;AAC3C,OAAO,4BAA4B,CAAA;AAEnC,KAAK,aAAa,GAAG,WAAW,GAAG;IACjC,KAAK,CAAC,EAAE,SAAS,GAAG,IAAI,CAAA;IACxB,QAAQ,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAA;IAClE,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,wBAAgB,YAAY,CAAE,KAAK,EAAE,SAAS,iBAuB7C"}

package/dist/mainPage/footer.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFooter = createFooter;
+require("solid-ui/components/footer");
+function createFooter(store) {
+  let footer = document.querySelector('solid-ui-footer');
+  if (!footer) {
+    footer = document.createElement('solid-ui-footer');
+    footer.className = 'menu-footer';
+    footer.style.position = 'static';
+    footer.style.width = '100%';
+    const navMenu = document.getElementById('NavMenu');
+    if (navMenu) {
+      navMenu.appendChild(footer);
+    } else {
+      document.body.appendChild(footer);
+    }
+  } else {
+    const navMenu = document.getElementById('NavMenu');
+    if (navMenu && footer.parentElement !== navMenu) {
+      navMenu.appendChild(footer);
+    }
+  }
+  footer.store = store;
+  return footer;
+}

package/dist/mainPage/header.d.ts

@@ -1,3 +1,17 @@
+import 'solid-ui/components/header';
+import { Header } from 'solid-ui/components/header';
 import { OutlineManager } from '../outline/manager';
-export declare function createHeader(outliner: OutlineManager): Promise<Element>;
+import { LiveStore } from 'rdflib';
+export declare const HELP_MENU_LIST: {
+    label: string;
+    url: string;
+    target: string;
+}[];
+type ManagedHeader = Header & {
+    __solidPanesListenersAttached?: boolean;
+    __solidPanesOutliner?: OutlineManager;
+};
+export declare function createHeader(store: LiveStore, outliner: OutlineManager): Promise<ManagedHeader>;
+export declare function refreshHeader(outliner: OutlineManager, headerElement?: Header): Promise<Header | null>;
+export {};
 //# sourceMappingURL=header.d.ts.map

package/dist/mainPage/header.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"header.d.ts","sourceRoot":"","sources":["../../src/mainPage/header.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAExD,OAAO,oBAAoB,CAAA;AAC3B,OAAO,qBAAqB,CAAA;AAC5B,OAAO,2BAA2B,CAAA;AAClC,OAAO,gCAAgC,CAAA;AACvC,OAAO,0BAA0B,CAAA;AACjC,OAAO,sBAAsB,CAAA;AAI7B,wBAAsB,YAAY,CAAE,QAAQ,EAAE,cAAc,oBAiG3D"}
+{"version":3,"file":"header.d.ts","sourceRoot":"","sources":["../../src/mainPage/header.ts"],"names":[],"mappings":"AAEA,OAAO,4BAA4B,CAAA;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAA;AAEnD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AA4BlC,eAAO,MAAM,cAAc;;;;GAG1B,CAAA;AAID,KAAK,aAAa,GAAG,MAAM,GAAG;IAC5B,6BAA6B,CAAC,EAAE,OAAO,CAAA;IACvC,oBAAoB,CAAC,EAAE,cAAc,CAAA;CACtC,CAAA;AAcD,wBAAsB,YAAY,CAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,cAAc,0BA6B7E;AAoDD,wBAAsB,aAAa,CAAE,QAAQ,EAAE,cAAc,EAAE,aAAa,CAAC,EAAE,MAAM,0BAyBpF"}

package/dist/mainPage/header.js

@@ -0,0 +1,203 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HELP_MENU_LIST = void 0;
+exports.createHeader = createHeader;
+exports.refreshHeader = refreshHeader;
+var _solidLogic = require("solid-logic");
+var _solidUi = require("solid-ui");
+require("solid-ui/components/header");
+var _help = _interopRequireDefault(require("../icons/help.svg?raw"));
+var _person = _interopRequireDefault(require("../icons/person.svg?raw"));
+var _signOut = _interopRequireDefault(require("../icons/signOut.svg?raw"));
+var _personInCircle = _interopRequireDefault(require("../icons/personInCircle.svg?raw"));
+var _downArrow = _interopRequireDefault(require("../icons/downArrow.svg?raw"));
+var _signUp = _interopRequireDefault(require("../icons/signUp.svg?raw"));
+var _iconHelper = require("../icons/iconHelper");
+var _menu = require("./menu");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * menu icons
+*/
+const HELP_MENU_ICON = (0, _iconHelper.createUiIcon)(_help.default, 'Help Icon', '#ffffff');
+const LOGIN_ICON = (0, _iconHelper.createUiIcon)(_person.default, 'LogIn Icon', '#ffffff');
+const SIGNUP_ICON = (0, _iconHelper.createUiIcon)(_signUp.default, 'SignUp Icon', '#ffffff');
+const LOGOUT_ICON = (0, _iconHelper.createUiIcon)(_signOut.default, 'LogOut Icon', '#000000');
+const DEFAULT_AVATAR_ICON = (0, _iconHelper.createUiIcon)(_personInCircle.default, 'Default Avatar Icon', '#6A7282');
+const DOWN_ARROW_ICON = (0, _iconHelper.createUiIcon)(_downArrow.default, 'Down Arrow Icon', '#ffffff');
+const SOLID_ICON_URL = 'https://solidproject.org/assets/img/solid-emblem.svg';
+/**
+ * menu elements
+*/
+const SIGN_IN_MENU_ITEM = 'Log In';
+const SIGN_OUT_MENU_ITEM = 'Log Out';
+const SIGN_UP_MENU_ITEM = 'Sign Up';
+const SIGN_UP__MENU_LINK = 'https://solidproject.org/get_a_pod';
+
+// data structure extracted for solid-ui-header binding
+const HELP_MENU_LIST = exports.HELP_MENU_LIST = [{
+  label: 'User guide',
+  url: 'https://solidos.github.io/userguide/',
+  target: '_blank'
+}, {
+  label: 'Report a problem',
+  url: 'https://github.com/solidos/solidos/issues',
+  target: '_blank'
+}];
+const HEADER_MOBILE_STYLE_ID = 'solid-ui-header-mobile-style';
+function ensureMobileHeaderStyles() {
+  if (document.getElementById(HEADER_MOBILE_STYLE_ID)) return;
+  const style = document.createElement('style');
+  style.id = HEADER_MOBILE_STYLE_ID;
+  style.textContent = `
+    solid-ui-header[layout="mobile"]::part(logo) {
+      display: none !important;
+    }
+  `;
+  document.head.appendChild(style);
+}
+async function createHeader(store, outliner) {
+  ensureMobileHeaderStyles();
+  const header = document.querySelector('solid-ui-header') || document.createElement('solid-ui-header');
+  const isNewHeader = !header.isConnected;
+  if (!header.id) {
+    header.id = 'mainSolidUiHeader';
+  }
+  header.__solidPanesOutliner = outliner;
+
+  // ensure it is in DOM (before MainContent for consistency)
+  const main = document.getElementById('MainContent');
+  if (!header.isConnected) {
+    if (main && main.parentNode) {
+      main.parentNode.insertBefore(header, main);
+    } else {
+      document.body.prepend(header);
+    }
+  }
+  await refreshHeader(outliner, header);
+  if (isNewHeader) {
+    header.__solidPanesListenersAttached = false;
+  }
+  attachHeaderListeners(header);
+  return header;
+}
+function attachHeaderListeners(header) {
+  if (header.__solidPanesListenersAttached) return;
+  const refreshCurrentHeader = async () => {
+    const outliner = header.__solidPanesOutliner;
+    if (!outliner) return;
+    await refreshHeader(outliner, header);
+  };
+  _solidLogic.authSession.events.on('login', refreshCurrentHeader);
+  _solidLogic.authSession.events.on('logout', refreshCurrentHeader);
+  _solidLogic.authSession.events.on('sessionRestore', refreshCurrentHeader);
+  header.addEventListener('auth-action-select', async e => {
+    const outliner = header.__solidPanesOutliner;
+    if (!outliner) return;
+    const detail = e.detail;
+    if (detail?.role === 'login') {
+      await refreshCurrentHeader();
+      // Do not auto-open the profile pane after login.
+      // outliner.showDashboard({ pane: 'profile' })
+    }
+  });
+  header.addEventListener('signup-success', async () => {
+    // do nothing
+  });
+  header.addEventListener('account-menu-select', async e => {
+    const outliner = header.__solidPanesOutliner;
+    if (!outliner) return;
+    const detail = e.detail;
+    if (detail?.action === 'logout') {
+      await refreshCurrentHeader();
+      // Do not navigate to the profile after logout.
+    } else if (detail?.action === 'show-profile') {
+      // TODO see if this can be consolidated
+      const currentUser = _solidLogic.authn.currentUser();
+      if (currentUser) {
+        outliner.showDashboard(currentUser, {
+          pane: 'profile'
+        });
+        (0, _menu.setActiveMenuPane)('profile');
+      }
+    }
+  });
+  header.__solidPanesListenersAttached = true;
+}
+async function refreshHeader(outliner, headerElement) {
+  ensureMobileHeaderStyles();
+  const headerOptions = setHeaderOptions(outliner);
+  const header = headerElement || document.querySelector('solid-ui-header');
+  if (!header) return null;
+  header.theme = headerOptions.theme;
+  header.layout = headerOptions.layout;
+  header.brandLink = headerOptions.brandLink;
+  header.logo = headerOptions.layout === 'desktop' ? headerOptions.logo : '';
+  header.helpIcon = headerOptions.helpIcon;
+  header.helpMenuList = headerOptions.helpMenuList;
+  header.authState = headerOptions.authState;
+  header.loginAction = headerOptions.loginAction;
+  header.signUpAction = headerOptions.signUpAction;
+  header.accountMenu = await setUserMenu();
+  header.logoutLabel = headerOptions.logoutLabel;
+  header.accountIcon = headerOptions.accountIcon;
+  header.accountAvatar = headerOptions.accountAvatar;
+  header.accountAvatarFallback = headerOptions.accountAvatarFallback;
+  header.loginIcon = headerOptions.loginIcon;
+  header.signUpIcon = headerOptions.signUpIcon;
+  header.logoutIcon = headerOptions.logoutIcon;
+  return header;
+}
+function setHeaderOptions(outliner) {
+  const currentUser = _solidLogic.authn.currentUser();
+  const isAuthenticated = !!currentUser;
+  const authState = isAuthenticated ? 'logged-in' : 'logged-out';
+  const layout = outliner.context?.environment?.layout === 'mobile' ? 'mobile' : 'desktop';
+  const theme = outliner.context?.environment?.theme === 'dark' ? 'dark' : 'light';
+  const headerOptions = {
+    logo: SOLID_ICON_URL,
+    helpIcon: HELP_MENU_ICON,
+    helpMenuList: HELP_MENU_LIST,
+    layout,
+    theme,
+    brandLink: '/',
+    authState,
+    loginAction: {
+      label: SIGN_IN_MENU_ITEM
+    },
+    signUpAction: {
+      label: SIGN_UP_MENU_ITEM,
+      url: SIGN_UP__MENU_LINK
+    },
+    logoutLabel: SIGN_OUT_MENU_ITEM,
+    accountIcon: isAuthenticated ? DOWN_ARROW_ICON : '',
+    accountAvatar: isAuthenticated ? _solidUi.widgets.findImage(currentUser) : undefined,
+    accountAvatarFallback: DEFAULT_AVATAR_ICON,
+    loginIcon: LOGIN_ICON,
+    signUpIcon: SIGNUP_ICON,
+    logoutIcon: LOGOUT_ICON
+  };
+  return headerOptions;
+}
+async function setUserMenu() {
+  const me = _solidLogic.authn.currentUser();
+  if (!me) {
+    return [];
+  }
+  try {
+    await _solidLogic.store.fetcher.load(me.doc());
+  } catch (err) {
+    console.error('Unable to load user profile', err);
+  }
+  const accountMenu = [{
+    label: _solidUi.utils.label(me),
+    avatar: _solidUi.widgets.findImage(me),
+    webid: me.value,
+    action: 'show-profile'
+  }
+  // TODO add all my available accounts
+  ];
+  return accountMenu;
+}

package/dist/mainPage/index.d.ts

@@ -1,6 +1,18 @@
-import { LiveStore, NamedNode } from '../../node_modules/rdflib';
-import { RenderEnvironment } from '../../node_modules/pane-registry';
+import { LiveStore, NamedNode } from 'rdflib';
+import type { RenderEnvironment } from 'pane-registry';
 import { OutlineManager } from '../index';
-export declare function initMainPage(store: LiveStore, uri?: string | NamedNode | null, environment?: RenderEnvironment): Promise<[Element, HTMLElement]>;
+export { refreshMenu as updateMenuLayout } from './menu';
+export { refreshHeader } from './header';
+export declare function initMainPage(store: LiveStore, uri?: string | NamedNode | null, environment?: RenderEnvironment): Promise<[import("solid-ui/components/header").Header & {
+    __solidPanesListenersAttached?: boolean;
+    __solidPanesOutliner?: OutlineManager;
+}, void, HTMLElement & {
+    store?: LiveStore | null;
+    position?: "static" | "absolute" | "relative" | "fixed" | "sticky";
+    top?: string;
+    right?: string;
+    bottom?: string;
+    left?: string;
+}]>;
 export declare function refreshUI(outliner: OutlineManager): Promise<void>;
 //# sourceMappingURL=index.d.ts.map

package/dist/mainPage/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mainPage/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAEtD,OAAO,EAAe,cAAc,EAAE,MAAM,UAAU,CAAA;AA4BtD,wBAAsB,YAAY,CAChC,KAAK,EAAE,SAAS,EAChB,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,EAC/B,WAAW,CAAC,EAAE,iBAAiB,mCAqBhC;AAED,wBAAsB,SAAS,CAAE,QAAQ,EAAE,cAAc,iBAiBxD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mainPage/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AACtD,OAAO,EAAe,cAAc,EAAE,MAAM,UAAU,CAAA;AActD,OAAO,EAAE,WAAW,IAAI,gBAAgB,EAAE,MAAM,QAAQ,CAAA;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAexC,wBAAsB,YAAY,CAChC,KAAK,EAAE,SAAS,EAChB,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,EAC/B,WAAW,CAAC,EAAE,iBAAiB;;;;;;;;;;IAahC;AAED,wBAAsB,SAAS,CAAE,QAAQ,EAAE,cAAc,iBAoBxD"}

package/dist/mainPage/index.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initMainPage = initMainPage;
+Object.defineProperty(exports, "refreshHeader", {
+  enumerable: true,
+  get: function () {
+    return _header.refreshHeader;
+  }
+});
+exports.refreshUI = refreshUI;
+Object.defineProperty(exports, "updateMenuLayout", {
+  enumerable: true,
+  get: function () {
+    return _menu.refreshMenu;
+  }
+});
+var _index = require("../index");
+var _header = require("./header");
+var _footer = require("./footer");
+var _menu = require("./menu");
+/*   Main Page
+ **
+ **  This code is called in mashlib and renders the header and footer of the Databrowser.
+ */
+
+// Symbol used to stash the last render-relevant env snapshot on the outliner
+// so refreshUI can skip a full GotoSubject re-render when nothing changed.
+const LAST_RENDER_ENV_KEY = '__lastRenderEnvSignature';
+function renderEnvSignature(env) {
+  if (!env) return '';
+  return [env.layout, env.theme, env.inputMode].join('|');
+}
+function ensureMainContent() {
+  let main = document.getElementById('MainContent');
+  if (!main) {
+    main = document.createElement('main');
+    main.id = 'MainContent';
+    main.setAttribute('role', 'main');
+    main.setAttribute('tabindex', '-1');
+    main.setAttribute('aria-live', 'polite');
+    document.body.appendChild(main);
+  }
+  return main;
+}
+async function initMainPage(store, uri, environment) {
+  ensureMainContent();
+  const outliner = (0, _index.getOutliner)(document, environment);
+  outliner[LAST_RENDER_ENV_KEY] = renderEnvSignature(environment);
+  uri = uri || window.location.href;
+  const subject = typeof uri === 'string' ? store.sym(uri) : uri;
+  outliner.GotoSubject(subject, true, undefined, true, undefined);
+  const header = await (0, _header.createHeader)(store, outliner);
+  const menu = (0, _menu.createLeftSideMenu)(subject, outliner);
+  const footer = menu.then(() => (0, _footer.createFooter)(store));
+  return Promise.all([header, menu, footer]);
+}
+async function refreshUI(outliner) {
+  const store = outliner?.context?.session?.store;
+  const paneRegistry = outliner?.context?.session?.paneRegistry;
+  const subjectUri = window.document.location.href;
+  const paneName = window.history.state?.paneName;
+  const pane = paneName ? paneRegistry?.byName?.(paneName) : undefined;
+
+  // Only re-run GotoSubject (full pane re-render) when render-relevant
+  // environment fields actually changed since the last render.
+  const currentSignature = renderEnvSignature(outliner?.context?.environment);
+  const previousSignature = outliner?.[LAST_RENDER_ENV_KEY] ?? '';
+  const envChanged = currentSignature !== previousSignature;
+  if (envChanged && store && typeof outliner?.GotoSubject === 'function') {
+    outliner.GotoSubject(store.sym(subjectUri), true, pane, true, undefined);
+    outliner[LAST_RENDER_ENV_KEY] = currentSignature;
+  }
+  await (0, _header.refreshHeader)(outliner);
+  (0, _menu.refreshMenu)(outliner.context.environment?.layout === 'mobile' ? 'mobile' : 'desktop');
+}