@cwa/nuxt-edge 1.0.0-29138192.e49c1a0

package/dist/module.mjs

@@ -0,0 +1,235 @@
+import { join } from 'path';
+import path from 'node:path';
+import { readFileSync, statSync } from 'node:fs';
+import { defu } from 'defu';
+import { mergeWith, isArray } from 'lodash-es';
+import { defineNuxtModule, useLogger, createResolver, installModule, addImportsDir, extendPages, addTemplate, addTypeTemplate, addPlugin, updateTemplates, resolveAlias } from '@nuxt/kit';
+
+function createDefaultCwaPages(pages, pageComponentFilePath, maxDepth, layout) {
+  function create(currentDepth = 0) {
+    const page = {
+      name: `cwaPage${currentDepth}`,
+      path: `:cwaPage${currentDepth}*`,
+      file: pageComponentFilePath,
+      meta: {
+        cwa: {
+          disabled: false
+        },
+        layout: layout || "cwa-root-layout"
+      }
+    };
+    if (currentDepth === 0) {
+      page.path = "/:cwaPage0*";
+    }
+    if (currentDepth < maxDepth) {
+      const child = create(++currentDepth);
+      page.children = [child];
+    }
+    return page;
+  }
+  const pagesTree = create();
+  pages.push(pagesTree);
+}
+const NAME = "@cwa/nuxt";
+const module = defineNuxtModule({
+  meta: {
+    name: NAME,
+    configKey: "cwa",
+    compatibility: {
+      nuxt: "^3.6.5",
+      bridge: false
+    }
+  },
+  defaults: {
+    appName: "CWA Web App",
+    storeName: "cwa",
+    resources: {
+      ComponentPosition: {
+        name: "Position",
+        description: "<p>Dynamic components can be used on dynamic pages to specify what component should be displayed from a data page in any given location.</p><p>You must select the reference from the data page to load into this position below.</p>",
+        instantAdd: true
+      },
+      ComponentGroup: {
+        name: "Group"
+      }
+    }
+  },
+  async setup(options, nuxt) {
+    const logger = useLogger(NAME);
+    const { resolve } = createResolver(import.meta.url);
+    const { version, name } = JSON.parse(
+      readFileSync(resolve("../package.json"), "utf8")
+    );
+    logger.info(`Adding ${NAME} module (${name}@${version})...`);
+    logger.info(`Installing @pinia/nuxt for ${NAME} module...`);
+    await installModule("@pinia/nuxt");
+    logger.info(`Modifying Nuxt configuration options for ${NAME} module...`);
+    nuxt.options.runtimeConfig.public.cwa = defu(nuxt.options.runtimeConfig.public.cwa, {
+      apiUrl: options.apiUrl || options.apiUrlBrowser || "",
+      apiUrlBrowser: options.apiUrlBrowser || options.apiUrl || ""
+    });
+    nuxt.options.alias["#cwa"] = resolve("./");
+    nuxt.options.routeRules = Object.assign({
+      "/_/**": { ssr: false }
+    }, nuxt.options.routeRules || {});
+    const runtimeDir = resolve("./runtime");
+    nuxt.options.build.transpile.push(runtimeDir);
+    logger.info(`Configuring auto-imports for CWA composables...`);
+    addImportsDir(resolve("./runtime/composables"));
+    addImportsDir(resolve("./runtime/composables/component"));
+    logger.info(`Configuring CWA default pages and components...`);
+    const vueTemplatesDir = resolve("./runtime/templates");
+    extendPages((pages) => {
+      const pageComponent = resolve(vueTemplatesDir, "cwa-page.vue");
+      createDefaultCwaPages(pages, pageComponent, options.pagesDepth || 3, options.layoutName);
+    });
+    const cwaVueComponentsDir = join(vueTemplatesDir, "components");
+    logger.info(`Registering user components for CWA...`);
+    const userComponentsPath = join(nuxt.options.srcDir, "cwa", "components");
+    nuxt.options.alias["#cwaComponents"] = userComponentsPath;
+    function extendCwaOptions(components) {
+      const defaultResourcesConfig = {};
+      const regex = /^(?!.+\/(admin|ui)\/).+.vue$/;
+      const allUserComponents = components.filter(({ filePath }) => filePath.startsWith(userComponentsPath));
+      const componentsByPath = allUserComponents.reduce((obj, value) => ({ ...obj, [value.filePath]: value }), {});
+      const userComponents = allUserComponents.filter(({ filePath }) => regex.test(filePath));
+      for (const component of userComponents) {
+        const isDirectory = (p) => {
+          try {
+            return statSync(p).isDirectory();
+          } catch (_e) {
+            return false;
+          }
+        };
+        const resolveComponentNames = (dirPath) => {
+          const componentNames = [];
+          if (isDirectory(dirPath)) {
+            const componentFilePaths = Object.keys(componentsByPath).filter((path2) => path2.startsWith(dirPath));
+            componentFilePaths.forEach((filePath) => {
+              if (componentsByPath[filePath]) {
+                componentsByPath[filePath].global && componentNames.push(componentsByPath[filePath].pascalName);
+              }
+            });
+          }
+          return componentNames;
+        };
+        const tabsDir = resolveAlias(resolve(path.dirname(component.filePath), "admin"));
+        const managerTabs = resolveComponentNames(tabsDir);
+        const uiDir = resolveAlias(resolve(path.dirname(component.filePath), "ui"));
+        const ui = resolveComponentNames(uiDir);
+        const resourceType = component.pascalName.replace(/^CwaComponent/, "");
+        defaultResourcesConfig[resourceType] = {
+          // auto name with spaces in place of pascal/camel case
+          name: resourceType.replace(/(?!^)([A-Z])/g, " $1"),
+          managerTabs,
+          ui
+        };
+      }
+      const resources = mergeWith({}, defaultResourcesConfig, options.resources, (a, b) => {
+        if (isArray(a)) {
+          return b.concat(a);
+        }
+      });
+      return { ...options, resources };
+    }
+    nuxt.hook("modules:done", () => {
+      logger.info(`Configuring template to propagate module options and adding plugin for ${NAME} module...`);
+      delete options.pagesDepth;
+      addTemplate({
+        filename: "cwa-options.ts",
+        getContents: ({ app }) => {
+          return `import type { CwaModuleOptions } from '#cwa/module';
+export const options:CwaModuleOptions = ${JSON.stringify(extendCwaOptions(app.components), void 0, 2)}
+export const currentModulePackageInfo:{ version: string, name: string } = ${JSON.stringify({ version, name }, void 0, 2)}
+`;
+        }
+      });
+      addTypeTemplate({
+        filename: "types/cwa.d.ts",
+        write: true,
+        getContents: () => (
+          /* ts */
+          `interface CwaRouteMeta {
+  admin?: boolean
+  disabled?: boolean
+  staticLayout?: GlobalComponentNames
+}
+export * from 'vue-router'
+declare module 'vue-router' {
+  interface RouteMeta {
+    cwa?: CwaRouteMeta
+  }
+}`
+        )
+      });
+      addPlugin({
+        src: resolve("./runtime/plugin")
+      });
+    });
+    nuxt.hook("components:dirs", (dirs) => {
+      logger.info(`Configuring component directories for ${NAME} module...`);
+      dirs.unshift({
+        path: join(cwaVueComponentsDir, "main"),
+        prefix: "Cwa",
+        ignore: ["**/_*/*", "**/*.spec.{cts,mts,ts}"]
+      });
+      dirs.unshift({
+        path: join(cwaVueComponentsDir, "ui"),
+        prefix: "CwaUi",
+        ignore: ["**/*.spec.{cts,mts,ts}"]
+      });
+      dirs.unshift({
+        path: join(nuxt.options.srcDir, "cwa", "layouts"),
+        prefix: "CwaLayout",
+        global: true,
+        ignore: ["**/*.spec.{cts,mts,ts}"]
+      });
+      dirs.unshift({
+        path: join(nuxt.options.srcDir, "cwa", "pages"),
+        prefix: "CwaPage",
+        global: true,
+        ignore: ["**/*.spec.{cts,mts,ts}"]
+      });
+      dirs.unshift({
+        path: userComponentsPath,
+        prefix: "CwaComponent",
+        global: true,
+        ignore: ["**/*.spec.{cts,mts,ts}"]
+      });
+    });
+    nuxt.hook("builder:watch", async (event, relativePath) => {
+      if (!["add", "unlink"].includes(event)) {
+        return;
+      }
+      logger.info(`File added or removed - updating options for ${NAME} module...`);
+      const path2 = resolve(nuxt.options.srcDir, relativePath);
+      const cwaDirs = [userComponentsPath];
+      if (cwaDirs.some((dir) => dir === path2 || path2.startsWith(dir + "/"))) {
+        await updateTemplates({
+          filter: (template) => [
+            "cwa-options.ts"
+          ].includes(template.filename)
+        });
+      }
+    });
+    nuxt.hook("vite:extendConfig", (config) => {
+      logger.info(`Extending Vite optimizeDeps config for ${NAME} module dependencies...`);
+      config.optimizeDeps = config.optimizeDeps || {};
+      config.optimizeDeps.include = config.optimizeDeps.include || [];
+      config.optimizeDeps.exclude = config.optimizeDeps.exclude || [];
+      const optimizeDepPackages = ["slugify", "dayjs"];
+      for (const opPkg of optimizeDepPackages) {
+        const pkgIndex = config.optimizeDeps.exclude.indexOf(opPkg);
+        if (pkgIndex > -1) {
+          config.optimizeDeps.exclude.splice(pkgIndex, 1);
+        }
+        if (!config.optimizeDeps.include.includes(opPkg)) {
+          config.optimizeDeps.include.push(opPkg);
+        }
+      }
+    });
+    logger.success(`Added ${NAME} module successfully.`);
+  }
+});
+
+export { NAME, module as default };

