gothamstoryblok 1.0.15

package/README.md

@@ -0,0 +1,84 @@
+<!--
+Get your module up and running quickly.
+
+Find and replace all on all files (CMD+SHIFT+F):
+- Name: My Module
+- Package name: my-module
+- Description: My new Nuxt module
+-->
+
+# My Module
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![License][license-src]][license-href]
+[![Nuxt][nuxt-src]][nuxt-href]
+
+My new Nuxt module for doing amazing things.
+
+- [✨ &nbsp;Release Notes](/CHANGELOG.md)
+<!-- - [🏀 Online playground](https://stackblitz.com/github/your-org/my-module?file=playground%2Fapp.vue) -->
+<!-- - [📖 &nbsp;Documentation](https://example.com) -->
+
+## Features
+
+<!-- Highlight some of the features your module provide here -->
+- ⛰ &nbsp;Foo
+- 🚠 &nbsp;Bar
+- 🌲 &nbsp;Baz
+
+## Quick Setup
+
+Install the module to your Nuxt application with one command:
+
+```bash
+npx nuxi module add my-module
+```
+
+That's it! You can now use My Module in your Nuxt app ✨
+
+
+## Contribution
+
+<details>
+  <summary>Local development</summary>
+  
+  ```bash
+  # Install dependencies
+  npm install
+  
+  # Generate type stubs
+  npm run dev:prepare
+  
+  # Develop with the playground
+  npm run dev
+  
+  # Build the playground
+  npm run dev:build
+  
+  # Run ESLint
+  npm run lint
+  
+  # Run Vitest
+  npm run test
+  npm run test:watch
+  
+  # Release new version
+  npm run release
+  ```
+
+</details>
+
+
+<!-- Badges -->
+[npm-version-src]: https://img.shields.io/npm/v/my-module/latest.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-version-href]: https://npmjs.com/package/my-module
+
+[npm-downloads-src]: https://img.shields.io/npm/dm/my-module.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-downloads-href]: https://npm.chart.dev/my-module
+
+[license-src]: https://img.shields.io/npm/l/my-module.svg?style=flat&colorA=020420&colorB=00DC82
+[license-href]: https://npmjs.com/package/my-module
+
+[nuxt-src]: https://img.shields.io/badge/Nuxt-020420?logo=nuxt
+[nuxt-href]: https://nuxt.com

package/dist/module.d.mts

@@ -0,0 +1,11 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface ModuleOptions {
+    expire: number;
+    version: 'draft' | 'published';
+    key: string;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "gothamstoryblok",
+  "configKey": "gothamstoryblok",
+  "version": "1.0.15",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,50 @@
+import { readdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { defineNuxtModule, createResolver, addPlugin, addServerHandler, addImportsDir } from '@nuxt/kit';
+
+const currentDir = dirname(fileURLToPath(import.meta.url));
+const addServerRoutes = (resolver) => {
+  const basePath = "/api/storyblok";
+  const sourcePath = "./runtime/server/api/storyblok";
+  const targetDir = join(currentDir, sourcePath);
+  const files = readdirSync(targetDir);
+  const cleanedFiles = files.filter((e) => e.includes(".js") || e.includes(".ts")).map((e) => e.replace(".js", "").replace(".ts", ""));
+  cleanedFiles.forEach((handler) => {
+    const [route, method] = handler.split(".");
+    addServerHandler({
+      route: `${basePath}/${route}`,
+      handler: resolver.resolve(`${sourcePath}/${route}.${method}`)
+    });
+  });
+};
+const addPlugins = (resolver) => {
+  addPlugin(resolver.resolve("./runtime/plugins/01.setupLanguages"));
+  addPlugin(resolver.resolve("./runtime/plugins/02.utils"));
+  addPlugin(resolver.resolve("./runtime/plugins/03.labels"));
+  addPlugin(resolver.resolve("./runtime/plugins/04.images"));
+  addPlugin(resolver.resolve("./runtime/plugins/05.datasources"));
+};
+const addComposables = (resolver) => {
+  addImportsDir(resolver.resolve("runtime/composables"));
+};
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "gothamstoryblok",
+    configKey: "gothamstoryblok"
+  },
+  defaults: {
+    expire: 1,
+    version: "draft",
+    key: ""
+  },
+  setup(_options, _nuxt) {
+    _nuxt.options.runtimeConfig.gothamstoryblok = { ..._options };
+    const resolver = createResolver(import.meta.url);
+    addPlugins(resolver);
+    addServerRoutes(resolver);
+    addComposables(resolver);
+  }
+});
+
+export { module$1 as default };

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

@@ -0,0 +1,11 @@
+export function useAsyncGothamStoryblok(url: any, options: any, bridgeOptions: any, nocomponent?: boolean): Promise<{
+    story?: undefined;
+    stories?: undefined;
+    rels?: undefined;
+    refresh?: undefined;
+} | {
+    story: import("vue").Ref<any, any>;
+    stories: import("vue").Ref<any, any>;
+    rels: import("vue").Ref<any, any>;
+    refresh: () => void;
+}>;

package/dist/runtime/composables/useAsyncGothamStoryblok.js

@@ -0,0 +1,62 @@
+import { useStoryblokBridge } from '@storyblok/vue'
+import { useNuxtApp, useState, useAsyncData, createError, useLanguage, onMounted } from '#imports'
+
+export const useAsyncGothamStoryblok = async (url, options, bridgeOptions, nocomponent = false) => {
+  const { $__ } = useNuxtApp()
+  const uniqueKey = `${JSON.stringify(options)}${url}`
+  const story = useState(`${uniqueKey}-state`)
+  const stories = useState(`${uniqueKey}-stories-state`)
+  const rels = useState(`${uniqueKey}-rels-state`)
+  if (!nocomponent) {
+    onMounted(() => {
+      if (!stories.value && story.value && story.value.id) {
+        useStoryblokBridge(
+          story.value.id,
+          evStory => (story.value = evStory),
+          bridgeOptions,
+        )
+      }
+    })
+  }
+  var refresh = () => {}
+  if (!story.value) {
+    const { data, error, refresh: refreshAsync } = await useAsyncData(uniqueKey, async () => {
+      var params = {
+        fullSlug: url,
+      }
+      if (options) params = { ...params, ...options }
+      const { currentLanguage, defaultLanguage } = useLanguage()
+      if (!params.language && currentLanguage.value != defaultLanguage) params.language = currentLanguage.value
+
+      if (params.isEditor) {
+        const { $__clearCache } = useNuxtApp()
+        await $__clearCache(params)
+      }
+
+      return $fetch('/api/storyblok/request', { query: params })
+    })
+    refresh = refreshAsync
+
+    if (error.value) throw error.value
+
+    if (!data?.value && !nocomponent) throw createError({ statusCode: 404, statusMessage: $__('errorPageNotFound'), fatal: true })
+    if (data?.value) {
+      if (data.value.total) {
+        stories.value = data.value.stories
+        return { ...data.value }
+      }
+      if (Array.isArray(data.value)) {
+        stories.value = data.value
+      }
+      else {
+        story.value = data.value
+      }
+
+      if (options?.resolve_relations) {
+        story.value = data.value?.story
+        rels.value = data.value?.rels
+      }
+    }
+  }
+  return { story, stories, rels, refresh }
+}

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

@@ -0,0 +1,6 @@
+export function useLanguage(): {
+    languages: import("vue").Ref<undefined, undefined>;
+    currentLanguage: import("vue").Ref<undefined, undefined>;
+    defaultLanguage: import("vue").Ref<undefined, undefined>;
+    slugList: import("vue").Ref<never[], never[]>;
+};

package/dist/runtime/composables/useLanguage.js

@@ -0,0 +1,15 @@
+import { useState } from '#imports'
+
+export const useLanguage = () => {
+  const languages = useState('languages', () => undefined)
+  const currentLanguage = useState('currentLanguage', () => undefined)
+  const defaultLanguage = useState('defaultLanguage', () => undefined)
+  const slugList = useState('slugList', () => [])
+
+  return {
+    languages,
+    currentLanguage,
+    defaultLanguage,
+    slugList,
+  }
+}

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

@@ -0,0 +1 @@
+export function useSeo(story: any): void;

package/dist/runtime/composables/useSeo.js

@@ -0,0 +1,69 @@
+import { renderRichText } from '@storyblok/js'
+import { useRequestURL, useRoute, useNuxtApp, useLanguage, useHead } from '#imports'
+
+const hostChecker = (array, string) => {
+  for (var i in array) {
+    if (string?.includes(array[i])) return true
+  }
+  return false
+}
+export const useSeo = (story) => {
+  const richText = data => renderRichText(data)
+  const { host } = useRequestURL()
+  const route = useRoute()
+  const { defaultLanguage } = useLanguage()
+  const { $__, $__img } = useNuxtApp()
+  var siteName = $__('configSiteName') != '' ? `${$__('configSiteName')} - ` : ''
+  const metadata
+    = story.value?.content?.metadata
+      || {
+        title: null,
+        description: $__('configSiteDescription'),
+        image: $__img('configSiteImage'),
+        follow: 'follow',
+      }
+
+  var { title, description, image, follow } = metadata
+  title = title || story?.value?.content?.title || story?.name
+
+  if (typeof title == 'object' && title?.type) {
+    const rendered = richText(title)
+    title = rendered?.replace(/<[^>]*>?/g, '')
+  }
+  if (!title && siteName && siteName?.includes(' - ')) {
+    siteName = siteName.replace(' - ', '')
+    title = ''
+  }
+  title = siteName + title
+
+  description = description || story?.value?.content?.previewText || $__('configSiteDescription')
+
+  const noFollow = follow == 'nofollow' || hostChecker(['development', 'staging'], host)
+  follow = noFollow ? 'noindex, nofollow' : 'index, follow'
+
+  const path = route.fullPath || route.path
+
+  useHead({
+    title: title,
+    htmlAttrs: {
+      lang: route.params.lang || defaultLanguage.value,
+    },
+    link: [
+      { rel: 'canonical', href: 'https://' + host + path },
+    ],
+    meta: [
+      { property: 'og:url', content: 'https://' + host + path },
+      { property: 'og:image:width', content: '1200' },
+      { property: 'og:image:height', content: '630' },
+      { property: 'og:image', content: image },
+      { property: 'og:description', content: description },
+      { property: 'og:site_name', content: $__('configSiteName') },
+      { property: 'og:title', content: title },
+      { property: 'og:type', content: 'article' },
+      { name: 'apple-mobile-web-app-title', content: title },
+      { name: 'application-name', content: $__('configSiteName') },
+      { name: 'description', content: description },
+      { name: 'robots', content: follow },
+    ],
+  })
+}

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

@@ -0,0 +1,23 @@
+export function useSizes(): {
+    reference: import("vue").Ref<undefined, undefined>;
+    sizes: import("vue").Ref<{
+        width: number;
+        height: number;
+        fr: number;
+    }, {
+        width: number;
+        height: number;
+        fr: number;
+    }>;
+    scroll: import("vue").Ref<{
+        top: number;
+        left: number;
+    }, {
+        top: number;
+        left: number;
+    }>;
+    observe: (el: any, fn: any) => void;
+    mw: (size: any) => number;
+    mh: (size: any) => number;
+    init: () => void;
+};

package/dist/runtime/composables/useSizes.js

@@ -0,0 +1,70 @@
+import { useState, watch } from '#imports'
+
+export const useSizes = () => {
+  const gridCount = 80
+  const reference = useState('reference', () => undefined)
+
+  const mw = (size) => {
+    if (size) return sizes.value.fr * size
+    return 0
+  }
+
+  const mh = (size) => {
+    if (size) return sizes.value.height / 100 * size
+    return 0
+  }
+
+  const sizes = useState('sizes', () => ({ width: 0, height: 0, fr: 0 }))
+  const scroll = useState('scroll', () => ({ top: 0, left: 0 }))
+
+  const resizeListener = () => {
+    reference.value = reference.value ?? window
+    // se mi riferisco alla window devo recuperare la inner altrimenti recupero la client
+    const width = (reference.value.clientWidth ?? reference.value.innerWidth)
+    const height = (reference.value.clientHeight ?? reference.value.innerHeight)
+
+    sizes.value.fr = width / gridCount
+    sizes.value.width = width
+    sizes.value.height = height
+  }
+  const scrollListener = () => {
+    const top = reference.value.scrollY !== undefined ? reference.value.scrollY : reference.value.scrollTop
+    const left = reference.value.scrollY !== undefined ? reference.value.scrollX : reference.value.scrollLeft
+
+    scroll.value.top = top
+    scroll.value.left = left
+  }
+
+  watch(reference, () => {
+    resizeListener()
+  })
+
+  const init = () => {
+    if (import.meta.client) {
+      resizeListener()
+      window.addEventListener('resize', resizeListener)
+      window.addEventListener('scroll', scrollListener)
+    }
+  }
+
+  const observer = useState('observer', () => null)
+  const observerFunctions = useState('observerFunctions', () => [])
+  if (import.meta.client && !observer.value) {
+    observer.value = new IntersectionObserver((entries) => {
+      entries.forEach((entry) => {
+        if (entry.isIntersecting) {
+          const index = entry.target.dataset.functionIndex
+          const fn = observerFunctions.value[index]
+          fn()
+        }
+      })
+    }, { threshold: 0.1 })
+  }
+  const observe = (el, fn) => {
+    observer.value.observe(el)
+    observerFunctions.value.push(fn)
+    el.dataset.functionIndex = observerFunctions.value.indexOf(fn)
+  }
+
+  return { reference, sizes, scroll, observe, mw, mh, init }
+}

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

@@ -0,0 +1,3 @@
+export function useStoryblokEditor(): {
+    sbEditor: import("vue").Ref<boolean, boolean>;
+};

package/dist/runtime/composables/useStoryblokEditor.js

@@ -0,0 +1,10 @@
+import { useRoute, useState } from '#imports'
+
+export const useStoryblokEditor = () => {
+  const route = useRoute()
+  const sbEditor = useState('sbEditor', () => {
+    return false
+  })
+  sbEditor.value = Object.keys(route.query)?.includes('_storyblok_tk[space_id]')
+  return { sbEditor }
+}

package/dist/runtime/plugins/01.setupLanguages.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/plugins/01.setupLanguages.js

@@ -0,0 +1,26 @@
+import { createError, useLanguage, useRoute } from '#imports'
+import { defineNuxtPlugin } from '#app'
+
+export default defineNuxtPlugin({
+  name: 'setuplanguages',
+  parallel: false,
+  async setup() {
+    const { languages, currentLanguage, defaultLanguage } = useLanguage()
+    const route = useRoute()
+    const { fullslug } = route.params
+    currentLanguage.value = fullslug && fullslug[0] ? fullslug[0] : undefined
+    if (import.meta.server) {
+      try {
+        const space = await $fetch('/api/storyblok/space')
+        languages.value = space.available_languages
+        defaultLanguage.value = space.default_language
+        if (currentLanguage.value?.length != 2) currentLanguage.value = defaultLanguage.value
+      }
+      catch (error) {
+        console.log(error)
+        throw createError({ statusCode: 500, statusMessage: 'Error setupLanguage plugin' })
+      }
+    }
+    if (currentLanguage.value?.length != 2) currentLanguage.value = defaultLanguage.value
+  },
+})

package/dist/runtime/plugins/02.utils.d.ts

@@ -0,0 +1,30 @@
+declare const _default: import("#app").Plugin<{
+    __url: (u: any) => any;
+    __parseEndpoint: () => {
+        endpoint: undefined;
+        language?: undefined;
+        version?: undefined;
+    } | {
+        endpoint: any;
+        language: any;
+        version: unknown;
+    };
+    __filename: (str: any) => any;
+    __formatDate: (d: any) => string;
+    __clearCache: (query: any) => Promise<void>;
+}> & import("#app").ObjectPlugin<{
+    __url: (u: any) => any;
+    __parseEndpoint: () => {
+        endpoint: undefined;
+        language?: undefined;
+        version?: undefined;
+    } | {
+        endpoint: any;
+        language: any;
+        version: unknown;
+    };
+    __filename: (str: any) => any;
+    __formatDate: (d: any) => string;
+    __clearCache: (query: any) => Promise<void>;
+}>;
+export default _default;

package/dist/runtime/plugins/02.utils.js

@@ -0,0 +1,74 @@
+import { defineNuxtPlugin } from '#app'
+import { useLanguage, useRoute, useRuntimeConfig, useStoryblokEditor } from '#imports'
+
+export default defineNuxtPlugin({
+  dependsOn: ['labels', 'images'],
+  async setup() {
+    return {
+      provide: {
+        __url: (u) => {
+          if (!u) return undefined
+          if (u == '#' || u.substring(0, 4) == 'http') return u
+          const { languages, currentLanguage, slugList } = useLanguage()
+          u = u.substring(0, 1) == '/' ? u : '/' + u
+          if (languages.value.length < 2) return u
+          u = u.replace(/([^:])\/\//g, '$1/')
+          const founded = slugList.value.find(s => (u == s.fullslug || u == '/' + s.fullslug))
+          if (founded?.slugs) {
+            const sp = u.split('/')
+            sp[sp.length - 1] = founded?.slugs[currentLanguage.value]
+            u = sp.join('/')
+          }
+          const prefix = '/' + currentLanguage.value + '/'
+          const startString = u.substring(0, 4)
+          if (prefix != startString) u = prefix + u
+          u = u.replace(/([^:])\/\//g, '$1/')
+          return u
+        },
+        __parseEndpoint: () => {
+          const config = useRuntimeConfig()
+          const route = useRoute()
+          const { languages, currentLanguage, defaultLanguage, slugList } = useLanguage()
+
+          let language
+          let fullslug
+
+          if (route?.params?.fullslug && route?.params?.fullslug.length > 0) {
+            fullslug = JSON.parse(JSON.stringify(route?.params?.fullslug))
+            const availableLanguages = languages.value
+            if (availableLanguages?.includes(fullslug[0])) {
+              language = fullslug[0] != defaultLanguage.value ? fullslug[0] : undefined
+              fullslug.shift()
+            }
+            if (fullslug[0] == '' || !fullslug[0]) fullslug = undefined
+          }
+
+          const endpoint = fullslug || ['homepage']
+          const version = config.public.storyblokVersion
+          // ECCEZIONE PER I TRANSLATED SLUGS
+          if (!route.query['_storyblok_tk[token]'] && slugList.value?.length > 0) {
+            let slug = endpoint.pop()
+            const founded = slugList.value.find(s => s.slugs[currentLanguage.value] == slug)
+            if (!founded?.slug) {
+              return { endpoint: undefined }
+            }
+            else {
+              endpoint.push(founded?.slug)
+            }
+          }
+          return { endpoint: endpoint.join('/'), language, version }
+        },
+        __filename: (str) => {
+          return str.replace(/^.*[\\/]/, '')
+        },
+        __formatDate: d => (new Date(d)).toLocaleDateString('IT-it', { day: '2-digit', month: '2-digit', year: 'numeric' }),
+        __clearCache: async (query) => {
+          const { sbEditor } = useStoryblokEditor()
+          if (sbEditor.value) {
+            await $fetch('/api/storyblok/clearCache', { query })
+          }
+        },
+      },
+    }
+  },
+})

package/dist/runtime/plugins/03.labels.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("#app").Plugin<{
+    __: (...args: any[]) => any;
+}> & import("#app").ObjectPlugin<{
+    __: (...args: any[]) => any;
+}>;
+export default _default;

package/dist/runtime/plugins/03.labels.js

@@ -0,0 +1,50 @@
+import { defineNuxtPlugin } from '#app'
+import { useFetch, useRoute, useLanguage } from '#imports'
+
+export default defineNuxtPlugin({
+  name: 'labels',
+  parallel: true,
+  async setup() {
+    const { params } = useRoute()
+    const { defaultLanguage, languages } = useLanguage()
+
+    var labels = {}
+    let language = defaultLanguage.value
+    if (params?.fullslug && params?.fullslug.length > 0) {
+      const fullslug = JSON.parse(JSON.stringify(params?.fullslug))
+      if (languages.value?.includes(fullslug[0])) {
+        language = fullslug[0]
+      }
+    }
+    const query = {
+      starts_with: 'system/labels',
+      language,
+    }
+    const { data: stories } = await useFetch('/api/storyblok/request', {
+      query,
+    })
+    if (stories?.value?.length) {
+      for (var story of stories.value) {
+        if (story?.content?.items?.length) {
+          for (var label of story.content.items) {
+            labels[label.key] = label.text
+          }
+        }
+      }
+    }
+    return {
+      provide: {
+        __: (...args) => {
+          var s = args[0]
+          var prefix = args[2]
+          const key = prefix ? prefix + '_' + s : s
+          s = labels[key] || labels[key] === '' ? labels[key] : s
+          for (var i = 1; i < args.length; i++) {
+            s = s.replace('%s', args[i])
+          }
+          return s || ''
+        },
+      },
+    }
+  },
+})

package/dist/runtime/plugins/04.images.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("#app").Plugin<{
+    __img: (key: any) => any;
+    __svg: (svgUrl: any) => Promise<any>;
+}> & import("#app").ObjectPlugin<{
+    __img: (key: any) => any;
+    __svg: (svgUrl: any) => Promise<any>;
+}>;
+export default _default;

package/dist/runtime/plugins/04.images.js

@@ -0,0 +1,39 @@
+import { defineNuxtPlugin, useFetch } from '#app'
+
+export default defineNuxtPlugin({
+  name: 'images',
+  parallel: true,
+  async setup() {
+    var images = {}
+    const { data: stories } = await useFetch('/api/storyblok/request', {
+      query: {
+        starts_with: 'system/images',
+      },
+    })
+    if (stories?.value?.length) {
+      for (var story of stories.value) {
+        if (story.content?.items?.length) {
+          for (var image of story.content.items) {
+            images[image.key] = image.asset
+          }
+        }
+      }
+    }
+    return {
+      provide: {
+        __img: (key) => {
+          return images[key]
+        },
+        __svg: async (svgUrl) => {
+          if (!svgUrl) return null
+          const extension = svgUrl.split('.').pop()
+          if (!extension?.includes('svg')) return null
+          svgUrl = svgUrl.replace('https://', 'https://s3.amazonaws.com/')
+          const response = await $fetch(svgUrl)
+          const data = await response.text()
+          return data
+        },
+      },
+    }
+  },
+})

package/dist/runtime/plugins/05.datasources.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("#app").Plugin<{
+    __datasource: (key: any) => any;
+    __datasources: (key: any) => any;
+}> & import("#app").ObjectPlugin<{
+    __datasource: (key: any) => any;
+    __datasources: (key: any) => any;
+}>;
+export default _default;

package/dist/runtime/plugins/05.datasources.js

@@ -0,0 +1,19 @@
+import { defineNuxtPlugin, useFetch } from '#app'
+
+export default defineNuxtPlugin({
+  async setup() {
+    const { data: datasources } = await useFetch('/api/storyblok/datasources')
+    return {
+      provide: {
+        __datasource: (key) => {
+          return datasources.value.find(d => d?.value == key)
+        },
+        __datasources: (key) => {
+          if (key) return datasources.value.filter(d => d?.datasource == key)
+
+          return datasources
+        },
+      },
+    }
+  },
+})

package/dist/runtime/plugins/test.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/plugins/test.js

@@ -0,0 +1,4 @@
+import { defineNuxtPlugin } from "#app";
+export default defineNuxtPlugin((_nuxtApp) => {
+  console.log("Plugin injected by my-module!");
+});

package/dist/runtime/server/api/storyblok/all.get.d.ts

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

package/dist/runtime/server/api/storyblok/all.get.js

@@ -0,0 +1,16 @@
+import { getAll } from '../../utils/storyblok.js'
+import { defineCachedEventHandler, getQuery, setHeader } from '#imports'
+
+export default defineCachedEventHandler(async (event) => {
+  const query = getQuery(event)
+  setHeader(event, 'x-origin-url', event.node.req.url)
+  return await getAll(query)
+}, {
+  maxAge: process.env.DEFAULT_EXPIRE,
+  group: 'storyblok',
+  shouldInvalidateCache: (e) => {
+    const query = getQuery(e)
+    const bypass = query.sbToken != undefined
+    return bypass
+  },
+})

package/dist/runtime/server/api/storyblok/cache.get.d.ts

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

package/dist/runtime/server/api/storyblok/cache.get.js

@@ -0,0 +1,15 @@
+import { defineEventHandler, useStorage } from '#imports'
+
+export default defineEventHandler(async () => {
+  const cacheStorage = useStorage('cache:storyblok:_')
+  const cachedKeys = await cacheStorage.getKeys()
+  const promises = cachedKeys.map(async (c) => {
+    const item = await cacheStorage.getItem(c)
+    return {
+      name: c,
+      ...item,
+    }
+  })
+  const items = await Promise.all(promises)
+  return items
+})

package/dist/runtime/server/api/storyblok/clearCache.get.d.ts

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

package/dist/runtime/server/api/storyblok/clearCache.get.js

@@ -0,0 +1,66 @@
+import Cloudflare from 'cloudflare'
+import { clearLinks } from '../../utils/storyblok.js'
+import { defineEventHandler, useRuntimeConfig, getQuery, useStorage } from '#imports'
+
+const { cloudflare } = useRuntimeConfig()
+
+const { zoneID, email, apiKey } = cloudflare
+let cloudFlareClient
+if (apiKey && email) {
+  cloudFlareClient = new Cloudflare({
+    apiEmail: email,
+    apiKey: apiKey,
+  })
+}
+const foundSlugInBody = (body, slug) => {
+  if (body?.full_slug && body?.full_slug == slug) return true
+  if (!body?.full_slug && Array.isArray(body)) {
+    const filtered = body.filter(e => e.full_slug == slug || e.full_slug == slug + '/')
+    return filtered.length > 0
+  }
+  const stringbody = JSON.stringify(body)
+  if (stringbody.includes(slug)) return true
+  return false
+}
+
+export default defineEventHandler(async (event) => {
+  // Clear cache Nitro
+  const config = useRuntimeConfig()
+  const query = getQuery(event)
+  const { fullSlug, language, itemId } = query
+  const cacheStorage = useStorage('cache:storyblok:_')
+  const cachedKeys = await cacheStorage.getKeys()
+  const endpoint = language && language != config.defaultLanguage ? `${language}/${fullSlug}` : fullSlug
+  console.log('Clear cache Nitro - endpoint', endpoint)
+  if (itemId) {
+    console.log('ITEM ID', itemId)
+    return await cacheStorage.removeItem(itemId)
+  }
+  // ho rimosso il push nell'array del promise all perché per qualche ragione non svuotava correttamente in locale.
+  // così è più lento ma funziona.
+  for (var i in cachedKeys) {
+    if (fullSlug) {
+      const stored = await cacheStorage.getItem(cachedKeys[i])
+      const toclear = foundSlugInBody(stored?.value?.body, endpoint)
+      if (toclear) {
+        console.log('clerearing', cachedKeys[i])
+        await cacheStorage.removeItem(cachedKeys[i])
+      }
+    }
+    else {
+      await cacheStorage.removeItem(cachedKeys[i])
+    }
+  }
+  console.log('Cleared cache Nitro - endpoint', endpoint)
+  await clearLinks()
+
+  if (cloudFlareClient) {
+    try {
+      await cloudFlareClient.cache.purge({ zone_id: zoneID, purge_everything: true })
+    }
+    catch (error) {
+      console.log('err purge cloudflare cache', error)
+    }
+  }
+  return true
+})

package/dist/runtime/server/api/storyblok/clearCache.post.d.ts

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

package/dist/runtime/server/api/storyblok/clearCache.post.js

@@ -0,0 +1,15 @@
+import { clearLinks } from '../../utils/storyblok.js'
+import { defineEventHandler, useStorage } from '#imports'
+
+export default defineEventHandler(async () => {
+  // Clear cache Nitro
+  const cacheStorage = useStorage('cache:storyblok:_')
+  const cachedKeys = await cacheStorage.getKeys()
+  let promiseArr = []
+  for (var i in cachedKeys) promiseArr.push(cacheStorage.removeItem(cachedKeys[i]))
+  await Promise.all(promiseArr)
+
+  await clearLinks()
+
+  return true
+})

package/dist/runtime/server/api/storyblok/datasources.get.d.ts

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

package/dist/runtime/server/api/storyblok/datasources.get.js

@@ -0,0 +1,41 @@
+// https://developers.cloudflare.com/workers/examples/aggregate-requests/
+
+import { defineCachedEventHandler, useRuntimeConfig, createError, getQuery } from '#imports'
+
+const config = useRuntimeConfig()
+export default defineCachedEventHandler(async () => {
+  try {
+    let arr = []
+    const cv = Date.now()
+    const { datasources } = await fetch('https://api.storyblok.com/v2/cdn/datasources?' + new URLSearchParams({ token: config.gothamstoryblok.key, per_page: 100, cv }), { headers: { 'Content-Type': 'application/json' } }).then(response => response.json())
+
+    const promiseArr = []
+    datasources.map((d) => {
+      promiseArr.push(
+        fetch('https://api.storyblok.com/v2/cdn/datasource_entries?' + new URLSearchParams({ token: config.gothamstoryblok.key, per_page: 100, cv, datasource: d.slug }, { headers: { 'Content-Type': 'application/json' } })),
+      )
+    })
+
+    const responses = await Promise.all(promiseArr)
+    const response = await Promise.all(responses.map(r => r.json()))
+
+    for (var i in response) {
+      response[i].datasource_entries = response[i].datasource_entries.map(e => ({ ...e, datasource: datasources[i].slug }))
+      arr = arr.concat(response[i].datasource_entries)
+    }
+
+    return arr
+  }
+  catch (error) {
+    console.log(error)
+    throw createError({ statusCode: 500, statusMessage: 'Error building datasources' })
+  }
+}, {
+  maxAge: process.env.DEFAULT_EXPIRE,
+  group: 'storyblok',
+  shouldInvalidateCache: (e) => {
+    const query = getQuery(e)
+    const bypass = query.sbToken != undefined
+    return bypass
+  },
+})

package/dist/runtime/server/api/storyblok/getall.get.d.ts

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

package/dist/runtime/server/api/storyblok/getall.get.js

@@ -0,0 +1,34 @@
+import { storyblokInit, apiPlugin } from '@storyblok/js'
+import { defineCachedEventHandler, useRuntimeConfig, getQuery } from '#imports'
+
+const config = useRuntimeConfig()
+const { storyblokApi } = storyblokInit({
+  accessToken: config.gothamstoryblok.key,
+  use: [apiPlugin],
+})
+
+export default defineCachedEventHandler(async (event) => {
+  const query = getQuery(event)
+  delete query.sbToken
+  const params = {
+    ...query,
+    version: config.gothamstoryblok.version,
+  }
+  storyblokApi.flushCache()
+  const { data: { stories } } = await storyblokApi.get('cdn/stories', params)
+
+  return stories
+}, {
+  maxAge: 60 * 60 * 12,
+  group: 'storyblok',
+  shouldInvalidateCache: async (e) => {
+    const query = getQuery(e)
+    const bypass = query.sbToken != undefined
+    console.log('bypass', bypass)
+    if (bypass) {
+      storyblokApi.flushCache()
+      await $fetch('/api/storyblok/clearCache')
+    }
+    return bypass
+  },
+})

package/dist/runtime/server/api/storyblok/links.get.d.ts

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

package/dist/runtime/server/api/storyblok/links.get.js

@@ -0,0 +1,17 @@
+import { links } from '../../utils/storyblok.js'
+import { defineCachedEventHandler, getQuery, setHeader } from '#imports'
+
+export default defineCachedEventHandler(async (event) => {
+  const query = getQuery(event)
+  setHeader(event, 'x-origin-url', event.node.req.url)
+  return await links(query)
+}, {
+  maxAge: process.env.DEFAULT_EXPIRE,
+  group: 'storyblok',
+  name: 'links',
+  shouldInvalidateCache: (e) => {
+    const query = getQuery(e)
+    const bypass = query.sbToken != undefined
+    return bypass
+  },
+})

package/dist/runtime/server/api/storyblok/request.get.d.ts

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

package/dist/runtime/server/api/storyblok/request.get.js

@@ -0,0 +1,17 @@
+import { request } from '../../utils/storyblok.js'
+import { defineCachedEventHandler, getQuery, setHeader } from '#imports'
+
+export default defineCachedEventHandler(async (event) => {
+  const query = getQuery(event)
+  setHeader(event, 'x-origin-url', event.node.req.url)
+  return await request(query)
+}, {
+  maxAge: process.env.DEFAULT_EXPIRE,
+  group: 'storyblok',
+  shouldInvalidateCache: (e) => {
+    const query = getQuery(e)
+    const bypass = query.sbToken != undefined
+    return bypass
+  },
+
+})

package/dist/runtime/server/api/storyblok/space.get.d.ts

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

package/dist/runtime/server/api/storyblok/space.get.js

@@ -0,0 +1,14 @@
+import { space } from '../../utils/storyblok.js'
+import { defineCachedEventHandler, getQuery } from '#imports'
+
+export default defineCachedEventHandler(async () => {
+  return await space()
+}, {
+  maxAge: process.env.DEFAULT_EXPIRE,
+  group: 'storyblok',
+  shouldInvalidateCache: (e) => {
+    const query = getQuery(e)
+    const bypass = query.sbToken != undefined
+    return bypass
+  },
+})

package/dist/runtime/server/tsconfig.json

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

package/dist/runtime/server/utils/storyblok.d.ts

@@ -0,0 +1,5 @@
+export function request(query: any): Promise<any>;
+export function space(): Promise<any>;
+export function getAll(params: any): Promise<unknown>;
+export function links(query: any): Promise<any>;
+export function clearLinks(): Promise<void>;

package/dist/runtime/server/utils/storyblok.js

@@ -0,0 +1,183 @@
+import { useRuntimeConfig, createError, useStorage } from '#imports'
+
+const config = useRuntimeConfig()
+const request = async (query) => {
+  try {
+    const defaultLanguage = config.defaultLanguage
+    const cv = Date.now()
+    const { find_by, returntotal, isEditor } = query
+    if (returntotal) delete query.returntotal
+    if (isEditor) delete query.isEditor
+    const params = {
+      cv,
+      version: config.gothamstoryblok.version,
+      token: config.gothamstoryblok.key,
+      find_by,
+    }
+    if (query.language && query.language != defaultLanguage) {
+      params.language = query.language
+    }
+    if (query.resolve_relations) {
+      params.resolve_relations = query.resolve_relations
+    }
+    if (query.fullSlug) {
+      await checkFullSlug(query.fullSlug)
+
+      const data = await $fetch(`https://api.storyblok.com/v2/cdn/stories/${query.fullSlug}`, { method: 'GET', query: params })
+
+      const { story, rels } = data
+
+      if (params.resolve_relations) return { story, rels }
+      return story
+    }
+
+    let { _data: data, headers } = await $fetch.raw('https://api.storyblok.com/v2/cdn/stories', {
+      query: {
+        cv,
+        version: config.gothamstoryblok.version,
+        token: config.gothamstoryblok.key,
+        ...query,
+      },
+    })
+    const perPage = Number.parseInt(headers.get('per-page'))
+    const total = Number.parseInt(headers.get('total'))
+    let { stories, rels } = data
+    if (!isEditor || isEditor === 'false') stories = stories.filter(s => !s?.content?.metadata?.disbledforlanguage)
+
+    let res = stories
+    if (returntotal) res = { stories, perPage, total }
+    if (rels.length) {
+      if (returntotal) {
+        res.rels = rels
+      }
+      else {
+        res = { stories, rels }
+      }
+    }
+
+    return res
+  }
+  catch (error) {
+    throw error
+  }
+}
+
+const space = async () => {
+  const data = await $fetch(`https://api.storyblok.com/v2/cdn/spaces/me`, {
+    query: {
+      token: config.gothamstoryblok.key,
+    },
+  })
+
+  const { space } = data
+  const available_languages = [...space.language_codes, config.defaultLanguage]
+  space.available_languages = available_languages
+  space.default_language = config.defaultLanguage
+  delete space.language_codes
+  return space
+}
+
+const getAll = async (params) => {
+  const requestParams = {
+    ...params,
+    returntotal: true,
+    per_page: 100,
+  }
+
+  const getStories = async (page = 1, allStories = []) => {
+    try {
+      const { stories, total } = await request(requestParams)
+      allStories.push(...stories)
+      console.log(allStories.length < total)
+      if (allStories.length === 100) {
+        return getStories(page + 1, allStories)
+      }
+      return allStories
+    }
+    catch (error) {
+      return error
+    }
+  }
+
+  try {
+    return await getStories()
+  }
+  catch (error) {
+    return error
+  }
+}
+
+const links = async (query) => {
+  const cv = Date.now()
+  try {
+    const { links } = await $fetch('https://api.storyblok.com/v2/cdn/links', {
+      query: {
+        cv,
+        version: config.gothamstoryblok.version,
+        token: config.gothamstoryblok.key,
+        ...query,
+      },
+    })
+
+    return links
+  }
+  catch (error) {
+    throw error
+  }
+}
+
+let linksList = undefined
+let linksListPromise = null
+const loadLinksList = async () => {
+  if (linksList) return linksList
+  // Se un'altra richiesta la sta già caricando, aspetta quella
+  if (!linksListPromise) {
+    linksListPromise = (async () => {
+      const result = {
+        slug: {},
+        uuid: {},
+        id: {},
+      }
+
+      const links = await $fetch('/api/storyblok/links', { query: { per_page: 1000 } })
+
+      for (const i in links) {
+        const link = links[i]
+        const slugParts = link.slug.split('/')
+        const slug = slugParts[slugParts.length - 1]
+
+        if (!result.slug[slug]) result.slug[slug] = link
+        if (!result.uuid[link.uuid]) result.uuid[link.uuid] = link
+        if (!result.id[link.id]) result.id[link.id] = link
+      }
+
+      linksList = result
+      linksListPromise = null // reset per richieste future
+      return result
+    })()
+  }
+
+  return linksListPromise
+}
+
+const checkFullSlug = async (fullSlug) => {
+  const cachedLinks = await loadLinksList()
+
+  const slugs = fullSlug.split('/')
+  const slug = slugs[slugs.length - 1]
+
+  if (!(cachedLinks.slug[slug] || cachedLinks.id[slug] || cachedLinks.uuid[slug])) {
+    throw createError({ statusCode: 404, message: 'Not found (fullSlug)' })
+  }
+}
+
+const clearLinks = async () => {
+  linksList = undefined
+  linksListPromise = null
+
+  const cacheLinks = useStorage('cache:storyblok:links')
+  const cachedKeys = await cacheLinks.getKeys()
+  for (var i in cachedKeys) await cacheLinks.removeItem(cachedKeys[i])
+}
+
+export { request, space, getAll, links, clearLinks }

package/dist/types.d.mts

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

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "gothamstoryblok",
+  "version": "1.0.15",
+  "description": "Gotham.Studio | Storyblok and utils module",
+  "repository": "Gothamsiti/gothamstoryblok",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@nuxt/kit": "^4.2.2",
+    "@storyblok/js": "^4.4.3",
+    "@storyblok/vue": "^9.4.3",
+    "cloudflare": "^5.2.0"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^3.1.1",
+    "@nuxt/eslint-config": "^1.12.1",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^4.2.2",
+    "@nuxt/test-utils": "^3.21.0",
+    "@types/node": "latest",
+    "changelogen": "^0.6.2",
+    "eslint": "^9.39.2",
+    "nuxt": "^4.2.2",
+    "typescript": "~5.9.3",
+    "vitest": "^4.0.16",
+    "vue-tsc": "^3.2.1"
+  },
+  "scripts": {
+    "dev": "npm run dev:prepare && nuxi dev playground",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  }
+}