@paris-ias/list 1.0.11 → 1.0.13

package/dist/runtime/components/publications/RowsItem.vue

@@ -1,4 +1,4 @@
-<template>
+<template>
   <v-col v-ripple cols="12" sm="6" md="4" lg="3" xl="2">
     <MiscAtomsImageContainer
       contain
@@ -82,24 +82,22 @@
     </div>
   </v-col>
   <v-divider />
-</template>
-
-<script setup>
-import { useDisplay } from "vuetify"
-const { name } = useDisplay()
-const { locale } = useI18n()
-const { $stores } = useNuxtApp()
-const router = useRouter()
-const localePath = useLocalePath()
-const props = defineProps({
-  item: {
-    type: Object,
-    default: () => {
-      return {}
-    },
-    required: true,
-  },
-})
-</script>
-
-<style lang="scss"></style>
+</template>
+
+<script setup>
+import { useDisplay } from "vuetify";
+const { name } = useDisplay();
+const { locale } = useI18n();
+const { $stores } = useNuxtApp();
+const router = useRouter();
+const localePath = useLocalePath();
+const props = defineProps({
+  item: {
+    type: Object,
+    default: () => {
+      return {};
+    },
+    required: true
+  }
+});
+</script>

package/dist/runtime/components/publications/View.vue

@@ -114,26 +114,20 @@
 </template>
 
 <script setup>
-import { useDisplay } from "vuetify"
-const { $stores } = useNuxtApp()
-const { name } = useDisplay()
-const { locale } = useI18n()
+import { useDisplay } from "vuetify";
+const { $stores } = useNuxtApp();
+const { name } = useDisplay();
+const { locale } = useI18n();
 const props = defineProps({
   item: {
     type: Object,
-    required: true,
+    required: true
   },
   loading: {
     type: Boolean,
     required: false,
-    default: false,
-  },
-})
-
-/* const { data: action } = await useAsyncData("actions", () =>
-  queryContent("/actions/" + locale.value)
-    .limit(1)
-    .find()
-) */
-$stores.publications.loading = false
+    default: false
+  }
+});
+$stores.publications.loading = false;
 </script>

package/dist/runtime/composables/useFetchItem.d.ts

@@ -0,0 +1,6 @@
+export declare const useFetchItem: () => {
+    fetchItem: <T>(payload: {
+        query: string;
+        key: string;
+    }) => Promise<T>;
+};

package/dist/runtime/composables/useFetchItem.js

@@ -0,0 +1,49 @@
+import { useRoute } from "vue-router";
+export const useFetchItem = () => {
+  const fetchItem = async (payload) => {
+    try {
+      const { locale } = useI18n();
+      const route = useRoute();
+      const variables = {
+        itemId: route.params.slug?.toString().trim(),
+        appId: "iea",
+        lang: locale.value
+      };
+      const { data, error } = await useAsyncQuery(payload.query, variables);
+      if (error.value) {
+        console.error("GraphQL error:", error.value);
+        throw error.value;
+      }
+      const item = data?.value[payload.key];
+      if (!item) {
+        throw createError({
+          statusCode: 404,
+          message: "Item not found in response"
+        });
+      }
+      const setI18nParams = useSetI18nParams();
+      if (!route.name.includes("people")) {
+        setI18nParams({
+          en: { slug: item.slug.en },
+          fr: { slug: item.slug.fr }
+        });
+      } else {
+        setI18nParams({
+          en: { slug: item.slug },
+          fr: { slug: item.slug }
+        });
+      }
+      return item;
+    } catch (error) {
+      console.error("Error fetching item:", error);
+      throw createError({
+        statusCode: 404,
+        message: "Item not found",
+        cause: error
+      });
+    }
+  };
+  return {
+    fetchItem
+  };
+};

package/dist/runtime/composables/useIcons.d.ts

@@ -0,0 +1 @@
+export default function getFileIcon(fileName: string): string;

package/dist/runtime/composables/useIcons.js

