gavaengine 0.1.2 → 1.2.0

package/dist/auth/index.d.ts

@@ -0,0 +1,42 @@
+import { G as GEAuthAdapter } from '../types-d8-k_4dN.js';
+export { a as GEAuthSession, b as GEAuthUser } from '../types-d8-k_4dN.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+interface NextAuthFunctions {
+    auth: () => Promise<any>;
+    signIn?: (provider: string, credentials: Record<string, unknown>) => Promise<any>;
+    signOut?: () => Promise<void>;
+}
+declare function createNextAuthAdapter({ auth, signIn, signOut, }: NextAuthFunctions): GEAuthAdapter;
+
+interface GEAuthUser {
+    id: string;
+    name?: string | null;
+    email?: string | null;
+    role: string;
+}
+interface GEAuthSession {
+    user: GEAuthUser;
+}
+interface GEAuthContextValue {
+    session: GEAuthSession | null;
+    user: GEAuthUser | null;
+    status: "loading" | "authenticated" | "unauthenticated";
+    signIn?: (credentials: Record<string, unknown>) => Promise<{
+        error?: string;
+    } | void>;
+    signOut?: () => Promise<void>;
+}
+declare function useGavaAuth(): GEAuthContextValue;
+interface AuthProviderProps {
+    children: ReactNode;
+    getSession: () => Promise<GEAuthSession | null>;
+    signIn?: (credentials: Record<string, unknown>) => Promise<{
+        error?: string;
+    } | void>;
+    signOut?: () => Promise<void>;
+}
+declare function AuthProvider({ children, getSession, signIn, signOut, }: AuthProviderProps): react_jsx_runtime.JSX.Element;
+
+export { AuthProvider, GEAuthAdapter, createNextAuthAdapter, useGavaAuth };

package/dist/auth/index.js

@@ -0,0 +1,12 @@
+"use client";
+import {
+  AuthProvider,
+  createNextAuthAdapter,
+  useGavaAuth
+} from "../chunk-QO42DDRU.js";
+export {
+  AuthProvider,
+  createNextAuthAdapter,
+  useGavaAuth
+};
+//# sourceMappingURL=index.js.map

package/dist/auth/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/{chunk-D5PTZWTT.js → chunk-ICIFEKSX.js}

@@ -3,7 +3,7 @@ import {
   ActionsProvider,
   ConfigProvider,
   SplashProvider
-} from "./chunk-BVLJYZ6T.js";
+} from "./chunk-IK24OCFW.js";
 
 // src/providers/GavaEngineProvider.tsx
 import { useRouter } from "next/navigation";
@@ -64,4 +64,4 @@ export {
   GavaEngineProvider,
   ThemeToggle
 };
-//# sourceMappingURL=chunk-D5PTZWTT.js.map
+//# sourceMappingURL=chunk-ICIFEKSX.js.map

package/dist/chunk-IK24OCFW.js