package/dist/runtime/admin/admin.d.ts

@@ -0,0 +1,36 @@
+import { type Emitter } from 'mitt';
+import type { AdminStore } from '../storage/stores/admin/admin-store.js';
+import type { ResourcesStore } from '../storage/stores/resources/resources-store.js';
+import type { Resources } from '../resources/resources.js';
+import ResourceStackManager from './resource-stack-manager.js';
+export type ReorderEvent = {
+    positionIri: string;
+    location: 'previous' | 'next' | number;
+};
+type Events = {
+    redrawFocus: undefined;
+    manageableComponentMounted: string;
+    componentMounted: string;
+    selectResource: string;
+    reorder: ReorderEvent;
+};
+export default class Admin {
+    private readonly adminStoreDefinition;
+    private readonly resourcesStoreDefinition;
+    private readonly stackManagerInstance;
+    private readonly emitter;
+    private throttledRedrawEmitFn;
+    constructor(adminStoreDefinition: AdminStore, resourcesStoreDefinition: ResourcesStore, resources: Resources);
+    get eventBus(): Emitter<Events>;
+    get resourceStackManager(): ResourceStackManager;
+    emptyStack(): void;
+    toggleEdit(editing?: boolean): void;
+    setNavigationGuardDisabled(disabled: boolean): void;
+    get navigationGuardDisabled(): boolean;
+    get isEditing(): boolean;
+    private get adminStore();
+    private redrawListen;
+    emitRedraw(): void;
+    private doEmitRedraw;
+}
+export {};

