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

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

@@ -0,0 +1,3 @@
+export * from './config';
+export * from './content-type';
+export * from './navigation';

package/dist/server/src/schemas/navigation.d.ts

@@ -0,0 +1,237 @@
+import * as z from 'zod';
+export type AudienceDBSchema = z.infer<typeof audienceDBSchema>;
+export declare const audienceDBSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    documentId: z.ZodString;
+    name: z.ZodString;
+    key: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: number;
+    documentId: string;
+    key: string;
+}, {
+    name: string;
+    id: number;
+    documentId: string;
+    key: string;
+}>;
+export type NavigationItemType = z.infer<typeof navigationItemType>;
+export declare const navigationItemType: z.ZodEnum<["INTERNAL", "EXTERNAL", "WRAPPER"]>;
+declare const navigationItemDBBaseSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    documentId: z.ZodString;
+    title: z.ZodString;
+    type: z.ZodEnum<["INTERNAL", "EXTERNAL", "WRAPPER"]>;
+    path: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    slug: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    externalPath: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    uiRouterKey: z.ZodString;
+    menuAttached: z.ZodBoolean;
+    order: z.ZodNumber;
+    collapsed: z.ZodBoolean;
+    related: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    additionalFields: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodNull]>>;
+    audience: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        documentId: z.ZodString;
+        name: z.ZodString;
+        key: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: number;
+        documentId: string;
+        key: string;
+    }, {
+        name: string;
+        id: number;
+        documentId: string;
+        key: string;
+    }>, "many">, z.ZodNull]>>;
+    autoSync: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodNull]>>;
+}, "strip", z.ZodTypeAny, {
+    type: "INTERNAL" | "EXTERNAL" | "WRAPPER";
+    id: number;
+    documentId: string;
+    title: string;
+    uiRouterKey: string;
+    menuAttached: boolean;
+    order: number;
+    collapsed: boolean;
+    additionalFields?: Record<string, unknown> | null | undefined;
+    path?: string | null | undefined;
+    audience?: {
+        name: string;
+        id: number;
+        documentId: string;
+        key: string;
+    }[] | null | undefined;
+    slug?: string | null | undefined;
+    externalPath?: string | null | undefined;
+    related?: string | null | undefined;
+    autoSync?: boolean | null | undefined;
+}, {
+    type: "INTERNAL" | "EXTERNAL" | "WRAPPER";
+    id: number;
+    documentId: string;
+    title: string;
+    uiRouterKey: string;
+    menuAttached: boolean;
+    order: number;
+    collapsed: boolean;
+    additionalFields?: Record<string, unknown> | null | undefined;
+    path?: string | null | undefined;
+    audience?: {
+        name: string;
+        id: number;
+        documentId: string;
+        key: string;
+    }[] | null | undefined;
+    slug?: string | null | undefined;
+    externalPath?: string | null | undefined;
+    related?: string | null | undefined;
+    autoSync?: boolean | null | undefined;
+}>;
+export type ReadNavigationItemFromLocaleSchema = z.infer<typeof readNavigationItemFromLocaleSchema>;
+export declare const readNavigationItemFromLocaleSchema: z.ZodObject<z.objectUtil.extendShape<Pick<Omit<{
+    id: z.ZodNumber;
+    documentId: z.ZodString;
+    title: z.ZodString;
+    type: z.ZodEnum<["INTERNAL", "EXTERNAL", "WRAPPER"]>;
+    path: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    slug: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    externalPath: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    uiRouterKey: z.ZodString;
+    menuAttached: z.ZodBoolean;
+    order: z.ZodNumber;
+    collapsed: z.ZodBoolean;
+    related: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    additionalFields: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodNull]>>;
+    audience: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        documentId: z.ZodString;
+        name: z.ZodString;
+        key: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: number;
+        documentId: string;
+        key: string;
+    }, {
+        name: string;
+        id: number;
+        documentId: string;
+        key: string;
+    }>, "many">, z.ZodNull]>>;
+    autoSync: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodNull]>>;
+}, "related">, "path" | "type" | "title" | "externalPath" | "uiRouterKey">, {
+    related: z.ZodUnknown;
+}>, "strip", z.ZodTypeAny, {
+    type: "INTERNAL" | "EXTERNAL" | "WRAPPER";
+    title: string;
+    uiRouterKey: string;
+    path?: string | null | undefined;
+    externalPath?: string | null | undefined;
+    related?: unknown;
+}, {
+    type: "INTERNAL" | "EXTERNAL" | "WRAPPER";
+    title: string;
+    uiRouterKey: string;
+    path?: string | null | undefined;
+    externalPath?: string | null | undefined;
+    related?: unknown;
+}>;
+export type NavigationItemDBSchema = z.infer<typeof navigationItemDBBaseSchema> & {
+    parent?: NavigationItemDBSchema | null;
+    items?: NavigationItemsDBSchema;
+    master?: NavigationDBSchema;
+};
+export declare const navigationItemDBSchema: z.ZodType<NavigationItemDBSchema>;
+export type NavigationItemsDBSchema = z.infer<typeof navigationItemsDBSchema>;
+export declare const navigationItemsDBSchema: z.ZodArray<z.ZodType<NavigationItemDBSchema, z.ZodTypeDef, NavigationItemDBSchema>, "many">;
+export type NavigationDBSchema = z.infer<ReturnType<typeof navigationDBSchema>>;
+export declare const navigationDBSchema: (withItems: boolean) => z.ZodObject<{
+    id: z.ZodNumber;
+    documentId: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    localeCode: z.ZodString;
+    visible: z.ZodBoolean;
+    items: z.ZodArray<z.ZodType<NavigationItemDBSchema, z.ZodTypeDef, NavigationItemDBSchema>, "many"> | z.ZodOptional<z.ZodArray<z.ZodType<NavigationItemDBSchema, z.ZodTypeDef, NavigationItemDBSchema>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: number;
+    documentId: string;
+    slug: string;
+    localeCode: string;
+    visible: boolean;
+    items?: NavigationItemDBSchema[] | undefined;
+}, {
+    name: string;
+    id: number;
+    documentId: string;
+    slug: string;
+    localeCode: string;
+    visible: boolean;
+    items?: NavigationItemDBSchema[] | undefined;
+}>;
+export type CreateNavigationSchema = z.infer<typeof createNavigationSchema>;
+export declare const createNavigationSchema: z.ZodObject<z.objectUtil.extendShape<Omit<{
+    id: z.ZodNumber;
+    documentId: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    localeCode: z.ZodString;
+    visible: z.ZodBoolean;
+    items: z.ZodArray<z.ZodType<NavigationItemDBSchema, z.ZodTypeDef, NavigationItemDBSchema>, "many"> | z.ZodOptional<z.ZodArray<z.ZodType<NavigationItemDBSchema, z.ZodTypeDef, NavigationItemDBSchema>, "many">>;
+}, "id" | "documentId" | "slug" | "localeCode" | "items">, {
+    documentId: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodUndefined>;
+}>, "strip", z.ZodTypeAny, {
+    name: string;
+    visible: boolean;
+    id?: undefined;
+    documentId?: string | undefined;
+}, {
+    name: string;
+    visible: boolean;
+    id?: undefined;
+    documentId?: string | undefined;
+}>;
+export type UpdateNavigationItemSchema = z.ZodType<Omit<z.infer<typeof navigationItemDBSchema>, 'id' | 'documentId' | 'parent' | 'items'>> & {
+    items?: UpdateNavigationItemsSchema | null;
+    id?: number;
+    documentId?: string;
+    updated?: boolean;
+    removed?: boolean;
+};
+export declare const updateNavigationItemSchema: UpdateNavigationItemSchema;
+export type UpdateNavigationItemsSchema = z.infer<typeof navigationItemsDBSchema>;
+export declare const updateNavigationItemsSchema: z.ZodArray<UpdateNavigationItemSchema, "many">;
+export type UpdateNavigationSchema = z.infer<typeof updateNavigationSchema>;
+export declare const updateNavigationSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    id: z.ZodNumber;
+    documentId: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+    localeCode: z.ZodOptional<z.ZodString>;
+    visible: z.ZodOptional<z.ZodBoolean>;
+    items: z.ZodOptional<z.ZodArray<UpdateNavigationItemSchema, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    documentId: string;
+    name?: string | undefined;
+    slug?: string | undefined;
+    localeCode?: string | undefined;
+    visible?: boolean | undefined;
+    items?: Omit<NavigationItemDBSchema, "id" | "documentId" | "items" | "parent">[] | undefined;
+}, {
+    id: number;
+    documentId: string;
+    name?: string | undefined;
+    slug?: string | undefined;
+    localeCode?: string | undefined;
+    visible?: boolean | undefined;
+    items?: Omit<NavigationItemDBSchema, "id" | "documentId" | "items" | "parent">[] | undefined;
+}>;
+export {};

