strapi-plugin-navigation 3.0.0-beta.0 → 3.0.0-beta.2

package/dist/server/src/index.d.ts

@@ -0,0 +1,582 @@
+declare const _default: {
+    bootstrap: (context: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => Promise<void>;
+    destroy: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    register: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    config: {
+        default: {
+            additionalFields: never[];
+            allowedLevels: number;
+            contentTypes: never[];
+            contentTypesNameFields: {};
+            contentTypesPopulate: {};
+            gql: {
+                navigationItemRelated: never[];
+            };
+            i18nEnabled: boolean;
+            pathDefaultFields: {};
+            pruneObsoleteI18nNavigations: boolean;
+            cascadeMenuAttached: boolean;
+            preferCustomContentTypes: boolean;
+            isCacheEnabled: boolean;
+        };
+    };
+    controllers: {
+        admin: typeof import("./controllers/admin").default;
+        client: typeof import("./controllers/client").default;
+    };
+    contentTypes: {
+        audience: {
+            schema: {
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    name: string;
+                };
+                options: {
+                    increments: boolean;
+                    comment: string;
+                };
+                attributes: {
+                    name: {
+                        type: string;
+                        required: boolean;
+                    };
+                    key: {
+                        type: string;
+                        targetField: string;
+                    };
+                };
+            };
+        };
+        navigation: {
+            schema: {
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    name: string;
+                };
+                options: {
+                    comment: string;
+                };
+                pluginOptions: {
+                    'content-manager': {
+                        visible: boolean;
+                    };
+                    'content-type-builder': {
+                        visible: boolean;
+                    };
+                    i18n: {
+                        localized: boolean;
+                    };
+                };
+                attributes: {
+                    name: {
+                        type: string;
+                        configurable: boolean;
+                        required: boolean;
+                    };
+                    slug: {
+                        type: string;
+                        target: string;
+                        configurable: boolean;
+                        required: boolean;
+                    };
+                    visible: {
+                        type: string;
+                        default: boolean;
+                        configurable: boolean;
+                    };
+                    items: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        configurable: boolean;
+                        mappedBy: string;
+                    };
+                    localeCode: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                };
+            };
+            lifecycles: Record<string, import("./types").Effect<import("./types").LifeCycleEvent<import("./types").LifeCycleHookName, unknown, Record<string, unknown>>>>;
+        };
+        'navigation-item': {
+            schema: {
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string; /**
+                     * Plugin server methods
+                     */
+                    displayName: string;
+                    name: string;
+                };
+                options: {
+                    increments: boolean;
+                    timestamps: boolean;
+                    comment: string;
+                };
+                pluginOptions: {
+                    'content-manager': {
+                        visible: boolean;
+                    };
+                    'content-type-builder': {
+                        visible: boolean;
+                    };
+                    i18n: {
+                        localized: boolean;
+                    };
+                };
+                attributes: {
+                    title: {
+                        type: string;
+                        configurable: boolean;
+                        required: boolean;
+                        pluginOptions: {
+                            i18n: {
+                                localized: boolean;
+                            };
+                        };
+                    };
+                    type: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                        configurable: boolean;
+                    };
+                    path: {
+                        type: string;
+                        targetField: string;
+                        configurable: boolean;
+                    };
+                    externalPath: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    uiRouterKey: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    menuAttached: {
+                        type: string;
+                        default: boolean;
+                        configurable: boolean;
+                    };
+                    order: {
+                        type: string;
+                        default: number;
+                        configurable: boolean;
+                    };
+                    collapsed: {
+                        type: string;
+                        default: boolean;
+                        configurable: boolean;
+                    };
+                    autoSync: {
+                        type: string;
+                        default: boolean;
+                        configurable: boolean;
+                    };
+                    related: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    parent: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        configurable: boolean;
+                        default: null;
+                    };
+                    master: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        configurable: boolean;
+                        inversedBy: string;
+                    };
+                    audience: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                    };
+                    additionalFields: {
+                        type: string;
+                        require: boolean;
+                        default: {};
+                    };
+                };
+            };
+            lifecycles: Record<string, import("./types").Effect<import("./types").LifeCycleEvent<import("./types").LifeCycleHookName, unknown, Record<string, unknown>>>>;
+        };
+    };
+    middlewares: {};
+    policies: {};
+    routes: {
+        admin: {
+            type: string;
+            routes: ({
+                method: string;
+                path: string; /**
+                 * Plugin server methods
+                 */
+                handler: string;
+                config: {
+                    policies: {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    }[];
+                };
+            } | {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: string[];
+                };
+            })[];
+        };
+        'content-api': {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: never[];
+                };
+            }[];
+        };
+    };
+    services: {
+        admin: (context: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            config({ viaSettingsPage }: import("./services/admin/types").ConfigInput): Promise<import("./dtos").NavigationPluginConfigDTO>;
+            configContentTypes({ viaSettingsPage, }: import("./services/admin/types").ConfigInput): Promise<import("./dtos").ConfigContentTypeDTO[]>;
+            get({ ids, localeCode }: import("./services/admin/types").GetInput): Promise<{
+                name: string;
+                id: number;
+                documentId: string;
+                slug: string;
+                localeCode: string;
+                visible: boolean;
+                items?: import("./schemas").NavigationItemDBSchema[] | undefined;
+            }[]>;
+            getById({ documentId, localeCode }: import("./services/admin/types").GetByIdInput): Promise<{
+                name: string;
+                id: number;
+                documentId: string;
+                slug: string;
+                localeCode: string;
+                visible: boolean;
+                items?: import("./schemas").NavigationItemDBSchema[] | undefined;
+            }>;
+            post({ auditLog, payload }: import("./services/admin/types").PostInput): Promise<import("./dtos").NavigationDTO>;
+            put({ auditLog, payload }: import("./services/admin/types").PutInput): Promise<{
+                name: string;
+                id: number;
+                documentId: string;
+                slug: string;
+                localeCode: string;
+                visible: boolean;
+                items?: import("./schemas").NavigationItemDBSchema[] | undefined;
+            }>;
+            delete({ auditLog, documentId }: import("./services/admin/types").DeleteInput): Promise<void>;
+            restart(): Promise<void>;
+            restoreConfig(): Promise<void>;
+            updateConfig({ config: newConfig }: import("./services/admin/types").UpdateConfigInput): Promise<void>;
+            fillFromOtherLocale({ auditLog, source, target, documentId, }: import("./services/admin/types").FillFromOtherLocaleInput): Promise<{
+                name: string;
+                id: number;
+                documentId: string;
+                slug: string;
+                localeCode: string;
+                visible: boolean;
+                items?: import("./schemas").NavigationItemDBSchema[] | undefined;
+            }>;
+            i18nNavigationContentsCopy({ source, target, }: import("./services/admin/types").I18nNavigationContentsCopyInput): Promise<void>;
+            readNavigationItemFromLocale({ path, source, target, }: import("./services/admin/types").ReadNavigationItemFromLocaleInput): Promise<{
+                type: "INTERNAL" | "EXTERNAL" | "WRAPPER";
+                title: string;
+                uiRouterKey: string;
+                path?: string | null | undefined;
+                externalPath?: string | null | undefined;
+                related?: unknown;
+            }>;
+            getContentTypeItems({ query, uid, }: import("./services/admin/types").GetContentTypeItemsInput): Promise<{
+                documentId: string;
+            }[]>;
+            purgeNavigationCache(documentId: string, clearLocalisations?: boolean | undefined): Promise<{
+                success: boolean;
+            }>;
+            purgeNavigationsCache(): Promise<{
+                success: boolean;
+            }>;
+        };
+        common: (context: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            getPluginStore(): Promise<{
+                get(params?: Partial<{
+                    key: string;
+                    type?: string | undefined;
+                    environment?: string | undefined;
+                    name?: string | undefined;
+                    tag?: string | undefined;
+                }> | undefined): Promise<unknown>;
+                set(params?: Partial<{
+                    key: string;
+                    value: unknown;
+                    type?: string | undefined;
+                    environment?: string | undefined;
+                    name?: string | undefined;
+                    tag?: string | undefined; /**
+                     * Plugin server methods
+                     */
+                }> | undefined): Promise<void>;
+                delete(params?: Partial<{
+                    key: string;
+                    type?: string | undefined;
+                    environment?: string | undefined;
+                    name?: string | undefined;
+                    tag?: string | undefined;
+                }> | undefined): Promise<void>;
+            }>;
+            mapToNavigationItemDTO({ navigationItems, populate, master, parent, }: import("./services/common/types").MapToNavigationItemDTOInput): Promise<import("./dtos").NavigationItemDTO[]>;
+            setDefaultConfig(): Promise<{
+                additionalFields: ("audience" | {
+                    type: "string" | "boolean";
+                    name: string;
+                    label: string;
+                    options?: string[] | undefined;
+                    required?: boolean | undefined;
+                    enabled?: boolean | undefined;
+                    multi?: false | undefined;
+                } | {
+                    type: "media";
+                    name: string;
+                    label: string;
+                    options?: string[] | undefined;
+                    required?: boolean | undefined;
+                    enabled?: boolean | undefined;
+                    multi?: false | undefined;
+                } | {
+                    options: string[];
+                    type: "select";
+                    name: string;
+                    label: string;
+                    multi: boolean;
+                    required?: boolean | undefined;
+                    enabled?: boolean | undefined;
+                })[];
+                allowedLevels: number;
+                contentTypes: string[];
+                contentTypesNameFields: Record<string, string[]>;
+                contentTypesPopulate: Record<string, string[]>;
+                gql: {
+                    navigationItemRelated: string[];
+                };
+                pathDefaultFields: Record<string, any>;
+                cascadeMenuAttached: boolean;
+                preferCustomContentTypes: boolean;
+                isCacheEnabled?: boolean | undefined;
+            }>;
+            getBranchName({ item }: import("./services/common/types").GetBranchNameInput): void | import("./types").NavigationActionsCategories;
+            analyzeBranch({ masterEntity, navigationItems, parentItem, prevAction, }: import("./services/common/types").AnalyzeBranchInput): Promise<import("./types").NavigationAction[]>;
+            removeBranch({ navigationItems, action, }: import("./services/common/types").RemoveBranchInput): Promise<import("./types").NavigationAction[]>;
+            createBranch({ action, masterEntity, navigationItems, parentItem, }: import("./services/common/types").CreateBranchInput): Promise<import("./types").NavigationAction[]>;
+            updateBranch({ masterEntity, navigationItems, action, parentItem, }: import("./services/common/types").UpdateBranchInput): Promise<import("./types").NavigationAction[]>;
+            emitEvent({ entity, event, uid }: import("./services/common/types").EmitEventInput<any, any>): Promise<void>;
+            pruneCustomFields({ removedFields }: {
+                removedFields: ({
+                    type: "string" | "boolean";
+                    name: string;
+                    label: string;
+                    options?: string[] | undefined;
+                    required?: boolean | undefined;
+                    enabled?: boolean | undefined;
+                    multi?: false | undefined;
+                } | {
+                    type: "media";
+                    name: string;
+                    label: string;
+                    options?: string[] | undefined;
+                    required?: boolean | undefined;
+                    enabled?: boolean | undefined;
+                    multi?: false | undefined;
+                } | {
+                    options: string[];
+                    type: "select";
+                    name: string;
+                    label: string;
+                    multi: boolean;
+                    required?: boolean | undefined;
+                    enabled?: boolean | undefined;
+                })[];
+            }): Promise<void>;
+            getSlug({ query }: import("./services/common/types").GetSlugInput): Promise<string>;
+            registerLifeCycleHook({ callback, contentTypeName, hookName }: import("./services/common/types").RegisterLifeCycleHookInput): void;
+            runLifeCycleHook({ contentTypeName, event, hookName }: import("./services/common/types").RunLifeCycleHookInput): Promise<void>;
+            buildNestedStructure({ navigationItems, id, }: import("./services/common/types").BuildNestedStructureInput): import("./schemas").NavigationItemDBSchema[];
+            readLocale(): Promise<{
+                defaultLocale: string;
+                restLocale: string[];
+            }>;
+        };
+        client: (context: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            readAll({ locale, orderBy, orderDirection }: import("./services/client/types").ReadAllInput): Promise<{
+                name: string;
+                id: number;
+                documentId: string;
+                slug: string;
+                localeCode: string;
+                visible: boolean;
+                items?: import("./schemas").NavigationItemDBSchema[] | undefined;
+            }[]>;
+            renderRFRNavigationItem({ item }: import("./services/client/types").RenderRFRNavInput): import("./dtos").RFRNavigationItemDTO;
+            renderRFRPage({ item, parent, enabledCustomFieldsNames }: import("./services/client/types").RenderRFRPageInput): import("./dtos").RFRPageDTO;
+            renderRFR({ items, parent, parentNavItem, contentTypes, enabledCustomFieldsNames, }: import("./services/client/types").RenderRFRInput): {
+                pages: {};
+                nav: {};
+            };
+            renderTree({ items, documentId, path, itemParser, }: import("./services/client/types").RenderTreeInput): Promise<import("./dtos").NavigationItemDTO[]>;
+            getCustomFields(additionalFields: ("audience" | {
+                type: "string" | "boolean";
+                name: string;
+                label: string;
+                options?: string[] | undefined;
+                required?: boolean | undefined;
+                enabled?: boolean | undefined;
+                multi?: false | undefined;
+            } | {
+                type: "media";
+                name: string;
+                label: string;
+                options?: string[] | undefined;
+                required?: boolean | undefined;
+                enabled?: boolean | undefined;
+                multi?: false | undefined;
+            } | {
+                options: string[];
+                type: "select";
+                name: string;
+                label: string;
+                multi: boolean;
+                required?: boolean | undefined;
+                enabled?: boolean | undefined;
+            })[]): ({
+                type: "string" | "boolean";
+                name: string;
+                label: string;
+                options?: string[] | undefined;
+                required?: boolean | undefined;
+                enabled?: boolean | undefined;
+                multi?: false | undefined;
+            } | {
+                type: "media";
+                name: string;
+                label: string;
+                options?: string[] | undefined;
+                required?: boolean | undefined;
+                enabled?: boolean | undefined;
+                multi?: false | undefined;
+            } | {
+                options: string[];
+                type: "select";
+                name: string;
+                label: string;
+                multi: boolean;
+                required?: boolean | undefined;
+                enabled?: boolean | undefined;
+            })[];
+            renderType({ criteria, filter, itemCriteria, locale, populate, rootPath, type, wrapRelated, }: import("./services/client/types").RenderTypeInput): Promise<import("./dtos").NavigationItemDTO[] | {
+                pages: {};
+                nav: {};
+            } | {
+                audience: string[] | undefined;
+                title: string;
+                related: any;
+                items: null;
+                path?: string | null | undefined;
+                type: "INTERNAL" | "EXTERNAL" | "WRAPPER";
+                id: number;
+                documentId: string;
+                slug?: string | null | undefined;
+                externalPath?: string | null | undefined;
+                uiRouterKey: string;
+                menuAttached: boolean;
+                order: number;
+                collapsed: boolean;
+                autoSync?: boolean | null | undefined;
+                master?: import("./dtos").NavigationDTO | undefined;
+                parent?: import("./dtos").NavigationItemDTO | null | undefined;
+            }[]>;
+            renderChildren({ childUIKey, idOrSlug, locale, menuOnly, type, wrapRelated, }: import("./services/client/types").RenderChildrenInput): Promise<import("./dtos").NavigationItemDTO[] | {
+                pages: {};
+                nav: {};
+            } | {
+                audience: string[] | undefined;
+                title: string;
+                related: any;
+                items: null;
+                path?: string | null | undefined;
+                type: "INTERNAL" | "EXTERNAL" | "WRAPPER";
+                id: number;
+                documentId: string;
+                slug?: string | null | undefined;
+                externalPath?: string | null | undefined;
+                uiRouterKey: string;
+                menuAttached: boolean;
+                order: number;
+                collapsed: boolean;
+                autoSync?: boolean | null | undefined;
+                master?: import("./dtos").NavigationDTO | undefined;
+                parent?: import("./dtos").NavigationItemDTO | null | undefined;
+            }[]>;
+            render({ idOrSlug, locale, menuOnly, populate, rootPath, type, wrapRelated, }: import("./services/client/types").RenderInput): Promise<import("./dtos").NavigationItemDTO[] | {
+                pages: {};
+                nav: {};
+            } | {
+                audience: string[] | undefined;
+                title: string;
+                related: any;
+                items: null;
+                path?: string | null | undefined;
+                type: "INTERNAL" | "EXTERNAL" | "WRAPPER";
+                id: number;
+                documentId: string;
+                slug?: string | null | undefined;
+                externalPath?: string | null | undefined;
+                uiRouterKey: string;
+                menuAttached: boolean;
+                order: number;
+                collapsed: boolean;
+                autoSync?: boolean | null | undefined;
+                master?: import("./dtos").NavigationDTO | undefined;
+                parent?: import("./dtos").NavigationItemDTO | null | undefined;
+            }[]>;
+        };
+        migrate: (context: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            migrateRelatedIdToDocumentId(): Promise<void>;
+        };
+    };
+};
+export default _default;