@@ -0,0 +1,30 @@
+export default function getFileIcon(fileName) {
+  console.log("fileName: ", fileName);
+  const fileExtension = fileName.split(".").pop();
+  console.log("fileExtension: ", fileExtension);
+  switch (fileExtension) {
+    case "pdf":
+      return "mdi-file-pdf-box";
+    case "doc":
+    case "docx":
+      return "mdi-file-word";
+    case "xls":
+    case "xlsx":
+      return "mdi-file-excel";
+    case "ppt":
+    case "pptx":
+      return "mdi-file-powerpoint";
+    case "jpg":
+    case "jpeg":
+    case "png":
+    case "gif":
+      return "mdi-file-image";
+    case "zip":
+    case "rar":
+      return "mdi-folder-zip";
+    case "txt":
+      return "mdi-file-document";
+    default:
+      return "mdi-file";
+  }
+}

package/dist/runtime/composables/useUtils.d.ts

@@ -0,0 +1,12 @@
+export declare const formatDate: (dateStr: string, locale: string) => string;
+export declare const getLocalizedDate: (dateIso: string) => string;
+export declare const getDetailedFormatedDate: (dateStr: string, locale: string) => {
+    day: number;
+    month: string;
+    year: number;
+    hours: number;
+    minutes: number;
+};
+export declare const capitalize: (value: string, multiple?: boolean) => string;
+export declare const slugify: (str: string) => string;
+export declare const formatDateValue: (date: string | Date, locale: string) => string;

package/dist/runtime/composables/useUtils.js