package/dist/server/src/services/admin/admin.d.ts

@@ -0,0 +1,32 @@
+import { Core } from '@strapi/strapi';
+import { ConfigContentTypeDTO, NavigationDTO, NavigationPluginConfigDTO } from '../../dtos';
+import { NavigationDBSchema, ReadNavigationItemFromLocaleSchema } from '../../schemas';
+import { ConfigInput, DeleteInput, FillFromOtherLocaleInput, GetByIdInput, GetContentTypeItemsInput, GetInput, I18nNavigationContentsCopyInput, PostInput, PutInput, ReadNavigationItemFromLocaleInput, UpdateConfigInput } from './types';
+export type AdminService = ReturnType<typeof adminService>;
+declare const adminService: (context: {
+    strapi: Core.Strapi;
+}) => {
+    config({ viaSettingsPage }: ConfigInput): Promise<NavigationPluginConfigDTO>;
+    configContentTypes({ viaSettingsPage, }: ConfigInput): Promise<ConfigContentTypeDTO[]>;
+    get({ ids, localeCode }: GetInput): Promise<NavigationDBSchema[]>;
+    getById({ documentId, localeCode }: GetByIdInput): Promise<NavigationDBSchema>;
+    post({ auditLog, payload }: PostInput): Promise<NavigationDTO>;
+    put({ auditLog, payload }: PutInput): Promise<NavigationDBSchema>;
+    delete({ auditLog, documentId }: DeleteInput): Promise<void>;
+    restart(): Promise<void>;
+    restoreConfig(): Promise<void>;
+    updateConfig({ config: newConfig }: UpdateConfigInput): Promise<void>;
+    fillFromOtherLocale({ auditLog, source, target, documentId, }: FillFromOtherLocaleInput): Promise<NavigationDBSchema>;
+    i18nNavigationContentsCopy({ source, target, }: I18nNavigationContentsCopyInput): Promise<void>;
+    readNavigationItemFromLocale({ path, source, target, }: ReadNavigationItemFromLocaleInput): Promise<ReadNavigationItemFromLocaleSchema>;
+    getContentTypeItems({ query, uid, }: GetContentTypeItemsInput): Promise<{
+        documentId: string;
+    }[]>;
+    purgeNavigationCache(documentId: string, clearLocalisations?: boolean): Promise<{
+        success: boolean;
+    }>;
+    purgeNavigationsCache(): Promise<{
+        success: boolean;
+    }>;
+};
+export default adminService;

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