package/dist/server/src/middlewares/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/server/src/permissions/index.d.ts

@@ -0,0 +1,3 @@
+import permissions from './permissions';
+export { setupPermissions } from './setup';
+export default permissions;

package/dist/server/src/permissions/permissions.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    render: (uid: string) => string;
+    navigation: {
+        read: string;
+        update: string;
+        settings: string;
+    };
+};
+export default _default;

package/dist/server/src/permissions/setup.d.ts

@@ -0,0 +1,4 @@
+import { Core } from '@strapi/strapi';
+export declare const setupPermissions: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => Promise<void>;

package/dist/server/src/permissions.d.ts

@@ -0,0 +1,13 @@
+import { Core } from '@strapi/strapi';
+declare const permissions: {
+    render: (uid: string) => string;
+    navigation: {
+        read: string;
+        update: string;
+        settings: string;
+    };
+};
+export declare const setupPermissions: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => Promise<void>;
+export default permissions;

package/dist/server/src/policies/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/server/src/register.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/types';
+declare const register: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default register;

package/dist/server/src/repositories/audience.d.ts

@@ -0,0 +1,11 @@
+import { Core } from '@strapi/strapi';
+export declare const getAudienceRepository: (context: {
+    strapi: Core.Strapi;
+}) => {
+    find(where: Record<string, unknown>, limit?: number): Promise<{
+        name: string;
+        id: number;
+        documentId: string;
+        key: string;
+    }[]>;
+};