package/dist/runtime/admin/admin.js

@@ -0,0 +1,65 @@
+import mitt from "mitt";
+import { watch } from "vue";
+import { throttle } from "lodash-es";
+import ResourceStackManager from "./resource-stack-manager.js";
+export default class Admin {
+  constructor(adminStoreDefinition, resourcesStoreDefinition, resources) {
+    this.adminStoreDefinition = adminStoreDefinition;
+    this.resourcesStoreDefinition = resourcesStoreDefinition;
+    this.emitter = mitt();
+    this.stackManagerInstance = new ResourceStackManager(this.adminStoreDefinition, this.resourcesStoreDefinition, resources);
+    this.emitRedraw = this.emitRedraw.bind(this);
+    this.redrawListen();
+  }
+  stackManagerInstance;
+  emitter;
+  throttledRedrawEmitFn;
+  get eventBus() {
+    return this.emitter;
+  }
+  get resourceStackManager() {
+    return this.stackManagerInstance;
+  }
+  emptyStack() {
+    this.resourceStackManager.completeStack({ clickTarget: window }, false);
+    this.resourceStackManager.showManager.value = false;
+  }
+  toggleEdit(editing) {
+    if (editing === false || editing === void 0 && this.isEditing) {
+      this.emptyStack();
+    }
+    this.adminStore.toggleEdit(editing);
+  }
+  setNavigationGuardDisabled(disabled) {
+    this.adminStore.state.navigationGuardDisabled = disabled;
+  }
+  get navigationGuardDisabled() {
+    return this.adminStore.state.navigationGuardDisabled;
+  }
+  get isEditing() {
+    return this.adminStore.state.isEditing;
+  }
+  get adminStore() {
+    return this.adminStoreDefinition.useStore();
+  }
+  redrawListen() {
+    this.eventBus.on("componentMounted", this.emitRedraw);
+    this.eventBus.on("manageableComponentMounted", this.emitRedraw);
+    watch([
+      this.resourceStackManager.showManager,
+      this.resourceStackManager.isEditingLayout
+    ], this.emitRedraw);
+  }
+  emitRedraw() {
+    if (!this.throttledRedrawEmitFn) {
+      this.throttledRedrawEmitFn = throttle(this.doEmitRedraw, 40, {
+        leading: true,
+        trailing: true
+      });
+    }
+    this.throttledRedrawEmitFn();
+  }
+  doEmitRedraw() {
+    this.eventBus.emit("redrawFocus");
+  }
+}