@@ -0,0 +1,3 @@
+import adminService from './admin';
+export type { AdminService } from './admin';
+export default adminService;

package/dist/server/src/services/admin/types.d.ts

@@ -0,0 +1,47 @@
+import { CreateNavigationSchema, NavigationDBSchema, NavigationPluginConfigDBSchema, UpdateNavigationSchema } from '../../schemas';
+import { AuditLogContext } from './utils';
+export interface ConfigInput {
+    viaSettingsPage?: boolean;
+}
+export interface GetInput {
+    ids?: string[];
+    localeCode?: string;
+}
+export interface GetByIdInput {
+    documentId: string;
+    localeCode?: string;
+}
+export interface PostInput {
+    payload: CreateNavigationSchema;
+    auditLog: AuditLogContext;
+}
+export interface PutInput {
+    payload: UpdateNavigationSchema;
+    auditLog: AuditLogContext;
+}
+export interface DeleteInput {
+    documentId: string;
+    auditLog: AuditLogContext;
+}
+export interface UpdateConfigInput {
+    config: NavigationPluginConfigDBSchema;
+}
+export interface FillFromOtherLocaleInput {
+    source: string;
+    target: string;
+    documentId: string;
+    auditLog: AuditLogContext;
+}
+export interface I18nNavigationContentsCopyInput {
+    target: NavigationDBSchema;
+    source: NavigationDBSchema;
+}
+export interface ReadNavigationItemFromLocaleInput {
+    source: string;
+    target: string;
+    path: string;
+}
+export interface GetContentTypeItemsInput {
+    uid: string;
+    query: Record<string, unknown>;
+}

package/dist/server/src/services/admin/utils.d.ts

