straplight 1.1.0

package/dist/admin/index.mjs

@@ -0,0 +1,4 @@
+import { i } from "../_chunks/index-B2B6CFFk.mjs";
+export {
+  i as default
+};

package/dist/admin/src/components/StraplightOverlay.d.ts

@@ -0,0 +1 @@
+export declare function StraplightOverlay(): import("react/jsx-runtime").JSX.Element | null;

package/dist/admin/src/components/StraplightPortal.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tiny component injected into content-manager zones.
+ * Its only job: capture `navigate` and store it globally
+ * so the standalone overlay can do SPA navigation.
+ */
+export declare function NavigateCapture(): null;

package/dist/admin/src/hooks/useStraplight.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+export interface SearchResult {
+    id: number;
+    documentId: string;
+    label: string;
+    contentType: string;
+    uid: string;
+    fields: {
+        name: string;
+        value: string;
+    }[];
+}
+export declare function useStraplight(): {
+    isOpen: boolean;
+    query: string;
+    setQuery: import("react").Dispatch<import("react").SetStateAction<string>>;
+    results: SearchResult[];
+    loading: boolean;
+    selectedIndex: number;
+    close: () => void;
+    onKeyDown: (e: React.KeyboardEvent) => void;
+    navigateToResult: (result: SearchResult) => void;
+};

package/dist/admin/src/hooks/useStraplightSettings.d.ts

@@ -0,0 +1,6 @@
+interface StraplightSettings {
+    debounceMs: number;
+    minQueryLength: number;
+}
+export declare function useStraplightSettings(): StraplightSettings;
+export {};

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

@@ -0,0 +1,11 @@
+declare const _default: {
+    register(app: any): void;
+    bootstrap(app: any): void;
+    registerTrads({ locales }: {
+        locales: string[];
+    }): Promise<{
+        data: any;
+        locale: string;
+    }[]>;
+};
+export default _default;

package/dist/admin/src/pages/Settings.d.ts

@@ -0,0 +1,2 @@
+export declare function SettingsPage(): import("react/jsx-runtime").JSX.Element;
+export default SettingsPage;

package/dist/admin/src/pluginId.d.ts

@@ -0,0 +1 @@
+export declare const PLUGIN_ID = "straplight";

package/dist/admin/src/utils/getTranslation.d.ts

@@ -0,0 +1,2 @@
+declare const getTranslation: (id: string) => string;
+export { getTranslation };

package/dist/server/index.js