@@ -0,0 +1,47 @@
+export const formatDate = (dateStr, locale) => {
+  const date = new Date(dateStr);
+  return date.toLocaleDateString(locale, {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+};
+export const getLocalizedDate = (dateIso) => {
+  const { $i18n } = useNuxtApp();
+  return new Date(dateIso).toLocaleDateString(
+    $i18n.localeProperties.value.language,
+    {
+      weekday: "long",
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    }
+  );
+};
+export const getDetailedFormatedDate = (dateStr, locale) => {
+  const date = new Date(dateStr);
+  return {
+    day: date.getDate(),
+    month: date.toLocaleString(locale, { month: "long" }),
+    year: date.getFullYear(),
+    hours: date.getUTCHours(),
+    minutes: date.getMinutes()
+  };
+};
+export const capitalize = (value, multiple) => multiple ? value.replace(/(?:^|[\s'-])\S/g, (a) => a.toUpperCase()) : value && value.charAt(0).toUpperCase() + value.slice(1);
+export const slugify = (str) => {
+  str = str.replace(/^\s+|\s+$/g, "").trim();
+  str = str.toLowerCase();
+  const from = "\xE0\xE1\xE4\xE2\xE8\xE9\xEB\xEA\xEC\xED\xEF\xEE\xF2\xF3\xF6\xF4\xF9\xFA\xFC\xFB\xF1\xE7\xB7/_,:;";
+  const to = "aaaaeeeeiiiioooouuuunc------";
+  for (let i = 0, l = from.length; i < l; i++) {
+    str = str.replace(new RegExp(from.charAt(i), "g"), to.charAt(i));
+  }
+  str = str.replace(/[^a-z0-9 -]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-");
+  return str;
+};
+export const formatDateValue = (date, locale) => {
+  const formattedDate = new Date(date);
+  return formattedDate.toLocaleDateString(locale);
+};

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

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

package/dist/runtime/plugins/{pinia.ts → pinia.js}

@@ -1,88 +1,69 @@
-import { createDynamicStore } from "../stores/factory"
-import type { AppConfig } from "nuxt/schema"
-import { useRootStore } from "../stores/root"
-const rootStore = useRootStore()
+import { createDynamicStore } from "../stores/factory.js";
 export default defineNuxtPlugin(async (nuxtApp) => {
-  const appConfig = useAppConfig() as AppConfig & {
-    list: {
-      modules: string[]
-    }
-  }
-
-  // Define module imports
+  const appConfig = useAppConfig();
   const moduleImports = {
     events: () => ({
       model: import("@paris-ias/data/dist/list/events.js"),
       queries: {
         list: import("../graphql/queries/list/events.gql"),
-        get: import("../graphql/queries/item/events.gql"),
-      },
+        get: import("../graphql/queries/item/events.gql")
+      }
     }),
     news: () => ({
       model: import("@paris-ias/data/dist/list/news.js"),
       queries: {
         list: import("../graphql/queries/list/news.gql"),
-        get: import("../graphql/queries/item/news.gql"),
-      },
+        get: import("../graphql/queries/item/news.gql")
+      }
     }),
     people: () => ({
       model: import("@paris-ias/data/dist/list/people.js"),
       queries: {
         list: import("../graphql/queries/list/people.gql"),
-        get: import("../graphql/queries/item/people.gql"),
-      },
+        get: import("../graphql/queries/item/people.gql")
+      }
     }),
     projects: () => ({
       model: import("@paris-ias/data/dist/list/projects.js"),
       queries: {
         list: import("../graphql/queries/list/projects.gql"),
-        get: import("../graphql/queries/item/projects.gql"),
-      },
+        get: import("../graphql/queries/item/projects.gql")
+      }
     }),
     fellowships: () => ({
       model: import("@paris-ias/data/dist/list/fellowships.js"),
       queries: {
         list: import("../graphql/queries/list/fellowships.gql"),
-        get: import("../graphql/queries/item/fellowships.gql"),
-      },
+        get: import("../graphql/queries/item/fellowships.gql")
+      }
     }),
     publications: () => ({
       model: import("@paris-ias/data/dist/list/publications.js"),
       queries: {
         list: import("../graphql/queries/list/publications.gql"),
-        get: import("../graphql/queries/item/publications.gql"),
-      },
-    }),
-
+        get: import("../graphql/queries/item/publications.gql")
+      }
+    })
     // Add other modules similarly...
-  }
-
-  // Initialize empty stores object
-  const stores: Record<string, any> = {}
-  const queries = {}
-
-  // Preload all required modules
+  };
+  const stores = {};
+  const queries = {};
+  console.log("INITIALIZING STORES");
   await Promise.all(
     appConfig.list.modules.map(async (type) => {
       try {
-        const imports = await moduleImports[
-          type as keyof typeof moduleImports
-        ]()
-        const model = (await imports.model).default
+        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,
-        }
-
-        stores[type] = createDynamicStore(type, { ...model, queries })()
+          get: (await imports.queries.get).default
+        };
+        stores[type] = createDynamicStore(type, model)();
       } catch (error) {
-        console.error(`Failed to initialize ${type} store:`, error)
+        console.error(`Failed to initialize ${type} store:`, error);
       }
     })
-  )
-
-  // Provide synchronous access to stores and queries
-  nuxtApp.provide("rootStore", rootStore)
-  nuxtApp.provide("stores", stores)
-  nuxtApp.provide("queries", queries)
-})
+  );
+  nuxtApp.provide("stores", stores);
+  nuxtApp.provide("queries", queries);
+});

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

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

package/dist/runtime/server/tsconfig.json

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

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

@@ -0,0 +1 @@
+export declare const createDynamicStore: (storeName: string, moduleState: object) => import("pinia").StoreDefinition<string, {} | Pick<any, string | number>, {} | Pick<any, string | number>, {} | Pick<any, string | number>>;

package/dist/runtime/stores/{factory.ts → factory.js}

@@ -1,4 +1,5 @@
-export const createDynamicStore = (storeName: string, moduleState: object) => {
+import { defineStore } from "pinia";
+export const createDynamicStore = (storeName, moduleState) => {
   return defineStore(storeName, () => {
     const state = reactive({
       loading: false,
@@ -7,12 +8,11 @@ export const createDynamicStore = (storeName: string, moduleState: object) => {
       page: 1,
       numberOfPages: 0,
       search: "",
-      error: null as string | null,
-      ...moduleState,
-    })
-
+      error: null,
+      ...moduleState
+    });
     return {
-      ...toRefs(state),
-    }
-  })
-}
+      ...toRefs(state)
+    };
+  });
+};

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