@@ -0,0 +1,32 @@
+import { Core } from '@strapi/strapi';
+import { CreateBranchNavigationItemDTO, NavigationItemDTO } from '../../dtos';
+import { NavigationDBSchema } from '../../schemas';
+import { NavigationAction } from '../../types';
+export type AuditLogContext = {
+    emit: (e: string, d: AuditLogParams) => void;
+};
+export type AuditLogParams = {
+    actionType: string;
+    oldEntity: NavigationDBSchema;
+    newEntity: NavigationDBSchema;
+} | {
+    actionType: 'DELETE';
+    entity: NavigationDBSchema;
+};
+export declare const sendAuditLog: (auditLogInstance: AuditLogContext, event: string, data: AuditLogParams) => void;
+export declare const prepareAuditLog: (actions: NavigationAction[]) => string;
+type FillCopyContext = {
+    master: NavigationDBSchema;
+    strapi: Core.Strapi;
+    localeCode: string;
+    entities: Map<string, NavigationItemDTO['related']>;
+};
+export declare const processItems: (context: FillCopyContext) => (item: CreateBranchNavigationItemDTO) => Promise<CreateBranchNavigationItemDTO>;
+export declare const intercalate: <T, U extends T>(glue: T, arr: U[]) => (T | U)[];
+export declare const getCacheStatus: ({ strapi, }: {
+    strapi: Core.Strapi;
+}) => Promise<{
+    hasCachePlugin: boolean;
+    enabled: boolean;
+}>;
+export {};

package/dist/server/src/services/client/client.d.ts

@@ -0,0 +1,93 @@
+import { Core } from '@strapi/strapi';
+import { NavigationItemDTO, RFRNavigationItemDTO, RFRPageDTO } from '../../dtos';
+import { NavigationItemAdditionalField, NavigationItemCustomField } from '../../schemas';
+import { ReadAllInput, RenderChildrenInput, RenderInput, RenderRFRInput, RenderRFRNavInput, RenderRFRPageInput, RenderTreeInput, RenderTypeInput } from './types';
+export type ClientService = ReturnType<typeof clientService>;
+declare const clientService: (context: {
+    strapi: Core.Strapi;
+}) => {
+    readAll({ locale, orderBy, orderDirection }: ReadAllInput): Promise<{
+        name: string;
+        id: number;
+        documentId: string;
+        slug: string;
+        localeCode: string;
+        visible: boolean;
+        items?: import("../../schemas").NavigationItemDBSchema[] | undefined;
+    }[]>;
+    renderRFRNavigationItem({ item }: RenderRFRNavInput): RFRNavigationItemDTO;
+    renderRFRPage({ item, parent, enabledCustomFieldsNames }: RenderRFRPageInput): RFRPageDTO;
+    renderRFR({ items, parent, parentNavItem, contentTypes, enabledCustomFieldsNames, }: RenderRFRInput): {
+        pages: {};
+        nav: {};
+    };
+    renderTree({ items, documentId, path, itemParser, }: RenderTreeInput): Promise<NavigationItemDTO[]>;
+    getCustomFields(additionalFields: NavigationItemAdditionalField[]): NavigationItemCustomField[];
+    renderType({ criteria, filter, itemCriteria, locale, populate, rootPath, type, wrapRelated, }: RenderTypeInput): Promise<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?: NavigationItemDTO | null | undefined;
+    }[]>;
+    renderChildren({ childUIKey, idOrSlug, locale, menuOnly, type, wrapRelated, }: RenderChildrenInput): Promise<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?: NavigationItemDTO | null | undefined;
+    }[]>;
+    render({ idOrSlug, locale, menuOnly, populate, rootPath, type, wrapRelated, }: RenderInput): Promise<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?: NavigationItemDTO | null | undefined;
+    }[]>;
+};
+export default clientService;

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

@@ -0,0 +1,3 @@
+import clientService from './client';
+export type { ClientService } from './client';
+export default clientService;

package/dist/server/src/services/client/types.d.ts