package/dist/server/src/repositories/generic.d.ts

@@ -0,0 +1,23 @@
+import { Core, UID } from '@strapi/strapi';
+type PublicationStatus = 'published' | 'draft';
+export declare const getGenericRepository: (context: {
+    strapi: Core.Strapi;
+}, uid: UID.ContentType) => {
+    findById(documentId: string, populate: any, status?: PublicationStatus, extra?: any): import("@strapi/types/dist/modules/documents/result/document-engine").FindOne<UID.ContentType, any>;
+    findManyById(documentIds: string[], populate: any, status?: PublicationStatus): import("@strapi/types/dist/modules/documents/result/document-engine").FindMany<UID.ContentType, {
+        readonly where: {
+            readonly documentId: {
+                readonly $in: string[];
+            };
+        };
+        readonly populate: any;
+        readonly status: PublicationStatus | undefined;
+    }>;
+    findMany(where: any, populate: any, status?: PublicationStatus): import("@strapi/types/dist/modules/documents/result/document-engine").FindMany<UID.ContentType, {
+        readonly where: any;
+        readonly populate: any;
+        readonly status: PublicationStatus | undefined;
+    }>;
+    count(where: Record<string, any>, status?: PublicationStatus): import("@strapi/types/dist/modules/documents/result/document-engine").Count;
+};
+export {};

package/dist/server/src/repositories/index.d.ts

@@ -0,0 +1,4 @@
+export { getAudienceRepository } from './audience';
+export { getGenericRepository } from './generic';
+export { getNavigationItemRepository } from './navigation-item';
+export { getNavigationRepository } from './navigation';