@paris-ias/list 1.0.112 → 1.0.113

package/dist/runtime/runtime/plugins/pinia.js

@@ -0,0 +1,134 @@
+import { createDynamicStore } from "../stores/factory.js";
+import { useRootStore } from "../stores/root.js";
+import { defineNuxtPlugin, useAppConfig } from "#app";
+export default defineNuxtPlugin(async (nuxtApp) => {
+  const appConfig = useAppConfig();
+  const moduleImports = {
+    events: () => ({
+      model: import("@paris-ias/data/dist/list/events.js"),
+      queries: {
+        list: import("../graphql/list/events.gql"),
+        get: import("../graphql/item/events.gql")
+      }
+    }),
+    news: () => ({
+      model: import("@paris-ias/data/dist/list/news.js"),
+      queries: {
+        list: import("../graphql/list/news.gql"),
+        get: import("../graphql/item/news.gql")
+      }
+    }),
+    people: () => ({
+      model: import("@paris-ias/data/dist/list/people.js"),
+      queries: {
+        list: import("../graphql/list/people.gql"),
+        get: import("../graphql/item/people.gql")
+      }
+    }),
+    projects: () => ({
+      model: import("@paris-ias/data/dist/list/projects.js"),
+      queries: {
+        list: import("../graphql/list/projects.gql"),
+        get: import("../graphql/item/projects.gql")
+      }
+    }),
+    fellowships: () => ({
+      model: import("@paris-ias/data/dist/list/fellowships.js"),
+      queries: {
+        list: import("../graphql/list/fellowships.gql"),
+        get: import("../graphql/item/fellowships.gql")
+      }
+    }),
+    publications: () => ({
+      model: import("@paris-ias/data/dist/list/publications.js"),
+      queries: {
+        list: import("../graphql/list/publications.gql"),
+        get: import("../graphql/item/publications.gql")
+      }
+    }),
+    actions: () => ({
+      model: import("@paris-ias/data/dist/list/action.js"),
+      queries: {
+        list: import("../graphql/list/action.gql"),
+        get: import("../graphql/item/action.gql")
+      }
+    }),
+    affiliations: () => ({
+      model: import("@paris-ias/data/dist/list/affiliations.js"),
+      queries: {
+        list: import("../graphql/list/affiliations.gql"),
+        get: import("../graphql/item/affiliations.gql")
+      }
+    }),
+    disciplines: () => ({
+      model: import("@paris-ias/data/dist/list/disciplines.js"),
+      queries: {
+        list: import("../graphql/list/disciplines.gql"),
+        get: import("../graphql/item/disciplines.gql")
+      }
+    }),
+    files: () => ({
+      model: import("@paris-ias/data/dist/list/files.js"),
+      queries: {
+        list: import("../graphql/list/files.gql"),
+        get: import("../graphql/item/files.gql")
+      }
+    }),
+    mailing: () => ({
+      model: import("@paris-ias/data/dist/list/mailing.js"),
+      queries: {
+        list: import("../graphql/list/mailing.gql"),
+        get: import("../graphql/item/mailing.gql")
+      }
+    }),
+    tags: () => ({
+      model: import("@paris-ias/data/dist/list/tags.js"),
+      queries: {
+        list: import("../graphql/list/tags.gql"),
+        get: import("../graphql/item/tags.gql")
+      }
+    }),
+    apps: () => ({
+      model: import("@paris-ias/data/dist/list/apps.js"),
+      queries: {
+        list: import("../graphql/list/apps.gql"),
+        get: import("../graphql/item/apps.gql")
+      }
+    }),
+    users: () => ({
+      model: import("@paris-ias/data/dist/list/users.js"),
+      queries: {
+        list: import("../graphql/list/users.gql"),
+        get: import("../graphql/item/users.gql")
+      }
+    })
+    // Add other modules similarly...
+  };
+  const stores = {};
+  const queries = {};
+  const models = {};
+  const builtFilters = await import("../public/filters.json");
+  console.log("INITIALIZING STORES");
+  await Promise.all(
+    appConfig.list.modules.map(async (type) => {
+      try {
+        const imports = await moduleImports[type]();
+        const model = (await imports.model).default;
+        queries[type] = {
+          list: (await imports.queries.list).default,
+          get: (await imports.queries.get).default
+        };
+        models[type] = model;
+        stores[type] = createDynamicStore(type, model)();
+      } catch (error) {
+        console.error(`Failed to initialize ${type} store:`, error);
+      }
+    })
+  );
+  const rootStore = useRootStore();
+  nuxtApp.provide("models", models);
+  nuxtApp.provide("rootStore", rootStore);
+  nuxtApp.provide("stores", stores);
+  nuxtApp.provide("queries", queries);
+  nuxtApp.provide("filters", builtFilters);
+});