@@ -0,0 +1,534 @@
+"use client";
+
+// src/i18n/it.ts
+var it = {
+  content: {
+    articles: "Articoli",
+    newArticle: "Nuovo articolo",
+    titlePlaceholder: "Titolo dell'articolo",
+    excerptPlaceholder: "Breve descrizione dell'articolo...",
+    slugPlaceholder: "slug-articolo",
+    authorPlaceholder: "Nome dell'autore",
+    category: "Categoria",
+    selectCategory: "Seleziona categoria",
+    excerpt: "Estratto",
+    author: "Autore",
+    slugUrl: "Slug URL",
+    noArticles: "Nessun articolo.",
+    noArticlesSearch: "Nessun articolo trovato.",
+    searchArticles: "Cerca articoli...",
+    coverImageLabel: "Immagine di copertina",
+    coverImageHint: "Scegli dalla libreria o carica un nuovo file",
+    viewArticle: "Vedi articolo pubblicato",
+    untitled: "Senza titolo"
+  },
+  editor: {
+    publish: "Pubblica",
+    unpublish: "Ritira",
+    saveDraft: "Salva bozza",
+    revisions: "Cronologia",
+    saving: "Salvando...",
+    saved: "Salvato",
+    saveError: "Errore nel salvataggio",
+    noRevisions: "Nessuna revisione salvata.",
+    restore: "Ripristina",
+    restoreConfirm: "Ripristinare questa revisione? Lo stato attuale verr\xE0 salvato prima del ripristino.",
+    beforeRestore: "Prima del ripristino",
+    publishedNote: "Pubblicato",
+    preview: "Anteprima",
+    placeholder: "Inizia a scrivere il tuo articolo..."
+  },
+  media: {
+    media: "Media",
+    noMedia: "Nessun file caricato.",
+    noMediaSearch: "Nessun file trovato.",
+    chooseFile: "Scegli file",
+    dragHint: "Trascina un'immagine qui oppure",
+    uploadHint: "JPEG, PNG, WebP, GIF (max 5MB)",
+    mediaLibrary: "Libreria media",
+    uploadNew: "Carica nuovo",
+    searchFiles: "Cerca file...",
+    selectImage: "Seleziona immagine",
+    noImages: "Nessuna immagine nella libreria.",
+    noImagesSearch: "Nessuna immagine trovata.",
+    copyUrl: "Copia URL",
+    editImage: "Modifica immagine",
+    restoreOriginal: "Ripristina originale",
+    freeAspect: "Libero"
+  },
+  users: {
+    users: "Utenti",
+    name: "Nome",
+    email: "Email",
+    password: "Password",
+    passwordEditHint: " (lascia vuoto per non modificarla)",
+    role: "Ruolo",
+    createdAt: "Creato il",
+    actions: "Azioni",
+    createUser: "Crea utente",
+    unauthorized: "Non autorizzato",
+    notAuthenticated: "Non autenticato",
+    allFieldsRequired: "Tutti i campi sono obbligatori.",
+    passwordMinLength: "La password deve avere almeno 6 caratteri.",
+    emailExists: "Esiste gi\xE0 un utente con questa email.",
+    invalidRole: "Ruolo non valido.",
+    cannotDeleteSelf: "Non puoi eliminare il tuo stesso account."
+  },
+  common: {
+    statistics: "Statistiche",
+    settings: "Impostazioni",
+    delete: "Elimina",
+    edit: "Modifica",
+    search: "Cerca",
+    draft: "Bozza",
+    published: "Pubblicato",
+    all: "Tutti",
+    drafts: "Bozze",
+    loading: "Caricamento...",
+    confirm: "Conferma",
+    cancel: "Annulla",
+    apply: "Applica",
+    change: "Cambia",
+    logout: "Esci",
+    saveChanges: "Salva modifiche",
+    updated: "Aggiornato",
+    status: "Stato",
+    title: "Titolo",
+    deleteConfirm: (title) => `Eliminare "${title || "Senza titolo"}"?`,
+    unpublishConfirm: (title) => `Ritirare "${title || "Senza titolo"}"? L'articolo torner\xE0 in bozza.`,
+    deleteUserConfirm: (name) => `Sei sicuro di voler eliminare l'utente "${name}"?`,
+    totalArticles: (count) => `${count} articol${count === 1 ? "o" : "i"} totali`,
+    totalFiles: (count) => `${count} file caricati`
+  }
+};
+
+// src/i18n/en.ts
+var en = {
+  content: {
+    articles: "Articles",
+    newArticle: "New article",
+    titlePlaceholder: "Article title",
+    excerptPlaceholder: "Brief description of the article...",
+    slugPlaceholder: "article-slug",
+    authorPlaceholder: "Author name",
+    category: "Category",
+    selectCategory: "Select category",
+    excerpt: "Excerpt",
+    author: "Author",
+    slugUrl: "URL Slug",
+    noArticles: "No articles.",
+    noArticlesSearch: "No articles found.",
+    searchArticles: "Search articles...",
+    coverImageLabel: "Cover image",
+    coverImageHint: "Choose from library or upload a new file",
+    viewArticle: "View published article",
+    untitled: "Untitled"
+  },
+  editor: {
+    publish: "Publish",
+    unpublish: "Unpublish",
+    saveDraft: "Save draft",
+    revisions: "History",
+    saving: "Saving...",
+    saved: "Saved",
+    saveError: "Error saving",
+    noRevisions: "No revisions saved.",
+    restore: "Restore",
+    restoreConfirm: "Restore this revision? The current state will be saved before restoring.",
+    beforeRestore: "Before restore",
+    publishedNote: "Published",
+    preview: "Preview",
+    placeholder: "Start writing your article..."
+  },
+  media: {
+    media: "Media",
+    noMedia: "No files uploaded.",
+    noMediaSearch: "No files found.",
+    chooseFile: "Choose file",
+    dragHint: "Drag an image here or",
+    uploadHint: "JPEG, PNG, WebP, GIF (max 5MB)",
+    mediaLibrary: "Media library",
+    uploadNew: "Upload new",
+    searchFiles: "Search files...",
+    selectImage: "Select image",
+    noImages: "No images in library.",
+    noImagesSearch: "No images found.",
+    copyUrl: "Copy URL",
+    editImage: "Edit image",
+    restoreOriginal: "Restore original",
+    freeAspect: "Free"
+  },
+  users: {
+    users: "Users",
+    name: "Name",
+    email: "Email",
+    password: "Password",
+    passwordEditHint: " (leave blank to keep current)",
+    role: "Role",
+    createdAt: "Created at",
+    actions: "Actions",
+    createUser: "Create user",
+    unauthorized: "Unauthorized",
+    notAuthenticated: "Not authenticated",
+    allFieldsRequired: "All fields are required.",
+    passwordMinLength: "Password must be at least 6 characters.",
+    emailExists: "A user with this email already exists.",
+    invalidRole: "Invalid role.",
+    cannotDeleteSelf: "You cannot delete your own account."
+  },
+  common: {
+    statistics: "Statistics",
+    settings: "Settings",
+    delete: "Delete",
+    edit: "Edit",
+    search: "Search",
+    draft: "Draft",
+    published: "Published",
+    all: "All",
+    drafts: "Drafts",
+    loading: "Loading...",
+    confirm: "Confirm",
+    cancel: "Cancel",
+    apply: "Apply",
+    change: "Change",
+    logout: "Logout",
+    saveChanges: "Save changes",
+    updated: "Updated",
+    status: "Status",
+    title: "Title",
+    deleteConfirm: (title) => `Delete "${title || "Untitled"}"?`,
+    unpublishConfirm: (title) => `Unpublish "${title || "Untitled"}"? The article will go back to draft.`,
+    deleteUserConfirm: (name) => `Are you sure you want to delete user "${name}"?`,
+    totalArticles: (count) => `${count} total article${count === 1 ? "" : "s"}`,
+    totalFiles: (count) => `${count} uploaded file${count === 1 ? "" : "s"}`
+  }
+};
+
+// src/i18n/index.ts
+var builtinLocales = { it, en };
+function loadLocale(locale) {
+  const found = builtinLocales[locale];
+  if (!found) {
+    throw new Error(
+      `Locale "${locale}" not found. Available: ${Object.keys(builtinLocales).join(", ")}`
+    );
+  }
+  return found;
+}
+function defineLocale(locale) {
+  return locale;
+}
+function mergeLocales(base, overrides) {
+  return deepMergeLocale(base, overrides);
+}
+function registerLocale(key, locale) {
+  builtinLocales[key] = locale;
+}
+function deepMergeLocale(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = target[key];
+    if (sourceVal && typeof sourceVal === "object" && !Array.isArray(sourceVal) && typeof targetVal === "object" && !Array.isArray(targetVal) && typeof sourceVal !== "function") {
+      result[key] = deepMergeLocale(
+        targetVal,
+        sourceVal
+      );
+    } else if (sourceVal !== void 0) {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+
+// src/config.ts
+function localeToStrings(locale) {
+  return {
+    // content
+    articles: locale.content.articles,
+    newArticle: locale.content.newArticle,
+    titlePlaceholder: locale.content.titlePlaceholder,
+    excerptPlaceholder: locale.content.excerptPlaceholder,
+    slugPlaceholder: locale.content.slugPlaceholder,
+    authorPlaceholder: locale.content.authorPlaceholder,
+    category: locale.content.category,
+    selectCategory: locale.content.selectCategory,
+    excerpt: locale.content.excerpt,
+    author: locale.content.author,
+    slugUrl: locale.content.slugUrl,
+    noArticles: locale.content.noArticles,
+    noArticlesSearch: locale.content.noArticlesSearch,
+    searchArticles: locale.content.searchArticles,
+    coverImageLabel: locale.content.coverImageLabel,
+    coverImageHint: locale.content.coverImageHint,
+    viewArticle: locale.content.viewArticle,
+    untitled: locale.content.untitled,
+    // editor
+    publish: locale.editor.publish,
+    unpublish: locale.editor.unpublish,
+    saveDraft: locale.editor.saveDraft,
+    revisions: locale.editor.revisions,
+    saving: locale.editor.saving,
+    saved: locale.editor.saved,
+    saveError: locale.editor.saveError,
+    noRevisions: locale.editor.noRevisions,
+    restore: locale.editor.restore,
+    restoreConfirm: locale.editor.restoreConfirm,
+    beforeRestore: locale.editor.beforeRestore,
+    publishedNote: locale.editor.publishedNote,
+    preview: locale.editor.preview,
+    // media
+    media: locale.media.media,
+    noMedia: locale.media.noMedia,
+    noMediaSearch: locale.media.noMediaSearch,
+    chooseFile: locale.media.chooseFile,
+    dragHint: locale.media.dragHint,
+    uploadHint: locale.media.uploadHint,
+    mediaLibrary: locale.media.mediaLibrary,
+    uploadNew: locale.media.uploadNew,
+    searchFiles: locale.media.searchFiles,
+    selectImage: locale.media.selectImage,
+    noImages: locale.media.noImages,
+    noImagesSearch: locale.media.noImagesSearch,
+    copyUrl: locale.media.copyUrl,
+    editImage: locale.media.editImage,
+    restoreOriginal: locale.media.restoreOriginal,
+    freeAspect: locale.media.freeAspect,
+    // users
+    users: locale.users.users,
+    name: locale.users.name,
+    email: locale.users.email,
+    password: locale.users.password,
+    passwordEditHint: locale.users.passwordEditHint,
+    role: locale.users.role,
+    createdAt: locale.users.createdAt,
+    actions: locale.users.actions,
+    createUser: locale.users.createUser,
+    unauthorized: locale.users.unauthorized,
+    notAuthenticated: locale.users.notAuthenticated,
+    allFieldsRequired: locale.users.allFieldsRequired,
+    passwordMinLength: locale.users.passwordMinLength,
+    emailExists: locale.users.emailExists,
+    invalidRole: locale.users.invalidRole,
+    cannotDeleteSelf: locale.users.cannotDeleteSelf,
+    // common
+    statistics: locale.common.statistics,
+    settings: locale.common.settings,
+    delete: locale.common.delete,
+    edit: locale.common.edit,
+    search: locale.common.search,
+    draft: locale.common.draft,
+    published: locale.common.published,
+    all: locale.common.all,
+    drafts: locale.common.drafts,
+    loading: locale.common.loading,
+    confirm: locale.common.confirm,
+    cancel: locale.common.cancel,
+    apply: locale.common.apply,
+    change: locale.common.change,
+    logout: locale.common.logout,
+    saveChanges: locale.common.saveChanges,
+    updated: locale.common.updated,
+    status: locale.common.status,
+    title: locale.common.title,
+    deleteConfirm: locale.common.deleteConfirm,
+    unpublishConfirm: locale.common.unpublishConfirm,
+    deleteUserConfirm: locale.common.deleteUserConfirm,
+    totalArticles: locale.common.totalArticles,
+    totalFiles: locale.common.totalFiles
+  };
+}
+var DEFAULT_STRINGS = localeToStrings(loadLocale("it"));
+var DEFAULT_CONFIG = {
+  branding: {
+    name: "GavaEngine"
+  },
+  roles: {
+    list: ["admin", "redattore", "scrittore", "lettore"],
+    labels: {
+      admin: "Amministratore",
+      redattore: "Redattore",
+      scrittore: "Scrittore",
+      lettore: "Lettore"
+    },
+    canEdit: (role) => role !== "lettore",
+    canPublish: (role) => role === "admin" || role === "redattore",
+    adminRole: "admin"
+  },
+  statuses: {
+    draft: "bozza",
+    published: "pubblicato"
+  },
+  locale: "it",
+  models: {
+    article: "article",
+    articleRevision: "articleRevision",
+    articleView: "articleView",
+    media: "media",
+    user: "user"
+  },
+  categories: [
+    "Cultura ed Intercultura",
+    "Fatti ed Eventi",
+    "Poeti e Prosatori",
+    "Famiglia, Istituzioni e Territorio",
+    "Amici del Meucci"
+  ],
+  upload: {
+    endpoint: "/api/upload",
+    imageTypes: ["image/jpeg", "image/png", "image/webp", "image/gif"],
+    videoTypes: ["video/mp4", "video/webm", "video/quicktime"],
+    maxImageSize: 5 * 1024 * 1024,
+    maxVideoSize: 50 * 1024 * 1024
+  },
+  editor: {
+    placeholder: "Inizia a scrivere il tuo articolo...",
+    autoSaveDelay: 2e3,
+    revisionThrottleMinutes: 5,
+    headingLevels: [2, 3]
+  },
+  routes: {
+    articles: "/dashboard/articoli",
+    articleEdit: (id) => `/dashboard/articoli/${id}`,
+    articleNew: "/dashboard/articoli/nuovo",
+    articleView: (slug) => `/articoli/${slug}`,
+    articlePreview: (id) => `/anteprima/${id}`,
+    users: "/dashboard/utenti",
+    userEdit: (id) => `/dashboard/utenti/${id}`,
+    userNew: "/dashboard/utenti/nuovo",
+    media: "/dashboard/media",
+    dashboard: "/dashboard",
+    login: "/login",
+    home: "/"
+  },
+  strings: DEFAULT_STRINGS
+};
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = target[key];
+    if (sourceVal && typeof sourceVal === "object" && !Array.isArray(sourceVal) && typeof targetVal === "object" && !Array.isArray(targetVal) && typeof sourceVal !== "function") {
+      result[key] = deepMerge(
+        targetVal,
+        sourceVal
+      );
+    } else if (sourceVal !== void 0) {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+function defineConfig(overrides = {}) {
+  const locale = overrides.locale ?? DEFAULT_CONFIG.locale;
+  const baseStrings = localeToStrings(loadLocale(locale));
+  const configWithLocale = {
+    ...DEFAULT_CONFIG,
+    strings: baseStrings
+  };
+  if (!overrides.editor?.placeholder) {
+    const localeData = loadLocale(locale);
+    configWithLocale.editor = {
+      ...configWithLocale.editor,
+      placeholder: localeData.editor.placeholder
+    };
+  }
+  return deepMerge(configWithLocale, overrides);
+}
+
+// src/providers/ConfigContext.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var ConfigContext = createContext(DEFAULT_CONFIG);
+function useGavaConfig() {
+  return useContext(ConfigContext);
+}
+function ConfigProvider({
+  config,
+  children
+}) {
+  return /* @__PURE__ */ jsx(ConfigContext.Provider, { value: config, children });
+}
+
+// src/providers/ActionsContext.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ActionsContext = createContext2(null);
+function useGavaActions() {
+  const ctx = useContext2(ActionsContext);
+  if (!ctx) {
+    throw new Error(
+      "useGavaActions must be used within a <GavaEngineProvider> with actions provided."
+    );
+  }
+  return ctx;
+}
+function ActionsProvider({
+  actions,
+  children
+}) {
+  return /* @__PURE__ */ jsx2(ActionsContext.Provider, { value: actions, children });
+}
+
+// src/providers/SplashContext.tsx
+import {
+  createContext as createContext3,
+  useContext as useContext3,
+  useState,
+  useCallback
+} from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var SplashContext = createContext3({
+  phase: "idle",
+  navigateWithSplash: () => {
+  },
+  openSplash: () => {
+  }
+});
+function useSplash() {
+  return useContext3(SplashContext);
+}
+function SplashProvider({
+  children,
+  navigate
+}) {
+  const [phase, setPhase] = useState("idle");
+  const navigateWithSplash = useCallback(
+    (url) => {
+      if (phase !== "idle") return;
+      setPhase("closing");
+      setTimeout(() => {
+        setPhase("closed");
+        navigate(url);
+      }, 700);
+    },
+    [phase, navigate]
+  );
+  const openSplash = useCallback(() => {
+    if (phase !== "closed") return;
+    requestAnimationFrame(() => {
+      setPhase("opening");
+      setTimeout(() => setPhase("idle"), 900);
+    });
+  }, [phase]);
+  return /* @__PURE__ */ jsx3(SplashContext.Provider, { value: { phase, navigateWithSplash, openSplash }, children });
+}
+
+export {
+  it,
+  en,
+  loadLocale,
+  defineLocale,
+  mergeLocales,
+  registerLocale,
+  localeToStrings,
+  DEFAULT_CONFIG,
+  defineConfig,
+  useGavaConfig,
+  ConfigProvider,
+  useGavaActions,
+  ActionsProvider,
+  useSplash,
+  SplashProvider
+};
+//# sourceMappingURL=chunk-IK24OCFW.js.map