package/dist/runtime/admin/manageable-resource.d.ts

@@ -0,0 +1,41 @@
+import { type ComponentPublicInstance, type Ref } from 'vue';
+import type Cwa from '../cwa.js';
+export type StyleOptions = {
+    multiple?: boolean;
+    classes: {
+        [name: string]: string[];
+    };
+};
+export type ManageableResourceOps = Ref<{
+    styles?: StyleOptions;
+    disabled?: boolean;
+}>;
+export default class ManageableResource {
+    private readonly component;
+    private readonly $cwa;
+    private readonly ops;
+    private currentIri;
+    private domElements;
+    private unwatchCurrentIri;
+    private tabResolver;
+    private isIriInit;
+    constructor(component: ComponentPublicInstance, $cwa: Cwa, ops: ManageableResourceOps);
+    init(iri: Ref<string | undefined>): void;
+    private _initNewIri;
+    initNewIri(): void;
+    clear(soft?: boolean): void;
+    private componentMountedListener;
+    mockChildMounted(): void;
+    private selectResourceListener;
+    private get childIris();
+    private getAllEls;
+    private addClickEventListeners;
+    private triggerClick;
+    private removeClickEventListeners;
+    private clickListener;
+    private getCurrentStackItem;
+    private get currentResource();
+    private get resourceType();
+    private get resourceConfig();
+    private get displayName();
+}

package/dist/runtime/admin/manageable-resource.js