package/dist/runtime/runtime/plugins/vuetify.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/runtime/plugins/vuetify.js

@@ -0,0 +1,21 @@
+import { createVuetify } from "vuetify";
+import * as components from "vuetify/components";
+import * as directives from "vuetify/directives";
+import { defineNuxtPlugin } from "nuxt/app";
+export default defineNuxtPlugin((nuxtApp) => {
+  const vuetify = createVuetify({
+    ssr: true,
+    components,
+    directives,
+    mobileBreakpoint: "sm",
+    /*  thresholds: {
+      xs: 0,
+      sm: 340,
+      md: 540,
+      lg: 800,
+      xl: 1280,
+    }, */
+  });
+
+  nuxtApp.vueApp.use(vuetify);
+});

package/dist/runtime/runtime/public/filters.json

@@ -0,0 +1,72 @@
+{
+  "events": {
+    "disciplines": [
+      "archeology",
+      "architecture-and-spatial-planning",
+      "art-and-art-history",
+      "classical-studies",
+      "cultural-heritage-and-museology",
+      "digital-humanities",
+      "economics-and-finance",
+      "education",
+      "environment",
+      "gender-studies",
+      "geography",
+      "history",
+      "history-philosophy-and-sociology-of-science",
+      "information-and-communication-studies",
+      "law",
+      "linguistics",
+      "literature",
+      "medicine-pharmacy",
+      "music-musicology-and-performance-arts",
+      "neuroscience",
+      "others",
+      "philosophy",
+      "physics-and-mathematics",
+      "political-science",
+      "psychology",
+      "religious-studies",
+      "sciences-of-the-universe",
+      "social-anthropology-and-ethnology",
+      "sociology"
+    ],
+    "fellowships": [],
+    "tags": [],
+    "category": [
+      "CALL",
+      "COLLOQUIUM",
+      "CONFERENCE",
+      "CONFERENCE_CYCLE",
+      "EXHIBITION",
+      "LECTURE",
+      "OTHER",
+      "SEMINAR"
+    ]
+  },
+  "fellowships": { "disciplines": [], "tags": [], "affiliations": [] },
+  "news": { "tags": [], "category": ["LIFE_AT_THE_INSTITUTE", "VIDEO"] },
+  "projects": { "tags": [] },
+  "people": {
+    "disciplines": [],
+    "fellowships": [],
+    "vintage": [
+      2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018,
+      2019, 2020, 2021, 2022, 2023, 2024, 2025
+    ],
+    "members": []
+  },
+  "publications": {
+    "affiliations": [],
+    "disciplines": [],
+    "tags": [],
+    "type": ["ARTICLE", "VIDEO"],
+    "eventCategory": [
+      "COLLOQUIUM",
+      "CONFERENCE",
+      "CONFERENCE_CYCLE",
+      "LECTURE",
+      "OTHER"
+    ]
+  }
+}

package/dist/runtime/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

package/dist/runtime/runtime/stores/factory.d.ts

@@ -0,0 +1,25 @@
+export declare const createDynamicStore: (storeName: string, moduleState: object) => import("pinia").StoreDefinition<string, Pick<{
+    loading: import("vue").Ref<boolean, boolean>;
+    total: import("vue").Ref<number, number>;
+    skip: import("vue").Ref<number, number>;
+    page: import("vue").Ref<number, number>;
+    numberOfPages: import("vue").Ref<number, number>;
+    search: import("vue").Ref<string, string>;
+    error: import("vue").Ref<string | null, string | null>;
+}, "error" | "search" | "loading" | "total" | "skip" | "page" | "numberOfPages">, Pick<{
+    loading: import("vue").Ref<boolean, boolean>;
+    total: import("vue").Ref<number, number>;
+    skip: import("vue").Ref<number, number>;
+    page: import("vue").Ref<number, number>;
+    numberOfPages: import("vue").Ref<number, number>;
+    search: import("vue").Ref<string, string>;
+    error: import("vue").Ref<string | null, string | null>;
+}, never>, Pick<{
+    loading: import("vue").Ref<boolean, boolean>;
+    total: import("vue").Ref<number, number>;
+    skip: import("vue").Ref<number, number>;
+    page: import("vue").Ref<number, number>;
+    numberOfPages: import("vue").Ref<number, number>;
+    search: import("vue").Ref<string, string>;
+    error: import("vue").Ref<string | null, string | null>;
+}, never>>;

