@cwa/nuxt-edge 0.0.0-29696494.72f11a4

package/dist/module.mjs

@@ -0,0 +1,292 @@
+import { join } from 'path';
+import path from 'node:path';
+import { readFileSync, statSync } from 'node:fs';
+import mergeWith from 'lodash-es/mergeWith';
+import isArray from 'lodash-es/isArray';
+import { defineNuxtModule, useLogger, createResolver, extendRouteRules, addImportsDir, extendPages, addTemplate, addTypeTemplate, addPlugin, addServerTemplate, addServerHandler, addServerPlugin, updateTemplates, resolveAlias } from '@nuxt/kit';
+import { defaultSiteConfig } from '../dist/runtime/composables/useCwaSiteConfig.js';
+
+function createDefaultCwaPages(pages, pageComponentFilePath, maxDepth, layout) {
+  function getPage(currentDepth) {
+    return {
+      name: `cwaPage${currentDepth}`,
+      path: currentDepth === 0 ? "/" : `:cwaPage${currentDepth}`,
+      file: pageComponentFilePath,
+      meta: {
+        cwa: {
+          disabled: false
+        },
+        layout: layout || "cwa-root-layout"
+      },
+      children: []
+    };
+  }
+  function createTree(currentDepth) {
+    const page = getPage(currentDepth);
+    if (currentDepth < maxDepth) {
+      const child = createTree(++currentDepth);
+      page.children = [child];
+    }
+    return page;
+  }
+  pages.push(createTree(0));
+}
+const NAME = "@cwa/nuxt";
+const module$1 = defineNuxtModule({
+  moduleDependencies: {
+    "@pinia/nuxt": {
+      version: "^0.11.3",
+      optional: false
+    },
+    "@nuxtjs/robots": {
+      version: "^6.0"
+    },
+    "@nuxtjs/sitemap": {
+      version: "^8.0",
+      optional: false,
+      defaults: {
+        sitemaps: {
+          cwa: {
+            sources: ["/__sitemap__/cwa-urls"],
+            chunks: true
+          }
+        }
+      }
+    },
+    "nuxt-link-checker": {
+      version: "^5.0"
+    },
+    "nuxt-schema-org": {
+      version: "^6.0"
+    },
+    "nuxt-seo-utils": {
+      version: "^8.1"
+    },
+    "nuxt-site-config": {
+      version: "^4.0.8"
+    }
+  },
+  meta: {
+    name: NAME,
+    configKey: "cwa",
+    compatibility: {
+      nuxt: ">=3.16"
+    }
+  },
+  defaults: {
+    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"
+      }
+    },
+    siteConfig: defaultSiteConfig
+  },
+  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})...`);
+    nuxt.options.alias["#cwa"] = resolve("./runtime");
+    nuxt.options.alias["#cwa-layer"] = resolve("./layer");
+    const appDir = resolve(`${nuxt.options.dir.app}`);
+    extendRouteRules("/_cwa/**", { ssr: false, robots: false });
+    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 || 4, options.layoutName);
+    });
+    const cwaVueComponentsDir = join(vueTemplatesDir, "components");
+    logger.info(`Registering user components for CWA...`);
+    const userComponentsPath = join(appDir, "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/types';
+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
+  fetch?: {
+    iri: string
+    manifestPath?: string
+  }
+}
+export * from 'vue-router'
+declare module 'vue-router' {
+  interface RouteMeta {
+    cwa?: CwaRouteMeta
+  }
+}`
+        )
+      });
+      addPlugin({
+        src: resolve("./runtime/plugin")
+      });
+      addServerTemplate({
+        filename: "#cwa/server-options.ts",
+        getContents: () => {
+          const serverOps = {
+            siteConfig: options.siteConfig
+          };
+          return `export const options = ${JSON.stringify(serverOps, void 0, 2)}
+`;
+        }
+      });
+      addServerHandler({
+        handler: resolve("./runtime/server/server-middleware")
+      });
+      addServerPlugin(resolve("./runtime/server/server-plugin"));
+      addServerHandler({
+        route: "/__sitemap__/cwa-urls",
+        handler: resolve("./runtime/server/cwa-urls.get")
+      });
+      addServerHandler({
+        route: "/__sitemap__/cwa-custom.xml",
+        handler: resolve("./runtime/server/cwa-custom-sitemap.get")
+      });
+      addServerHandler({
+        route: "/_cwa/healthcheck",
+        handler: resolve("./runtime/server/cwa-healthcheck.get")
+      });
+    });
+    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(appDir, "cwa", "layouts"),
+        prefix: "CwaLayout",
+        global: true,
+        ignore: ["**/*.spec.{cts,mts,ts}"]
+      });
+      dirs.unshift({
+        path: join(appDir, "cwa", "pages"),
+        prefix: "CwaPage",
+        global: true,
+        ignore: ["**/admin/*", "**/*.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(appDir, relativePath);
+      const cwaDirs = [userComponentsPath];
+      if (cwaDirs.some((dir) => dir === path2 || path2.startsWith(dir + "/"))) {
+        await updateTemplates({
+          filter: (template) => [
+            "cwa-options.ts",
+            "#cwa/server-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", "cookie", "set-cookie-parser"];
+      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$1 as default };

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

@@ -0,0 +1,35 @@
+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 stackManagerInstance;
+    private readonly emitter;
+    private throttledRedrawEmitFn;
+    private readonly _adminStore;
+    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/throttle";
+import ResourceStackManager from "./resource-stack-manager.js";
+export default class Admin {
+  stackManagerInstance;
+  emitter;
+  throttledRedrawEmitFn;
+  _adminStore;
+  constructor(adminStoreDefinition, resourcesStoreDefinition, resources) {
+    this.emitter = mitt();
+    this.stackManagerInstance = new ResourceStackManager(adminStoreDefinition, resourcesStoreDefinition, resources);
+    this.emitRedraw = this.emitRedraw.bind(this);
+    this.redrawListen();
+    this._adminStore = adminStoreDefinition.useStore();
+  }
+  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._adminStore;
+  }
+  redrawListen() {
+    this.eventBus.on("componentMounted", this.emitRedraw);
+    this.eventBus.on("manageableComponentMounted", this.emitRedraw);
+    watch(() => [
+      this.resourceStackManager.showManager.value,
+      this.resourceStackManager.isEditingLayout.value
+    ], 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,42 @@
+import type { ComponentPublicInstance, 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;
+    private pendingChildMountedReInit;
+    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,241 @@
+import { CwaResourceTypes, getResourceTypeFromIri } from "#cwa/resources/resource-utils";
+import { NEW_RESOURCE_IRI } from "#cwa/storage/stores/resources/state";
+import { watchOnce } from "@vueuse/core";
+import { consola } from "consola";
+import {
+  computed,
+  markRaw,
+  nextTick,
+  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);
+  }
+  component;
+  $cwa;
+  ops;
+  currentIri;
+  domElements = ref([]);
+  unwatchCurrentIri;
+  tabResolver;
+  isIriInit = false;
+  pendingChildMountedReInit = 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;
+    }
+    if (this.pendingChildMountedReInit) {
+      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 isChild = iris.some((i) => childIris.includes(i));
+    if (isChild) {
+      this.pendingChildMountedReInit = true;
+      this.$cwa.admin.eventBus.emit("componentMounted", currentIri);
+      void nextTick(() => {
+        this.pendingChildMountedReInit = false;
+        if (!this.currentIri?.value || !this.isIriInit) {
+          return;
+        }
+        this.removeClickEventListeners();
+        this.addClickEventListeners();
+      });
+    }
+  }
+  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);
+    }
+  }
+  async triggerClick() {
+    await new Promise((resolve) => {
+      if (this.domElements.value.length) {
+        resolve();
+        return;
+      }
+      const timeout = setTimeout(() => {
+        stopWatch();
+        clearTimeout(timeout);
+      }, 1e3);
+      const stopWatch = watchOnce(this.domElements, (newDomEls) => {
+        if (newDomEls.length) {
+          resolve();
+          clearTimeout(timeout);
+        }
+      });
+    });
+    const firstDomElement = this.domElements.value[0];
+    if (!firstDomElement) {
+      consola.error("Manageable resource listener called to select component, but no dom elements found.", this.currentIri?.value);
+      return;
+    }
+    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: getResourceTypeFromIri(this.currentIri.value) ?? (this.currentIri.value === NEW_RESOURCE_IRI ? CwaResourceTypes.COMPONENT : void 0),
+        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/types';
+import type { CwaCurrentResourceInterface } from '#cwa/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 {};