@@ -0,0 +1,66 @@
+import { NavigationItemDTO, RFRNavigationItemDTO } from '../../dtos';
+export type RenderType = 'FLAT' | 'TREE' | 'RFR';
+export type PopulateQueryParam = string | boolean | string[];
+export type NestedPath = {
+    id?: number;
+    documentId?: string;
+    parent?: {
+        id: number;
+        documentId: string;
+        path: string;
+    };
+    path: string;
+};
+export interface ReadAllInput {
+    orderBy?: string;
+    orderDirection?: 'DESC' | 'ASC';
+    locale?: string;
+}
+export interface RenderRFRInput {
+    items: NavigationItemDTO[];
+    parent?: string;
+    parentNavItem?: RFRNavigationItemDTO;
+    contentTypes: string[];
+    enabledCustomFieldsNames: string[];
+}
+export interface RenderRFRNavInput {
+    item: Pick<NavigationItemDTO, 'uiRouterKey' | 'title' | 'path' | 'type' | 'audience'>;
+}
+export interface RenderRFRPageInput {
+    item: Omit<NavigationItemDTO, 'items' | 'parent' | 'master'>;
+    parent?: string;
+    enabledCustomFieldsNames: string[];
+}
+export interface RenderTreeInput {
+    items?: NavigationItemDTO[];
+    documentId?: string;
+    path: string | undefined;
+    itemParser: (_: NavigationItemDTO, path: string) => Promise<NavigationItemDTO>;
+}
+export interface RenderTypeInput {
+    type?: RenderType;
+    criteria?: Record<string, unknown>;
+    itemCriteria?: Record<string, unknown>;
+    filter?: string;
+    rootPath?: string;
+    wrapRelated?: boolean;
+    populate?: PopulateQueryParam;
+    locale?: string;
+}
+export interface RenderChildrenInput {
+    idOrSlug: number | string;
+    childUIKey: string;
+    type?: RenderType;
+    menuOnly?: boolean;
+    wrapRelated?: boolean;
+    locale?: string;
+}
+export interface RenderInput {
+    idOrSlug: string | number;
+    type?: RenderType;
+    menuOnly?: boolean;
+    rootPath?: string;
+    wrapRelated?: boolean;
+    populate?: PopulateQueryParam;
+    locale?: string;
+}

package/dist/server/src/services/client/utils.d.ts

@@ -0,0 +1,12 @@
+import { NavigationItemDTO } from '../../dtos';
+import { StrapiContentTypeFullSchema } from '../../types';
+import { NestedPath } from './types';
+export declare const composeItemTitle: (item: NavigationItemDTO, fields?: Record<string, string[]>, contentTypes?: StrapiContentTypeFullSchema[]) => string | undefined;
+export declare const extractItemRelationTitle: (relatedItem: any, fields?: Record<string, string[]>, contentTypes?: StrapiContentTypeFullSchema[]) => any;
+export declare const filterByPath: <T extends Pick<NavigationItemDTO, "path" | "documentId" | "parent">>(items: T[], path?: string) => {
+    root?: NestedPath;
+    items: T[];
+};
+export declare const buildNestedPaths: <T extends Pick<NavigationItemDTO, "path" | "documentId" | "parent">>(items: T[], documentId?: string, parentPath?: string | null) => NestedPath[];
+export declare const compareArraysOfNumbers: (arrA: number[], arrB: number[]) => number;
+export declare const filterOutUnpublished: (item: NavigationItemDTO) => any;

package/dist/server/src/services/common/common.d.ts

@@ -0,0 +1,31 @@
+import type { Core } from '@strapi/strapi';
+import { NavigationItemDTO } from '../../dtos';
+import { NavigationItemCustomField, NavigationItemDBSchema, NavigationPluginConfigDBSchema } from '../../schemas';
+import { NavigationAction, NavigationActionsCategories } from '../../types';
+import { AnalyzeBranchInput, BuildNestedStructureInput, CreateBranchInput, EmitEventInput, GetBranchNameInput, GetSlugInput, MapToNavigationItemDTOInput, RegisterLifeCycleHookInput, RemoveBranchInput, RunLifeCycleHookInput, UpdateBranchInput } from './types';
+export type CommonService = ReturnType<typeof commonService>;
+declare const commonService: (context: {
+    strapi: Core.Strapi;
+}) => {
+    getPluginStore(): Promise<ReturnType<typeof strapi.store>>;
+    mapToNavigationItemDTO({ navigationItems, populate, master, parent, }: MapToNavigationItemDTOInput): Promise<NavigationItemDTO[]>;
+    setDefaultConfig(): Promise<NavigationPluginConfigDBSchema>;
+    getBranchName({ item }: GetBranchNameInput): NavigationActionsCategories | void;
+    analyzeBranch({ masterEntity, navigationItems, parentItem, prevAction, }: AnalyzeBranchInput): Promise<NavigationAction[]>;
+    removeBranch({ navigationItems, action, }: RemoveBranchInput): Promise<NavigationAction[]>;
+    createBranch({ action, masterEntity, navigationItems, parentItem, }: CreateBranchInput): Promise<NavigationAction[]>;
+    updateBranch({ masterEntity, navigationItems, action, parentItem, }: UpdateBranchInput): Promise<NavigationAction[]>;
+    emitEvent({ entity, event, uid }: EmitEventInput<any, any>): Promise<void>;
+    pruneCustomFields({ removedFields }: {
+        removedFields: NavigationItemCustomField[];
+    }): Promise<void>;
+    getSlug({ query }: GetSlugInput): Promise<string>;
+    registerLifeCycleHook({ callback, contentTypeName, hookName }: RegisterLifeCycleHookInput): void;
+    runLifeCycleHook({ contentTypeName, event, hookName }: RunLifeCycleHookInput): Promise<void>;
+    buildNestedStructure({ navigationItems, id, }: BuildNestedStructureInput): NavigationItemDBSchema[];
+    readLocale(): Promise<{
+        defaultLocale: string;
+        restLocale: string[];
+    }>;
+};
+export default commonService;

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