package/dist/runtime/runtime/stores/factory.js

@@ -0,0 +1,19 @@
+import { defineStore } from "pinia";
+import { reactive, toRefs } from "vue";
+export const createDynamicStore = (storeName, moduleState) => {
+  return defineStore(storeName, () => {
+    const state = reactive({
+      loading: false,
+      total: 0,
+      skip: 0,
+      page: 1,
+      numberOfPages: 0,
+      search: "",
+      error: null,
+      ...moduleState
+    });
+    return {
+      ...toRefs(state)
+    };
+  });
+};

package/dist/runtime/runtime/stores/root.d.ts

@@ -0,0 +1,60 @@
+interface SearchResults {
+    events: Record<string, unknown>;
+    news: Record<string, unknown>;
+    people: Record<string, unknown>;
+    projects: Record<string, unknown>;
+    fellowships: Record<string, unknown>;
+    publications: Record<string, unknown>;
+    actions: Record<string, unknown>;
+    affiliations: Record<string, unknown>;
+    disciplines: Record<string, unknown>;
+    files: Record<string, unknown>;
+    mailing: Record<string, unknown>;
+    tags: Record<string, unknown>;
+}
+interface RootStoreState {
+    scrolled: boolean;
+    loading: boolean;
+    total: number;
+    skip: number;
+    page: number;
+    numberOfPages: number;
+    search: string;
+    results: SearchResults;
+}
+export declare const useRootStore: import("pinia").StoreDefinition<"rootStore", RootStoreState, {}, {
+    setLoading(value: boolean, type?: string): void;
+    setScrolled(): void;
+    loadRouteQuery(type: string): void;
+    setFiltersCount(type: string): void;
+    updateRouteQuery(type: string): void;
+    resetState(type: string, lang: string): void;
+    updateSort({ value, type, lang, }: {
+        value: (number | string)[];
+        type: string;
+        lang?: string;
+    }): void;
+    updateView({ value, type, lang, }: {
+        value: string;
+        type: string;
+        lang?: string;
+    }): void;
+    updateFilter(key: string, val: unknown, type: string, lang: string): void;
+    updateItemsPerPage({ value, type, lang, }: {
+        value: number;
+        type: string;
+        lang?: string;
+    }): void;
+    updatePage({ page, type, lang, }: {
+        page: number;
+        type: string;
+        lang?: string;
+    }): Promise<void>;
+    updateSearch({ type, search, lang, }: {
+        type: string;
+        search: string;
+        lang: string;
+    }): Promise<void>;
+    update(type: string, lang?: string): Promise<boolean>;
+}>;
+export {};

package/dist/runtime/runtime/stores/root.js