@@ -0,0 +1,263 @@
+"use strict";
+const bootstrap = ({ strapi }) => {
+};
+const destroy = ({ strapi }) => {
+};
+const register = ({ strapi }) => {
+};
+const config = {
+  default: {},
+  validator() {
+  }
+};
+const contentTypes = {};
+const controller = ({ strapi }) => ({
+  async search(ctx) {
+    const q = typeof ctx.query.q === "string" ? ctx.query.q.trim() : "";
+    if (!q) {
+      ctx.body = { results: [] };
+      return;
+    }
+    const results = await strapi.plugin("straplight").service("service").search(q);
+    ctx.body = { results };
+  }
+});
+const settings$1 = ({ strapi }) => ({
+  async getSettings(ctx) {
+    const settingsService = strapi.plugin("straplight").service("settings");
+    const currentSettings = await settingsService.getSettings();
+    const contentTypes2 = settingsService.getContentTypes();
+    ctx.body = { settings: currentSettings, contentTypes: contentTypes2 };
+  },
+  async updateSettings(ctx) {
+    const settingsService = strapi.plugin("straplight").service("settings");
+    const saved = await settingsService.setSettings(ctx.request.body);
+    ctx.body = { settings: saved };
+  }
+});
+const controllers = {
+  controller,
+  settings: settings$1
+};
+const middlewares = {};
+const policies = {};
+const contentAPIRoutes = () => ({
+  type: "content-api",
+  routes: []
+});
+const adminAPIRoutes = () => ({
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/search",
+      handler: "controller.search",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "GET",
+      path: "/settings",
+      handler: "settings.getSettings",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "PUT",
+      path: "/settings",
+      handler: "settings.updateSettings",
+      config: {
+        policies: []
+      }
+    }
+  ]
+});
+const routes = {
+  "content-api": contentAPIRoutes,
+  admin: adminAPIRoutes
+};
+const STRING_FIELD_TYPES = /* @__PURE__ */ new Set(["string", "text", "email", "uid", "richtext"]);
+const MAIN_FIELD_CANDIDATES = ["title", "name", "slug", "email", "subject", "label"];
+function getMainField(schema) {
+  const configured = schema.pluginOptions?.["content-manager"]?.mainField;
+  if (configured && schema.attributes?.[configured]) {
+    return configured;
+  }
+  for (const candidate of MAIN_FIELD_CANDIDATES) {
+    if (schema.attributes?.[candidate]) {
+      return candidate;
+    }
+  }
+  for (const [name, attr] of Object.entries(schema.attributes || {})) {
+    if (STRING_FIELD_TYPES.has(attr.type)) {
+      return name;
+    }
+  }
+  return null;
+}
+function getSearchableFields(schema) {
+  const fields = [];
+  for (const [name, attr] of Object.entries(schema.attributes || {})) {
+    if (STRING_FIELD_TYPES.has(attr.type)) {
+      fields.push(name);
+    }
+  }
+  return fields;
+}
+function getRelationFields(schema) {
+  const fields = [];
+  for (const [name, attr] of Object.entries(schema.attributes || {})) {
+    const a = attr;
+    if (a.type === "relation" && a.target?.startsWith("api::")) {
+      fields.push(name);
+    }
+  }
+  return fields;
+}
+function resolveRelationValue(entry, fieldName, schema, strapi) {
+  const related = entry[fieldName];
+  if (!related) return null;
+  const item = Array.isArray(related) ? related[0] : related;
+  if (!item) return null;
+  const attr = schema.attributes?.[fieldName];
+  if (!attr?.target) return null;
+  const targetSchema = strapi.contentTypes[attr.target];
+  if (!targetSchema) return null;
+  const targetMainField = getMainField(targetSchema);
+  if (targetMainField && item[targetMainField]) {
+    return String(item[targetMainField]);
+  }
+  return null;
+}
+const service = ({ strapi }) => ({
+  async search(query) {
+    const settings2 = await strapi.plugin("straplight").service("settings").getSettings();
+    const allResults = [];
+    const contentTypes2 = Object.entries(strapi.contentTypes).filter(([uid]) => uid.startsWith("api::")).filter(([uid]) => settings2.contentTypes[uid]?.enabled !== false);
+    const promises = contentTypes2.map(async ([uid, schema]) => {
+      try {
+        const searchableFields = getSearchableFields(schema);
+        if (searchableFields.length === 0) return;
+        const mainField = getMainField(schema) || searchableFields[0];
+        const filters = {
+          $or: searchableFields.map((field) => ({
+            [field]: { $containsi: query }
+          }))
+        };
+        const displayFields = settings2.contentTypes[uid]?.displayFields || [];
+        const relationFields = getRelationFields(schema);
+        const relationsToPopulate = displayFields.filter((f) => relationFields.includes(f));
+        const populate = {};
+        for (const rel of relationsToPopulate) {
+          const attr = schema.attributes?.[rel];
+          if (!attr?.target) continue;
+          const targetSchema = strapi.contentTypes[attr.target];
+          if (!targetSchema) continue;
+          const targetMainField = getMainField(targetSchema);
+          if (targetMainField) {
+            populate[rel] = { fields: [targetMainField] };
+          }
+        }
+        const entries = await strapi.documents(uid).findMany({
+          filters,
+          limit: 5,
+          ...Object.keys(populate).length > 0 ? { populate } : {}
+        });
+        const displayName = schema.info?.displayName || schema.info?.singularName || uid;
+        for (const entry of entries) {
+          const fields = displayFields.slice(0, 2).filter((f) => f !== mainField).map((f) => {
+            if (relationFields.includes(f)) {
+              const value = resolveRelationValue(entry, f, schema, strapi);
+              return value ? { name: f, value } : null;
+            }
+            const val = entry[f];
+            return val != null ? { name: f, value: String(val) } : null;
+          }).filter(Boolean);
+          allResults.push({
+            id: entry.id,
+            documentId: entry.documentId,
+            label: entry[mainField] || `#${entry.documentId}`,
+            contentType: displayName,
+            uid,
+            fields
+          });
+        }
+      } catch {
+      }
+    });
+    await Promise.all(promises);
+    return allResults;
+  }
+});
+const DEFAULTS = {
+  debounceMs: 200,
+  minQueryLength: 1,
+  contentTypes: {}
+};
+const settings = ({ strapi }) => ({
+  async getSettings() {
+    const store = strapi.store({ type: "plugin", name: "straplight" });
+    const data = await store.get({ key: "settings" });
+    return {
+      ...DEFAULTS,
+      ...data || {}
+    };
+  },
+  async setSettings(newSettings) {
+    const validated = {
+      debounceMs: Math.max(0, Math.round(Number(newSettings.debounceMs) || DEFAULTS.debounceMs)),
+      minQueryLength: Math.max(1, Math.round(Number(newSettings.minQueryLength) || DEFAULTS.minQueryLength)),
+      contentTypes: {}
+    };
+    if (newSettings.contentTypes && typeof newSettings.contentTypes === "object") {
+      for (const [uid, ct] of Object.entries(newSettings.contentTypes)) {
+        if (!uid.startsWith("api::")) continue;
+        validated.contentTypes[uid] = {
+          enabled: ct.enabled !== false,
+          displayFields: Array.isArray(ct.displayFields) ? ct.displayFields.slice(0, 2) : []
+        };
+      }
+    }
+    const store = strapi.store({ type: "plugin", name: "straplight" });
+    await store.set({ key: "settings", value: validated });
+    return validated;
+  },
+  getContentTypes() {
+    return Object.entries(strapi.contentTypes).filter(([uid]) => uid.startsWith("api::")).map(([uid, schema]) => ({
+      uid,
+      displayName: schema.info?.displayName || schema.info?.singularName || uid,
+      fields: Object.entries(schema.attributes || {}).filter(([, attr]) => {
+        const a = attr;
+        return STRING_FIELD_TYPES.has(a.type) || a.type === "relation" && a.target?.startsWith("api::");
+      }).map(([name, attr]) => {
+        const a = attr;
+        if (a.type === "relation") {
+          const targetSchema = strapi.contentTypes[a.target];
+          const targetName = targetSchema?.info?.displayName || a.target;
+          return { name, type: "relation", target: targetName };
+        }
+        return { name, type: a.type };
+      }),
+      mainField: getMainField(schema) || ""
+    }));
+  }
+});
+const services = {
+  service,
+  settings
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+module.exports = index;

package/dist/server/index.mjs

@@ -0,0 +1,264 @@
+const bootstrap = ({ strapi }) => {
+};
+const destroy = ({ strapi }) => {
+};
+const register = ({ strapi }) => {
+};
+const config = {
+  default: {},
+  validator() {
+  }
+};
+const contentTypes = {};
+const controller = ({ strapi }) => ({
+  async search(ctx) {
+    const q = typeof ctx.query.q === "string" ? ctx.query.q.trim() : "";
+    if (!q) {
+      ctx.body = { results: [] };
+      return;
+    }
+    const results = await strapi.plugin("straplight").service("service").search(q);
+    ctx.body = { results };
+  }
+});
+const settings$1 = ({ strapi }) => ({
+  async getSettings(ctx) {
+    const settingsService = strapi.plugin("straplight").service("settings");
+    const currentSettings = await settingsService.getSettings();
+    const contentTypes2 = settingsService.getContentTypes();
+    ctx.body = { settings: currentSettings, contentTypes: contentTypes2 };
+  },
+  async updateSettings(ctx) {
+    const settingsService = strapi.plugin("straplight").service("settings");
+    const saved = await settingsService.setSettings(ctx.request.body);
+    ctx.body = { settings: saved };
+  }
+});
+const controllers = {
+  controller,
+  settings: settings$1
+};
+const middlewares = {};
+const policies = {};
+const contentAPIRoutes = () => ({
+  type: "content-api",
+  routes: []
+});
+const adminAPIRoutes = () => ({
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/search",
+      handler: "controller.search",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "GET",
+      path: "/settings",
+      handler: "settings.getSettings",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "PUT",
+      path: "/settings",
+      handler: "settings.updateSettings",
+      config: {
+        policies: []
+      }
+    }
+  ]
+});
+const routes = {
+  "content-api": contentAPIRoutes,
+  admin: adminAPIRoutes
+};
+const STRING_FIELD_TYPES = /* @__PURE__ */ new Set(["string", "text", "email", "uid", "richtext"]);
+const MAIN_FIELD_CANDIDATES = ["title", "name", "slug", "email", "subject", "label"];
+function getMainField(schema) {
+  const configured = schema.pluginOptions?.["content-manager"]?.mainField;
+  if (configured && schema.attributes?.[configured]) {
+    return configured;
+  }
+  for (const candidate of MAIN_FIELD_CANDIDATES) {
+    if (schema.attributes?.[candidate]) {
+      return candidate;
+    }
+  }
+  for (const [name, attr] of Object.entries(schema.attributes || {})) {
+    if (STRING_FIELD_TYPES.has(attr.type)) {
+      return name;
+    }
+  }
+  return null;
+}
+function getSearchableFields(schema) {
+  const fields = [];
+  for (const [name, attr] of Object.entries(schema.attributes || {})) {
+    if (STRING_FIELD_TYPES.has(attr.type)) {
+      fields.push(name);
+    }
+  }
+  return fields;
+}
+function getRelationFields(schema) {
+  const fields = [];
+  for (const [name, attr] of Object.entries(schema.attributes || {})) {
+    const a = attr;
+    if (a.type === "relation" && a.target?.startsWith("api::")) {
+      fields.push(name);
+    }
+  }
+  return fields;
+}
+function resolveRelationValue(entry, fieldName, schema, strapi) {
+  const related = entry[fieldName];
+  if (!related) return null;
+  const item = Array.isArray(related) ? related[0] : related;
+  if (!item) return null;
+  const attr = schema.attributes?.[fieldName];
+  if (!attr?.target) return null;
+  const targetSchema = strapi.contentTypes[attr.target];
+  if (!targetSchema) return null;
+  const targetMainField = getMainField(targetSchema);
+  if (targetMainField && item[targetMainField]) {
+    return String(item[targetMainField]);
+  }
+  return null;
+}
+const service = ({ strapi }) => ({
+  async search(query) {
+    const settings2 = await strapi.plugin("straplight").service("settings").getSettings();
+    const allResults = [];
+    const contentTypes2 = Object.entries(strapi.contentTypes).filter(([uid]) => uid.startsWith("api::")).filter(([uid]) => settings2.contentTypes[uid]?.enabled !== false);
+    const promises = contentTypes2.map(async ([uid, schema]) => {
+      try {
+        const searchableFields = getSearchableFields(schema);
+        if (searchableFields.length === 0) return;
+        const mainField = getMainField(schema) || searchableFields[0];
+        const filters = {
+          $or: searchableFields.map((field) => ({
+            [field]: { $containsi: query }
+          }))
+        };
+        const displayFields = settings2.contentTypes[uid]?.displayFields || [];
+        const relationFields = getRelationFields(schema);
+        const relationsToPopulate = displayFields.filter((f) => relationFields.includes(f));
+        const populate = {};
+        for (const rel of relationsToPopulate) {
+          const attr = schema.attributes?.[rel];
+          if (!attr?.target) continue;
+          const targetSchema = strapi.contentTypes[attr.target];
+          if (!targetSchema) continue;
+          const targetMainField = getMainField(targetSchema);
+          if (targetMainField) {
+            populate[rel] = { fields: [targetMainField] };
+          }
+        }
+        const entries = await strapi.documents(uid).findMany({
+          filters,
+          limit: 5,
+          ...Object.keys(populate).length > 0 ? { populate } : {}
+        });
+        const displayName = schema.info?.displayName || schema.info?.singularName || uid;
+        for (const entry of entries) {
+          const fields = displayFields.slice(0, 2).filter((f) => f !== mainField).map((f) => {
+            if (relationFields.includes(f)) {
+              const value = resolveRelationValue(entry, f, schema, strapi);
+              return value ? { name: f, value } : null;
+            }
+            const val = entry[f];
+            return val != null ? { name: f, value: String(val) } : null;
+          }).filter(Boolean);
+          allResults.push({
+            id: entry.id,
+            documentId: entry.documentId,
+            label: entry[mainField] || `#${entry.documentId}`,
+            contentType: displayName,
+            uid,
+            fields
+          });
+        }
+      } catch {
+      }
+    });
+    await Promise.all(promises);
+    return allResults;
+  }
+});
+const DEFAULTS = {
+  debounceMs: 200,
+  minQueryLength: 1,
+  contentTypes: {}
+};
+const settings = ({ strapi }) => ({
+  async getSettings() {
+    const store = strapi.store({ type: "plugin", name: "straplight" });
+    const data = await store.get({ key: "settings" });
+    return {
+      ...DEFAULTS,
+      ...data || {}
+    };
+  },
+  async setSettings(newSettings) {
+    const validated = {
+      debounceMs: Math.max(0, Math.round(Number(newSettings.debounceMs) || DEFAULTS.debounceMs)),
+      minQueryLength: Math.max(1, Math.round(Number(newSettings.minQueryLength) || DEFAULTS.minQueryLength)),
+      contentTypes: {}
+    };
+    if (newSettings.contentTypes && typeof newSettings.contentTypes === "object") {
+      for (const [uid, ct] of Object.entries(newSettings.contentTypes)) {
+        if (!uid.startsWith("api::")) continue;
+        validated.contentTypes[uid] = {
+          enabled: ct.enabled !== false,
+          displayFields: Array.isArray(ct.displayFields) ? ct.displayFields.slice(0, 2) : []
+        };
+      }
+    }
+    const store = strapi.store({ type: "plugin", name: "straplight" });
+    await store.set({ key: "settings", value: validated });
+    return validated;
+  },
+  getContentTypes() {
+    return Object.entries(strapi.contentTypes).filter(([uid]) => uid.startsWith("api::")).map(([uid, schema]) => ({
+      uid,
+      displayName: schema.info?.displayName || schema.info?.singularName || uid,
+      fields: Object.entries(schema.attributes || {}).filter(([, attr]) => {
+        const a = attr;
+        return STRING_FIELD_TYPES.has(a.type) || a.type === "relation" && a.target?.startsWith("api::");
+      }).map(([name, attr]) => {
+        const a = attr;
+        if (a.type === "relation") {
+          const targetSchema = strapi.contentTypes[a.target];
+          const targetName = targetSchema?.info?.displayName || a.target;
+          return { name, type: "relation", target: targetName };
+        }
+        return { name, type: a.type };
+      }),
+      mainField: getMainField(schema) || ""
+    }));
+  }
+});
+const services = {
+  service,
+  settings
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+export {
+  index as default
+};

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

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

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

@@ -0,0 +1,5 @@
+declare const _default: {
+    default: {};
+    validator(): void;
+};
+export default _default;

package/dist/server/src/content-types/index.d.ts

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

package/dist/server/src/controllers/controller.d.ts

@@ -0,0 +1,7 @@
+import type { Core } from '@strapi/strapi';
+declare const controller: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    search(ctx: any): Promise<void>;
+};
+export default controller;

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

@@ -0,0 +1,14 @@
+declare const _default: {
+    controller: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        search(ctx: any): Promise<void>;
+    };
+    settings: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        getSettings(ctx: any): Promise<void>;
+        updateSettings(ctx: any): Promise<void>;
+    };
+};
+export default _default;

package/dist/server/src/controllers/settings.d.ts

@@ -0,0 +1,8 @@
+import type { Core } from '@strapi/strapi';
+declare const settings: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    getSettings(ctx: any): Promise<void>;
+    updateSettings(ctx: any): Promise<void>;
+};
+export default settings;

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

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