@@ -0,0 +1,3 @@
+import commonService from './common';
+export type { CommonService } from './common';
+export default commonService;

package/dist/server/src/services/common/types.d.ts

@@ -0,0 +1,68 @@
+import { UID } from '@strapi/strapi';
+import { CreateBranchNavigationItemDTO, NavigationDTO, NavigationItemDTO } from '../../dtos';
+import { NavigationDBSchema, NavigationItemDBSchema, NavigationItemsDBSchema } from '../../schemas';
+import { ContentType, Effect, LifeCycleEvent, LifeCycleHookName, NavigationAction } from '../../types';
+export type LifecycleHookRecord = Partial<Record<LifeCycleHookName, Array<Effect<LifeCycleEvent>>>>;
+export interface RegisterLifeCycleHookInput {
+    hookName: LifeCycleHookName;
+    callback: Effect<LifeCycleEvent>;
+    contentTypeName: ContentType;
+}
+export interface RunLifeCycleHookInput {
+    contentTypeName: ContentType;
+    event: LifeCycleEvent;
+    hookName: LifeCycleHookName;
+}
+export interface MapToNavigationItemDTOInput {
+    navigationItems: NavigationItemDBSchema[];
+    populate: unknown;
+    master?: Omit<NavigationDTO, 'items'>;
+    parent?: NavigationItemDTO;
+}
+export interface CreateBranchInput {
+    navigationItems: CreateBranchNavigationItemDTO[];
+    masterEntity: NavigationDBSchema | undefined;
+    parentItem: NavigationItemDBSchema | undefined;
+    action: NavigationAction;
+}
+export interface RemoveBranchInput {
+    navigationItems?: NavigationItemsDBSchema;
+    action?: NavigationAction;
+}
+export interface UpdateBranchInput {
+    navigationItems: NavigationItemsDBSchema & {
+        updated?: boolean;
+    }[];
+    masterEntity: NavigationDBSchema | undefined;
+    parentItem: NavigationItemDBSchema | undefined;
+    action: NavigationAction;
+}
+export interface AnalyzeBranchInput {
+    navigationItems: (Omit<NavigationItemDBSchema, 'id' | 'documentId'> & {
+        removed?: boolean;
+        id?: number;
+        documentId?: string;
+    })[];
+    masterEntity?: NavigationDBSchema;
+    parentItem?: NavigationItemDBSchema;
+    prevAction: NavigationAction;
+}
+export interface EmitEventInput<TEvent, TEntity> {
+    uid: UID.Schema;
+    event: TEvent;
+    entity: TEntity;
+}
+export interface GetBranchNameInput {
+    item: Omit<NavigationItemDBSchema, 'id' | 'documentId'> & {
+        removed?: boolean;
+        documentId?: string;
+        id?: number;
+    };
+}
+export interface BuildNestedStructureInput {
+    navigationItems?: NavigationItemDBSchema[];
+    id?: number;
+}
+export interface GetSlugInput {
+    query: string;
+}

package/dist/server/src/services/common/utils.d.ts

@@ -0,0 +1,12 @@
+import { NavigationItemType } from '../../schemas';
+export interface DuplicateCheckItem {
+    items?: DuplicateCheckItem[];
+    id?: number;
+    title: string;
+    path?: string | null;
+    type: NavigationItemType;
+}
+export declare const checkDuplicatePath: ({ checkData, parentItem, }: {
+    parentItem?: DuplicateCheckItem;
+    checkData: DuplicateCheckItem[];
+}) => Promise<void>;