@@ -0,0 +1,315 @@
+import { defineStore } from "pinia";
+import SEARCH from "../graphql/list/search.gql";
+import { useNuxtApp, useRouter, useAsyncQuery } from "#imports";
+export const useRootStore = defineStore("rootStore", {
+  state: () => ({
+    scrolled: typeof window !== "undefined" ? window.scrollY > 0 : false,
+    loading: false,
+    total: 0,
+    skip: 0,
+    page: 1,
+    numberOfPages: 0,
+    search: "",
+    results: {
+      events: {},
+      news: {},
+      people: {},
+      projects: {},
+      fellowships: {},
+      publications: {},
+      actions: {},
+      affiliations: {},
+      disciplines: {},
+      files: {},
+      mailing: {},
+      tags: {}
+    }
+  }),
+  actions: {
+    setLoading(value, type = "") {
+      console.log("setLoading", { value, type });
+      const { $stores } = useNuxtApp();
+      this.loading = value;
+      if (type.length && type !== "all" && $stores[type]) {
+        $stores[type].loading = value;
+      }
+    },
+    setScrolled() {
+      if (typeof window !== "undefined") {
+        this.scrolled = window.scrollY > 0;
+      }
+    },
+    /*     saveFiltersToLocalStorage(type: string): void {
+          const { $stores } = useNuxtApp() as {
+            $stores: Record<string, ModuleStore>;
+          };
+          const filters = $stores[type]?.filters ?? {};
+          const values = Object.fromEntries(
+            Object.entries(filters).map(([key, filter]) => [key, filter.value])
+          );
+    
+          const local = JSON.parse(localStorage.getItem("PARIS_IAS") || "{}");
+          local[`${type}_filters`] = values;
+          localStorage.setItem("PARIS_IAS", JSON.stringify(local));
+        }, */
+    loadRouteQuery(type) {
+      console.log("loadRouteQuery", type);
+      const { $stores } = useNuxtApp();
+      const { currentRoute } = useRouter();
+      const query = currentRoute.value.query;
+      const filters = $stores[type]?.filters ?? {};
+      console.log("filters: ", filters);
+      if (Object.keys(query)?.length) {
+        Object.keys(query).forEach((filter) => {
+          if (filter in filters) {
+            console.log("filter: ", filter, query[filter]);
+            const queryValue = query[filter];
+            if (typeof queryValue === "string") {
+              filters[filter].value = filters[filter].multiple ? JSON.parse(queryValue) : queryValue;
+            }
+          } else {
+            console.log("unknown filter: ", filter);
+          }
+        });
+      }
+      console.log("query loaded");
+    },
+    /*  loadFiltersFromLocalStorage(type: string): void {
+          const { $stores } = useNuxtApp() as {
+            $stores: Record<string, ModuleStore>
+          }
+          const local = JSON.parse(localStorage.getItem("PARIS_IAS") || "{}")
+          const saved = local[`${type}_filters`] ?? null
+    
+          if (!saved) {
+            console.log(`[${type}] No data to restore.`)
+            return
+          }
+    
+          const filters = $stores[type]?.filters ?? {}
+          for (const [key, value] of Object.entries(saved)) {
+            if (filters[key]) {
+              filters[key].value = value
+            }
+          }
+    
+          this.setFiltersCount(type)
+          this.updateRouteQuery(type)
+          console.log(`[${type}] Filters restored from localStorage`, saved)
+        }, */
+    setFiltersCount(type) {
+      console.log("setFiltersCount", type);
+      const { $stores } = useNuxtApp();
+      const filters = $stores[type]?.filters ?? {};
+      const count = Object.values(filters).reduce((acc, filter) => {
+        const value = filter?.value;
+        const isEmpty = value === void 0 || value === null || Array.isArray(value) && value.length === 0 || typeof value === "string" && value.trim() === "";
+        return isEmpty ? acc : acc + 1;
+      }, 0);
+      if ($stores[type]) {
+        $stores[type].filtersCount = count;
+      }
+    },
+    updateRouteQuery(type) {
+      console.log("updateRouteQuery", type);
+      const router = useRouter();
+      const { $stores } = useNuxtApp();
+      const routeQuery = {
+        ...this.search ? { search: this.search } : {},
+        ...this.page > 1 ? { page: this.page.toString() } : {},
+        ...Object.entries($stores[type]?.filters ?? {}).reduce(
+          (acc, [key, filter]) => {
+            const value = filter?.value;
+            const isEmpty = value === void 0 || value === null || value === false || Array.isArray(value) && value.length === 0 || typeof value === "string" && value.trim() === "";
+            if (isEmpty) return acc;
+            return {
+              ...acc,
+              [key]: Array.isArray(value) ? JSON.stringify(value) : String(value)
+            };
+          },
+          {}
+        )
+      };
+      router.replace({ query: routeQuery });
+    },
+    async resetState(type, lang) {
+      console.log("resetState", { type, lang });
+      const { $stores, $models } = useNuxtApp();
+      console.log("$models[type]: ", $models[type]);
+      console.log("$stores[type]: ", $stores[type]);
+      if ($models[type] && $stores[type]) {
+        $stores[type].filters = $models[type].filters;
+      }
+      console.log("resetState");
+      this.search = "";
+      this.page = 1;
+      this.scrolled = false;
+      this.loading = false;
+      this.total = 0;
+      this.skip = 0;
+      this.numberOfPages = 0;
+      await this.update(type, lang);
+    },
+    async updateSort({
+      value,
+      type,
+      lang = "en"
+    }) {
+      console.log("updateSort", {
+        value,
+        type
+      });
+      const { $stores } = useNuxtApp();
+      if ($stores[type]) {
+        $stores[type].sortBy = [String(value[0])];
+        $stores[type].sortDesc = [Number(value[1])];
+      }
+      this.page = 1;
+      await this.update(type, lang);
+    },
+    async updateView({
+      value,
+      type,
+      lang
+    }) {
+      console.log("updateView", { value, type });
+      const { $stores } = useNuxtApp();
+      if ($stores[type]?.views?.[value]) {
+        $stores[type].view = {
+          ...$stores[type].views[value],
+          name: value
+        };
+      }
+      await this.update(type, lang);
+    },
+    /*     updateLocalStorage(key: string, value: string): void {
+      const local = JSON.parse(localStorage.getItem("PARIS_IAS") || "{}")
+      local[key] = value
+      localStorage.setItem("PARIS_IAS", JSON.stringify(local))
+    }, */
+    async updateFilter(key, val, type, lang) {
+      const { $stores } = useNuxtApp();
+      console.log("update filter: ", { key, val, type });
+      if ($stores[type]?.filters?.[key]) {
+        $stores[type].filters[key].value = val;
+      }
+      this.page = 1;
+      await this.update(type, lang);
+    },
+    async updateItemsPerPage({
+      value,
+      type,
+      lang
+    }) {
+      console.log("updateItemsPerPage", { value, type });
+      const { $stores } = useNuxtApp();
+      this.page = 1;
+      if ($stores[type]) {
+        $stores[type].itemsPerPage = value;
+      }
+      await this.update(type, lang);
+    },
+    async updatePage({
+      page,
+      type,
+      lang = "en"
+    }) {
+      console.log("updatePage", { page, type });
+      const router = useRouter();
+      const currentQuery = router.currentRoute.value.query;
+      const newQuery = { ...currentQuery };
+      if (page > 1) {
+        newQuery.page = page.toString();
+      } else {
+        delete newQuery.page;
+      }
+      this.page = page;
+      await this.update(type, lang);
+    },
+    /* 
+    initializePageFromRoute(): void {
+      const { query } = useRouter().currentRoute.value
+      const page = Number.parseInt(query.page as string, 10)
+      this.page = isNaN(page) || page < 1 ? 1 : page
+    }, */
+    async updateSearch({
+      type = "all",
+      search = "",
+      lang = "en"
+    }) {
+      console.log("updateSearch", { type, search, lang });
+      this.search = search;
+      await this.update(type, lang);
+    },
+    async update(type, lang = "en") {
+      const { $stores, $queries } = useNuxtApp();
+      console.log("update", { type, lang });
+      this.setLoading(true);
+      if (type !== "all" && $stores[type]) {
+        $stores[type].loading = true;
+      }
+      const itemsPerPage = type === "all" ? 3 : $stores[type]?.itemsPerPage || 10;
+      const filters = {};
+      if (type !== "all") {
+        const storeFilters = $stores[type]?.filters ?? {};
+        for (const filter in storeFilters) {
+          const filterValue = storeFilters[filter]?.value;
+          if (typeof filterValue !== "undefined" && filterValue !== null && (Array.isArray(filterValue) ? filterValue.length > 0 : true)) {
+            filters[filter] = filterValue;
+          }
+        }
+      }
+      const args = JSON.parse(
+        JSON.stringify({
+          options: {
+            // skip
+            skip: +this.page === 1 ? 0 : (+this.page - 1) * itemsPerPage,
+            // limit
+            limit: itemsPerPage,
+            // sort, array of keys and array of directions - to have x tie breakers if necessary
+            sortBy: type === "all" ? "searchScore" : $stores[type]?.sortBy || ["created"],
+            sortDesc: type === "all" ? -1 : ($stores[type]?.sortDesc?.[0] || 0) > 0 ? true : false,
+            // search (if set)
+            ...this.search?.length && type !== "all" && { search: this.search },
+            // add the store module filters
+            filters
+          },
+          ...this.search?.length && type === "all" && { search: this.search },
+          appId: "iea",
+          lang
+        })
+      );
+      args.options.filters = JSON.stringify(args.options.filters);
+      console.log("args: ", args);
+      const { data, error } = await useAsyncQuery(
+        type === "all" ? SEARCH : $queries[type]?.list,
+        args
+      );
+      console.log("data: ", data);
+      if (error.value) console.log(error.value);
+      const key = type === "all" ? "search" : "list" + type.charAt(0).toUpperCase() + type.slice(1);
+      if (type === "all") {
+        this.results = data?.value?.[key] || this.results;
+      } else {
+        const items = data?.value?.[key]?.items ?? [];
+        if ($stores[type]) {
+          $stores[type].total = data?.value?.[key]?.total || 0;
+          const result = {
+            ...data?.value?.[key],
+            items: items.map(({ id, ...rest }) => ({
+              ...rest,
+              _path: `/${id}`
+            }))
+          };
+          $stores[type].items = result.items;
+          const lastPage = Math.ceil((result.total || 0) / itemsPerPage);
+          this.setFiltersCount(type);
+          $stores[type].numberOfPages = lastPage;
+        }
+      }
+      this.updateRouteQuery(type);
+      this.setLoading(false, type);
+      return true;
+    }
+  }
+});