@@ -0,0 +1,206 @@
+import {
+  computed,
+  markRaw,
+  ref,
+  watch
+} from "vue";
+import ManagerTabsResolver from "./manager-tabs-resolver.js";
+export default class ManageableResource {
+  constructor(component, $cwa, ops) {
+    this.component = component;
+    this.$cwa = $cwa;
+    this.ops = ops;
+    this.tabResolver = new ManagerTabsResolver();
+    this.componentMountedListener = this.componentMountedListener.bind(this);
+    this.selectResourceListener = this.selectResourceListener.bind(this);
+    this.clickListener = this.clickListener.bind(this);
+  }
+  currentIri;
+  domElements = ref([]);
+  unwatchCurrentIri;
+  tabResolver;
+  isIriInit = false;
+  // PUBLIC
+  init(iri) {
+    this.clear(false);
+    this.currentIri = iri;
+    this.$cwa.admin.eventBus.on("componentMounted", this.componentMountedListener);
+    this.$cwa.admin.eventBus.on("selectResource", this.selectResourceListener);
+    this.unwatchCurrentIri = watch(this.currentIri, this._initNewIri.bind(this), {
+      immediate: true,
+      flush: "post"
+    });
+  }
+  _initNewIri(iri) {
+    this.clear(true);
+    this.isIriInit = true;
+    if (!iri) {
+      return;
+    }
+    this.addClickEventListeners();
+  }
+  initNewIri() {
+    this._initNewIri(this.currentIri?.value);
+  }
+  clear(soft = false) {
+    if (!this.isIriInit) {
+      return;
+    }
+    this.removeClickEventListeners();
+    this.domElements.value = [];
+    if (!soft) {
+      this.$cwa.admin.eventBus.off("componentMounted", this.componentMountedListener);
+      this.$cwa.admin.eventBus.off("selectResource", this.selectResourceListener);
+      if (this.unwatchCurrentIri) {
+        this.unwatchCurrentIri();
+        this.unwatchCurrentIri = void 0;
+      }
+      if (this.currentIri) {
+        this.currentIri = void 0;
+      }
+    }
+    this.isIriInit = false;
+  }
+  // REFRESHING INITIALISATION
+  componentMountedListener(iri) {
+    const currentIri = this.currentIri?.value;
+    if (!currentIri || this.currentIri?.value === iri) {
+      return;
+    }
+    const childIris = this.childIris.value;
+    const iris = [];
+    if (iri.endsWith("_placeholder")) {
+      iris.push(iri);
+      iris.push(...this.$cwa.resources.findAllPublishableIris(iri.replace("_placeholder", "")));
+    } else {
+      iris.push(...this.$cwa.resources.findAllPublishableIris(iri));
+    }
+    const iriIsChild = () => {
+      for (const iri2 of iris) {
+        if (childIris.includes(iri2)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    const isNewlyMountedIriAChild = iriIsChild();
+    if (isNewlyMountedIriAChild) {
+      this.removeClickEventListeners();
+      this.addClickEventListeners();
+      this.$cwa.admin.eventBus.emit("componentMounted", currentIri);
+    }
+  }
+  mockChildMounted() {
+    const currentIri = this.currentIri?.value;
+    this.removeClickEventListeners();
+    this.addClickEventListeners();
+    if (currentIri) this.$cwa.admin.eventBus.emit("componentMounted", currentIri);
+  }
+  selectResourceListener(iri) {
+    if (iri === this.currentIri?.value) {
+      this.triggerClick();
+    }
+  }
+  get childIris() {
+    return computed(() => {
+      if (!this.currentIri?.value) {
+        return [];
+      }
+      const addResourceEvent = this.$cwa.resourcesManager.addResourceEvent.value;
+      return this.$cwa.resources.getChildIris(this.currentIri?.value, addResourceEvent);
+    });
+  }
+  // GET DOM ELEMENTS TO ADD CLICK EVENTS TO
+  getAllEls() {
+    const allSiblings = [];
+    let currentEl = this.component.$el;
+    if (!currentEl) {
+      return [];
+    }
+    if (currentEl.nodeType === Node.ELEMENT_NODE) {
+      return [currentEl];
+    }
+    let startTagCount = 0;
+    do {
+      if (currentEl.nodeType === Node.COMMENT_NODE) {
+        const nodeValue = currentEl.nodeValue.trim();
+        if (startTagCount && nodeValue === "cwa-end") {
+          startTagCount--;
+          if (startTagCount === 0) {
+            break;
+          }
+        }
+        if (nodeValue === "cwa-start") {
+          startTagCount++;
+        }
+        continue;
+      }
+      currentEl.nodeType === Node.ELEMENT_NODE && startTagCount && allSiblings.push(currentEl);
+    } while (currentEl = currentEl.nextSibling);
+    return allSiblings;
+  }
+  addClickEventListeners() {
+    this.domElements.value = this.getAllEls();
+    for (const el of this.domElements.value) {
+      el.addEventListener("click", this.clickListener, false);
+      el.addEventListener("contextmenu", this.clickListener, false);
+    }
+  }
+  triggerClick() {
+    const firstDomElement = this.domElements.value[0];
+    const clickEvent = new Event("click", { bubbles: true });
+    firstDomElement.dispatchEvent(clickEvent);
+  }
+  removeClickEventListeners() {
+    for (const el of this.domElements.value) {
+      el.removeEventListener("click", this.clickListener);
+      el.removeEventListener("contextmenu", this.clickListener);
+    }
+  }
+  // This will be called by the click event listener in context of this, and can be removed as well.
+  // if we define with a name and call that, the `this` context will be the clicked dom element
+  clickListener(evt) {
+    if (!this.currentIri?.value || !this.currentResource || this.ops.value.disabled === true) {
+      return;
+    }
+    this.$cwa.admin.resourceStackManager.addToStack(this.getCurrentStackItem(evt.target), evt.type === "contextmenu", this.ops);
+  }
+  getCurrentStackItem(clickTarget) {
+    if (!this.currentResource || !this.currentIri?.value) {
+      throw new Error("Cannot get a currentStackItem when currentResource or currentIri is not defined");
+    }
+    return {
+      iri: this.currentIri.value,
+      domElements: this.domElements,
+      clickTarget,
+      displayName: this.displayName,
+      managerTabs: markRaw(this.tabResolver.resolve({ resourceType: this.resourceType, resourceConfig: this.resourceConfig, resource: this.currentResource })),
+      ui: this.resourceConfig?.ui,
+      styles: computed(() => this.ops.value.styles),
+      childIris: this.childIris
+    };
+  }
+  get currentResource() {
+    return this.currentIri?.value ? this.$cwa.resources.getResource(this.currentIri.value)?.value : void 0;
+  }
+  get resourceType() {
+    const currentResource = this.currentResource;
+    if (!currentResource) {
+      return;
+    }
+    return currentResource.data?.["@type"];
+  }
+  get resourceConfig() {
+    const currentResource = this.currentResource;
+    if (!currentResource) {
+      return;
+    }
+    if (!this.$cwa.resourcesConfig || !this.resourceType) {
+      return;
+    }
+    return this.$cwa.resourcesConfig[this.resourceType];
+  }
+  get displayName() {
+    return this.resourceConfig?.name || this.resourceType;
+  }
+}

package/dist/runtime/admin/manager-tabs-resolver.d.ts

@@ -0,0 +1,17 @@
+import type { CwaResourceMeta, ManagerTab } from '#cwa/module';
+import type { CwaCurrentResourceInterface } from '#cwa/runtime/storage/stores/resources/state';
+export declare const DEFAULT_TAB_ORDER = 50;
+interface resolveTabsOps {
+    resourceType?: string;
+    resourceConfig?: CwaResourceMeta;
+    resource: CwaCurrentResourceInterface;
+}
+export default class ManagerTabsResolver {
+    private cwa;
+    constructor();
+    private getComponentGroupTabs;
+    private getComponentPositionTabs;
+    private getComponentTabs;
+    resolve(ops: resolveTabsOps): ManagerTab[];
+}
+export {};

package/dist/runtime/admin/manager-tabs-resolver.js

@@ -0,0 +1,51 @@
+import { defineAsyncComponent } from "vue";
+import { getPublishedResourceState } from "#cwa/runtime/resources/resource-utils";
+import { useCwa } from "#imports";
+export const DEFAULT_TAB_ORDER = 50;
+export default class ManagerTabsResolver {
+  cwa;
+  constructor() {
+    this.cwa = useCwa();
+  }
+  *getComponentGroupTabs() {
+    yield defineAsyncComponent(() => import("#cwa/runtime/templates/components/main/admin/resource-manager/_tabs/group/Group.vue"));
+  }
+  *getComponentPositionTabs() {
+    if (this.cwa.resources.isDataPage.value) {
+      yield defineAsyncComponent(() => import("#cwa/runtime/templates/components/main/admin/resource-manager/_tabs/position/DataPage.vue"));
+      return;
+    }
+    if (this.cwa.resources.isDynamicPage.value) {
+      yield defineAsyncComponent(() => import("#cwa/runtime/templates/components/main/admin/resource-manager/_tabs/position/DynamicPage.vue"));
+    }
+  }
+  *getComponentTabs(resource) {
+    yield defineAsyncComponent(() => import("#cwa/runtime/templates/components/main/admin/resource-manager/_tabs/component/Ui.vue"));
+    yield defineAsyncComponent(() => import("#cwa/runtime/templates/components/main/admin/resource-manager/_tabs/component/Order.vue"));
+    if (getPublishedResourceState(resource) !== void 0) {
+      yield defineAsyncComponent(() => import("#cwa/runtime/templates/components/main/admin/resource-manager/_tabs/component/Publish.vue"));
+    }
+  }
+  resolve(ops) {
+    let tabs = [
+      defineAsyncComponent(() => import("#cwa/runtime/templates/components/main/admin/resource-manager/_tabs/ResourceInfoTab.vue"))
+    ];
+    if (ops.resourceConfig?.managerTabs) {
+      tabs = [...tabs, ...ops.resourceConfig.managerTabs];
+    }
+    if (ops.resourceType) {
+      switch (ops.resourceType) {
+        case "ComponentGroup":
+          tabs = [...tabs, ...this.getComponentGroupTabs()];
+          break;
+        case "ComponentPosition":
+          tabs = [...tabs, ...this.getComponentPositionTabs()];
+          break;
+        default:
+          tabs = [...tabs, ...this.getComponentTabs(ops.resource)];
+          break;
+      }
+    }
+    return tabs;
+  }
+}

package/dist/runtime/admin/navigation-guard.d.ts

@@ -0,0 +1,18 @@
+import type { RouteLocationNormalized, Router } from 'vue-router';
+import type { AdminStore } from '../storage/stores/admin/admin-store.js';
+export default class NavigationGuard {
+    private router;
+    private adminStoreDefinition;
+    private programmatic;
+    constructor(router: Router, adminStoreDefinition: AdminStore);
+    private extendRouteMethods;
+    private isRouteForcedNavigation;
+    private allowNavigation;
+    get navigationDisabled(): boolean;
+    get adminNavigationGuardFn(): (toRoute: RouteLocationNormalized) => boolean | {
+        path: string;
+        query: import("vue-router").LocationQuery;
+        hash: string;
+    };
+    private get adminStore();
+}