@@ -0,0 +1,34 @@
+export declare const useRootStore: import("pinia").StoreDefinition<"rootStore", Record<string, any>, {}, {
+    setLoading(value: boolean, type?: string): void;
+    setScrolled(): void;
+    loadRouteQuery(type: string): void;
+    setFiltersCount(type: string): void;
+    setBlankFilterLoad(type: string): void;
+    setDefaults(): void;
+    updateRouteQuery(type: string): void;
+    resetState(): void;
+    updateSort({ value, type }: {
+        value: number[] | string[];
+        type: string;
+    }): void;
+    updateView({ value, type }: {
+        value: string;
+        type: string;
+    }): void;
+    updateLocalStorage(key: string, value: string): void;
+    updateFilter(key: string, val: any, type: string): void;
+    updateItemsPerPage({ value, type }: {
+        value: number;
+        type: string;
+    }): void;
+    updatePage({ page, type }: {
+        page: number;
+        type: string;
+    }): void;
+    updateSearch({ type, search, lang, }: {
+        type: string;
+        search: string;
+        lang: string;
+    }): Promise<void>;
+    update(type: string, lang?: string): Promise<boolean>;
+}>;

package/dist/runtime/stores/root.js

@@ -0,0 +1,227 @@
+import { defineStore } from "pinia";
+import SEARCH from "../graphql/queries/list/search.gql";
+export const useRootStore = defineStore("rootStore", {
+  state: () => ({
+    scrolled: import.meta.browser ? window.scrollY > 0 : false,
+    loading: false,
+    total: 0,
+    skip: 0,
+    page: 1,
+    numberOfPages: 0,
+    search: "",
+    results: {
+      events: {},
+      news: {},
+      people: {},
+      projects: {},
+      fellowships: {},
+      publications: {}
+    }
+  }),
+  actions: {
+    setLoading(value, type = "") {
+      const { $stores } = useNuxtApp();
+      this.loading = value;
+      if (type.length) $stores[type].loading = value;
+    },
+    setScrolled() {
+      if (import.meta.browser) {
+        this.scrolled = window.scrollY > 0;
+      }
+    },
+    loadRouteQuery(type) {
+      const { currentRoute } = useRouter();
+      const { $stores } = useNuxtApp();
+      const query = currentRoute.value.query;
+      if (Object.keys(query)?.length) {
+        Object.keys(query).forEach((filter) => {
+          if (Object.keys($stores[type].filters).includes(filter))
+            $stores[type].filters[filter].value = this[type].list.filters[filter].multiple ? JSON.parse(query[filter]) : query[filter];
+        });
+      }
+      console.log("query loaded");
+    },
+    setFiltersCount(type) {
+      const { $stores } = useNuxtApp();
+      let filtersCount = 0;
+      Object.keys($stores[type].filters).forEach((filter) => {
+        if ($stores[type].filters[filter]?.value?.length && typeof $stores[type].filters[filter]?.value !== "undefined") {
+          filtersCount++;
+        }
+        return filtersCount;
+      });
+      $stores[type].filtersCount = filtersCount;
+    },
+    setBlankFilterLoad(type) {
+    },
+    setDefaults() {
+      const lang = localStorage.getItem("lang");
+    },
+    updateRouteQuery(type) {
+      const router = useRouter();
+      const { $stores } = useNuxtApp();
+      const routeQuery = {
+        // Add search if it exists and is defined
+        ...this.search ? { search: this.search } : {},
+        // Add page if it's greater than 1
+        ...this.page > 1 ? { page: this.page.toString() } : {},
+        // Add filters with defined values
+        ...Object.entries($stores[type].filters).reduce(
+          (acc, [filterKey, filter]) => {
+            if (!$stores[type].filters[filterKey]?.value) {
+              return acc;
+            }
+            return {
+              ...acc,
+              ...{
+                [filterKey]: $stores[type].filters[filterKey]?.value
+              }
+            };
+          },
+          {}
+        )
+      };
+      router.replace({ query: routeQuery });
+    },
+    resetState() {
+      const { $stores } = useNuxtApp();
+      console.log("resetState");
+      this.search = "";
+      this.page = 1;
+      this.scrolled = false;
+      this.loading = false;
+      this.total = 0;
+      this.skip = 0;
+      this.numberOfPages = 0;
+      const modules = [
+        "events",
+        "news",
+        "people",
+        "projects",
+        "fellowships",
+        "publications"
+      ];
+      modules.forEach((type) => {
+      });
+    },
+    updateSort({ value, type }) {
+      const { $stores } = useNuxtApp();
+      $stores[type].sortBy = [value[0]];
+      $stores[type].sortDesc = [value[1]];
+      this.page = 1;
+      this.updateLocalStorage(type + "_sort", value.join("_"));
+      this.update(type);
+    },
+    updateView({ value, type }) {
+      const { $stores } = useNuxtApp();
+      $stores[type].view = {
+        ...$stores[type].views[value],
+        name: value
+      };
+      this.updateLocalStorage(type + "_view", value);
+      this.update(type);
+    },
+    updateLocalStorage(key, value) {
+      const local = JSON.parse(localStorage.getItem("PARIS_IAS")) || {};
+      local[key] = value;
+      localStorage.setItem("PARIS_IAS", JSON.stringify(local));
+    },
+    updateFilter(key, val, type) {
+      const { $stores } = useNuxtApp();
+      console.log("update filter: ", { key, val, type });
+      if (["online", "outside", "past"].includes(key) && val === false) {
+        $stores[type].filters[key].value = null;
+      } else {
+        $stores[type].filters[key].value = val;
+      }
+      this.updatePage({ page: 1, type });
+    },
+    updateItemsPerPage({ value, type }) {
+      const { $stores } = useNuxtApp();
+      this.page = 1;
+      $stores[types].itemsPerPage = value;
+      this.update(type);
+    },
+    updatePage({ page, type }) {
+      this.page = page;
+      this.update(type);
+    },
+    async updateSearch({
+      type = "all",
+      search = "",
+      lang = "en"
+    }) {
+      this.search = search;
+      this.setLoading(true);
+      await this.update(type, lang);
+    },
+    async update(type, lang = "en") {
+      const { $stores } = useNuxtApp();
+      this.setLoading(true);
+      if (type !== "all") {
+        $stores[type].loading = true;
+      }
+      const itemsPerPage = type === "all" ? 3 : $stores[type]?.itemsPerPage;
+      const filters = {};
+      if (type !== "all") {
+        for (const filter in $stores[type].filters) {
+          const filterValue = $stores[type].filters[filter]?.value;
+          if (typeof filterValue !== "undefined" && filterValue?.length) {
+            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,
+            sortDesc: type === "all" ? -1 : $stores[type].sortDesc > 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);
+      let result = {};
+      console.log("args: ", args);
+      console.log(`Fetching ${type}`);
+      const { $queries } = useNuxtApp();
+      const { data, error } = await useAsyncQuery(
+        type === "all" ? SEARCH : $queries[type].list,
+        args
+      );
+      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];
+      } else {
+        const items = data?.value?.[key]?.items ?? [];
+        this.total = data?.value?.[key]?.total;
+        result = {
+          ...data?.value?.[key],
+          items: items.map(({ id, ...rest }) => ({
+            ...rest,
+            _path: `/${id}`
+          }))
+        };
+        $stores[type].items = result["items"];
+        const lastPage = Math.ceil(result.total / itemsPerPage);
+        this.setFiltersCount(type);
+        this.setBlankFilterLoad(type);
+        $stores[type].numberOfPages = lastPage;
+      }
+      this.setLoading(false, type);
+      return true;
+    }
+  }
+});

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'