@vicacha-devs/strapi-plugin-global-search 0.0.0-stage → 2.0.3

package/dist/server/index.d.ts

@@ -0,0 +1,212 @@
+declare const _default: {
+    register: ({ strapi }: {
+        strapi: import("./types").StrapiLike;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: import("./types").StrapiLike;
+    }) => Promise<void>;
+    config: {
+        default: import("./types").PluginSettings;
+        validator: (config?: Partial<import("./types").PluginSettings>) => void;
+        defaults: import("./types").PluginSettings;
+    };
+    controllers: {
+        search: ({ strapi }: {
+            strapi: import("./types").StrapiLike;
+        }) => {
+            find(ctx: {
+                request: {
+                    query: Record<string, unknown>;
+                    body?: Record<string, unknown>;
+                };
+                state: {
+                    userAbility?: {
+                        can: (action: string, subject: string) => boolean;
+                    } | null;
+                };
+                body?: unknown;
+                throw: (code: number, msg: string) => void;
+            }): Promise<void>;
+        };
+        schema: ({ strapi }: {
+            strapi: import("./types").StrapiLike;
+        }) => {
+            find(ctx: {
+                request: {
+                    query: Record<string, unknown>;
+                    body?: Record<string, unknown>;
+                };
+                state: {
+                    userAbility?: {
+                        can: (action: string, subject: string) => boolean;
+                    } | null;
+                };
+                body?: unknown;
+                throw: (code: number, msg: string) => void;
+            }): Promise<void>;
+            findAll(ctx: {
+                request: {
+                    query: Record<string, unknown>;
+                    body?: Record<string, unknown>;
+                };
+                state: {
+                    userAbility?: {
+                        can: (action: string, subject: string) => boolean;
+                    } | null;
+                };
+                body?: unknown;
+                throw: (code: number, msg: string) => void;
+            }): Promise<void>;
+        };
+        settings: ({ strapi }: {
+            strapi: import("./types").StrapiLike;
+        }) => {
+            find(ctx: {
+                request: {
+                    query: Record<string, unknown>;
+                    body?: Partial<import("./types").PluginSettings>;
+                };
+                state: {
+                    userAbility?: {
+                        can: (action: string, subject: string) => boolean;
+                    } | null;
+                };
+                body?: unknown;
+                throw: (code: number, msg: string) => void;
+            }): Promise<void>;
+            update(ctx: {
+                request: {
+                    query: Record<string, unknown>;
+                    body?: Partial<import("./types").PluginSettings>;
+                };
+                state: {
+                    userAbility?: {
+                        can: (action: string, subject: string) => boolean;
+                    } | null;
+                };
+                body?: unknown;
+                throw: (code: number, msg: string) => void;
+            }): Promise<void>;
+            reset(ctx: {
+                request: {
+                    query: Record<string, unknown>;
+                    body?: Partial<import("./types").PluginSettings>;
+                };
+                state: {
+                    userAbility?: {
+                        can: (action: string, subject: string) => boolean;
+                    } | null;
+                };
+                body?: unknown;
+                throw: (code: number, msg: string) => void;
+            }): Promise<void>;
+        };
+    };
+    routes: {
+        admin: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    }[];
+                };
+            }[];
+        };
+    };
+    services: {
+        schema: ({ strapi }: {
+            strapi: import("./types").StrapiLike;
+        }) => {
+            listCandidateUids(includePluginContentTypes?: boolean): string[];
+            isSearchableAttribute(name: string, attribute: import("./services/schema").AttributeLike | undefined): boolean;
+            isSafeDisplayAttribute(name: string, attribute: import("./services/schema").AttributeLike | undefined): boolean;
+            collectFieldPaths(attributes?: Record<string, import("./services/schema").AttributeLike>, { maxDepth, depth, prefix, visited, }?: {
+                maxDepth: number;
+                depth?: number;
+                prefix?: string;
+                visited?: Set<string>;
+            }): string[];
+            resolveMainField(contentType: import("./services/schema").ContentTypeLike): Promise<string>;
+            extractExcludedFields(uid: string, excludedFields?: string[]): Set<string>;
+            resolveDisplayName(uid: string, info?: import("./services/schema").ContentTypeLike["info"]): string;
+            hasAnySearchableField(fields: {
+                idFields: string[];
+                topLevelFields: string[];
+                nestedFields: string[];
+            }, isMainSearchable: boolean): boolean;
+            describeContentType(uid: string, settings: import("./types").PluginSettings): Promise<import("./types").ContentTypeDescriptor | null>;
+            getSearchableContentTypes({ force, }?: {
+                force?: boolean;
+            }): Promise<import("./types").ContentTypeDescriptor[]>;
+            getAllContentTypes(): Promise<import("./types").ContentTypeDescriptor[]>;
+            clearCache(): void;
+        };
+        query: () => {
+            nest: (path: string, condition: Record<string, unknown>) => Record<string, unknown>;
+            buildPopulate: (paths: string[]) => Record<string, unknown> | undefined;
+            searchablePaths(descriptor: import("./types").ContentTypeDescriptor): string[];
+            buildFilters(descriptor: import("./types").ContentTypeDescriptor, query: string): {
+                $or: unknown[];
+            } | null;
+            buildParams(descriptor: import("./types").ContentTypeDescriptor, { query, locale, limit, includeDrafts, }: {
+                query: string;
+                locale?: string;
+                limit: number;
+                includeDrafts: boolean;
+            }): Record<string, unknown> | null;
+        };
+        ranking: () => {
+            findMatch(entry: unknown, paths: string[], test: (value: string) => boolean, normalize?: boolean): {
+                path: string;
+                value: string;
+            } | null;
+            score(entry: unknown, descriptor: import("./types").ContentTypeDescriptor, query: string): {
+                tier: number;
+                tierLabel: string;
+                matchedField: string | null;
+                matchedFieldLabel: string | null;
+                matchedSnippet: string | null;
+                exactCase: boolean;
+                valueLength: number;
+            };
+            compare(a: import("./types").RankedHit, b: import("./types").RankedHit): number;
+            sort(hits: import("./types").RankedHit[]): import("./types").RankedHit[];
+        };
+        permissions: () => {
+            filterReadableTypes(types: import("./types").ContentTypeDescriptor[], userAbility?: {
+                can: (action: string, subject: string) => boolean;
+            } | null): import("./types").ContentTypeDescriptor[];
+        };
+        settings: ({ strapi }: {
+            strapi: import("./types").StrapiLike;
+        }) => {
+            get(): Promise<import("./types").PluginSettings>;
+            set(patch?: Partial<import("./types").PluginSettings>): Promise<import("./types").PluginSettings>;
+            reset(): Promise<import("./types").PluginSettings>;
+            defaults: import("./types").PluginSettings;
+        };
+        search: ({ strapi }: {
+            strapi: import("./types").StrapiLike;
+        }) => {
+            buildAdminUrl(descriptor: import("./types").ContentTypeDescriptor, entry: import("./services/search").EntryLike): string;
+            queryContentType(descriptor: import("./types").ContentTypeDescriptor, { query, locale, settings, }: {
+                query: string;
+                locale?: string;
+                settings: import("./types").PluginSettings;
+            }): Promise<import("./services/search").EntryLike[]>;
+            resolveEntryTitle(descriptor: import("./types").ContentTypeDescriptor, entry: import("./services/search").EntryLike): string;
+            resolveEntryStatus(descriptor: import("./types").ContentTypeDescriptor, entry: import("./services/search").EntryLike): "published" | "draft" | null;
+            toHit(descriptor: import("./types").ContentTypeDescriptor, entry: import("./services/search").EntryLike, query: string, settings: import("./types").PluginSettings): import("./types").RankedHit;
+            search({ query: rawQuery, types, locale, page, pageSize, userAbility, }?: import("./types").SearchParams): Promise<import("./types").SearchResult>;
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../server/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;wBAIW,CAAC;;;+BAGZ,CAAC;;;;;;;;;;;;;;wBAFE,CAAC;;;+BAGE,CAAC;;;;;;;;;;wBAHJ,CAAC;;;+BAGE,CAAC;;;;;;;;;;;;;;wBAJoB,CAAC;;;+BAI1B,CAAF;;;;;;;;;;wBAJ2B,CAAC;;;+BAI1B,CAAF;;;;;;;;;;wBAJ2B,CAAC;;;+BAI1B,CAAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAOmjG,CAAC;sBAAwB,CAAC;uBAAyB,CAAC;;;;;;;;;;;;qBAAkoK,CAAC;;;;;;;;;;;;;;sBAArqK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAl/D,CAAC;;;;;;;;;;AARrlC,wBAOE"}