@mouseless/baked 0.19.0

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

@@ -0,0 +1,3 @@
+export default function _default(): {
+    fetch: (name: any) => Promise<any>;
+};

package/dist/runtime/composables/useLayouts.js

@@ -0,0 +1,21 @@
+import { createError, useNuxtApp } from "#app";
+
+export default function() {
+  const { $layouts } = useNuxtApp();
+
+  async function fetch(name) {
+    if(!$layouts[name]) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: `'${name}' Layout Not Found`,
+        fatal: true
+      });
+    }
+
+    return await $layouts[name]();
+  }
+
+  return {
+    fetch
+  };
+}

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

@@ -0,0 +1,6 @@
+export default function _default({ group }?: {}): {
+    localize: (key: any, parameters?: {}) => any;
+    locale: any;
+    getLocales: () => any;
+    setLocale: (language: any) => void;
+};

package/dist/runtime/composables/useLocalization.js

@@ -0,0 +1,34 @@
+import { useNuxtApp, useRouter, useRuntimeConfig } from "#imports";
+
+export default function({ group } = {}) {
+  const { $i18n: { locale, locales: i18nLocales, setLocaleCookie, t } } = useNuxtApp();
+  const { public: { localization } } = useRuntimeConfig();
+  const router = useRouter();
+
+  function getLocales() {
+    return localization.supportedLanguages.filter(l =>
+      i18nLocales.value.map(l => l.code).includes(l.code)
+    );
+  }
+
+  function setLocale(language) {
+    setLocaleCookie(language);
+    router.go();
+  }
+
+  function localize(key, parameters = {}) {
+    if(!key) { return; }
+
+    const keyWithGroup = group ? `${group}.${key}` : key;
+    const result = t(keyWithGroup, parameters);
+
+    return result === keyWithGroup ? key : result;
+  }
+
+  return {
+    localize,
+    locale,
+    getLocales,
+    setLocale
+  };
+}

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

@@ -0,0 +1,3 @@
+export default function _default(): {
+    compute: () => string;
+};

package/dist/runtime/composables/useLoginRedirect.js

@@ -0,0 +1,15 @@
+import { useRoute, useRuntimeConfig } from "#app";
+
+export default function() {
+  const { public: { auth } } = useRuntimeConfig();
+
+  function compute() {
+    const route = useRoute();
+
+    return `/${auth.loginPageRoute}?redirect=${route.fullPath}`;
+  }
+
+  return {
+    compute
+  };
+}

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

@@ -0,0 +1,3 @@
+export default function _default(): {
+    run: (callback: any) => Promise<void>;
+};

package/dist/runtime/composables/useMutex.js

@@ -0,0 +1,26 @@
+import { E_CANCELED } from "async-mutex";
+
+export default function() {
+  async function run(callback) {
+    const mutex = useNuxtApp().$mutex;
+
+    try {
+      await mutex.acquire();
+      await callback();
+    } catch (e) {
+      if(e !== E_CANCELED) {
+        mutex.cancel();
+      }
+
+      throw e;
+    } finally {
+      if(mutex.isLocked()) {
+        mutex.release();
+      }
+    }
+  }
+
+  return {
+    run
+  };
+}

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

@@ -0,0 +1,3 @@
+export default function _default(): {
+    compute: () => import("vue").Ref<import("#app").NuxtError<unknown> | undefined, import("#app").NuxtError<unknown> | undefined>;
+};

package/dist/runtime/composables/useNuxtError.js

@@ -0,0 +1,13 @@
+import { useError } from "#app";
+
+export default function() {
+  const error = useError();
+
+  function compute() {
+    return error;
+  }
+
+  return {
+    compute
+  };
+}

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

@@ -0,0 +1,3 @@
+export default function _default(): {
+    compute: () => import("vue-router").RouteLocationNormalizedLoadedGeneric;
+};

package/dist/runtime/composables/useNuxtRoute.js

@@ -0,0 +1,13 @@
+import { useRoute } from "#app";
+
+export default function() {
+  const route = useRoute();
+
+  function compute() {
+    return route;
+  }
+
+  return {
+    compute
+  };
+}

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

@@ -0,0 +1,5 @@
+export default function _default(): {
+    fetch: (name: any, { throwNotFound }?: {
+        throwNotFound: boolean;
+    }) => Promise<any>;
+};

package/dist/runtime/composables/usePages.js

@@ -0,0 +1,27 @@
+import { createError, useNuxtApp } from "#app";
+
+export default function() {
+  const { $pages } = useNuxtApp();
+
+  async function fetch(name,
+    { throwNotFound } = { throwNotFound: true }
+  ) {
+    if(!$pages[name]) {
+      if(throwNotFound) {
+        throw createError({
+          statusCode: 404,
+          statusMessage: `'${name}' Page Not Found`,
+          fatal: true
+        });
+      } else {
+        return null;
+      }
+    }
+
+    return await $pages[name]();
+  }
+
+  return {
+    fetch
+  };
+}

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

@@ -0,0 +1,3 @@
+export default function _default(): {
+    compute: () => import("vue-router").LocationQuery;
+};

package/dist/runtime/composables/useQuery.js

@@ -0,0 +1,13 @@
+import { useRoute } from "#app";
+
+export default function() {
+  const route = useRoute();
+
+  function compute() {
+    return route.query;
+  }
+
+  return {
+    compute
+  };
+}

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

@@ -0,0 +1 @@
+export default function _default(): unknown;

package/dist/runtime/composables/useToast.js

@@ -0,0 +1,5 @@
+import { useNuxtApp } from "#app";
+
+export default function() {
+  return useNuxtApp().$toast;
+}

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

@@ -0,0 +1,11 @@
+export default function _default(): {
+    current: (shouldRefresh?: boolean) => Promise<{
+        access: any;
+        refresh: any;
+        displayName: any;
+        accessIsExpired: () => boolean;
+        refreshIsExpired: () => boolean;
+    } | null>;
+    setCurrent: (value: any, dispatch?: boolean) => void;
+    onChanged: (callback: any) => void;
+};

package/dist/runtime/composables/useToken.js

@@ -0,0 +1,99 @@
+import { useRuntimeConfig } from "#app";
+import { createError, useMutex } from "#imports";
+
+export default function() {
+  const mutex = useMutex();
+  const { public: { auth, composables } } = useRuntimeConfig();
+
+  async function current(
+    shouldRefresh = true
+  ) {
+    const tokenString = localStorage.getItem("token");
+    if(!tokenString) { return null; }
+
+    const result = Token(tokenString);
+
+    if(!result.access) { return null; }
+    if(!result.refresh) { return null; }
+
+    if(result.refreshIsExpired()) { return null; }
+    if(result.accessIsExpired() && shouldRefresh) {
+      await refresh();
+
+      return current(false);
+    }
+
+    return result;
+  }
+
+  async function refresh() {
+    await mutex.run(async() => {
+      const token = await current(false);
+      if(!token?.accessIsExpired()) { return; }
+
+      const result = await $fetch(auth.refreshApiRoute,
+        {
+          baseURL: composables.useDataFetcher.baseURL,
+          method: "POST",
+          headers: { "Authorization": `Bearer ${token?.refresh}` }
+        }
+      );
+
+      setCurrent(result, false);
+    });
+  }
+
+  function setCurrent(value,
+    dispatch = true
+  ) {
+    if(!value) {
+      localStorage.removeItem("token");
+    } else {
+      localStorage.setItem("token", JSON.stringify(value));
+    }
+
+    if(dispatch) {
+      globalThis.dispatchEvent(new CustomEvent("token-changed"));
+    }
+  }
+
+  function onChanged(callback) {
+    globalThis.addEventListener("token-changed", callback);
+  }
+
+  return {
+    current,
+    setCurrent,
+    onChanged
+  };
+};
+
+function Token(tokenString) {
+  const { access, refresh, displayName } = JSON.parse(tokenString);
+
+  function accessIsExpired() {
+    return isExpired(access);
+  }
+
+  function refreshIsExpired() {
+    return isExpired(refresh);
+  }
+
+  function isExpired(token) {
+    try {
+      const claims = JSON.parse(atob(token.split(".")[1]));
+
+      return parseInt(claims.exp) * 1000 < Date.now();
+    } catch {
+      throw createError({ statusCode: 401 });
+    }
+  }
+
+  return {
+    access,
+    refresh,
+    displayName,
+    accessIsExpired,
+    refreshIsExpired
+  };
+}

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

@@ -0,0 +1,9 @@
+export default function _default(): import("vue").Ref<{
+    panelStates: {};
+    selectStates: {};
+    selectButtonStates: {};
+}, {
+    panelStates: {};
+    selectStates: {};
+    selectButtonStates: {};
+}>;

package/dist/runtime/composables/useUiStates.js

@@ -0,0 +1,9 @@
+import { useState } from "#imports";
+
+export default function() {
+  return useState("uiStates", () => ({
+    panelStates: { },
+    selectStates: { },
+    selectButtonStates: { }
+  }));
+}

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

@@ -0,0 +1,3 @@
+export default function _default(): {
+    deepUnref: (val: Mixed) => Mixed;
+};

package/dist/runtime/composables/useUnref.js

@@ -0,0 +1,109 @@
+/*
+MIT License
+
+Copyright (c) 2021 Dan Hulton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+
+import { isRef, unref } from "vue";
+
+const isObject = val => val !== null && typeof val === "object";
+const isArray = Array.isArray;
+
+/**
+ * Deeply unref a value, recursing into objects and arrays.
+ *
+ * @param {Mixed} val - The value to deeply unref.
+ *
+ * @return {Mixed}
+ */
+const deepUnref = val => {
+  const checkedVal = isRef(val) ? unref(val) : val;
+
+  if(! isObject(checkedVal)) {
+    return checkedVal;
+  }
+
+  if(isArray(checkedVal)) {
+    return unrefArray(checkedVal);
+  }
+
+  return unrefObject(checkedVal);
+};
+
+/**
+ * Unref a value, recursing into it if it's an object.
+ *
+ * @param {Mixed} val - The value to unref.
+ *
+ * @return {Mixed}
+ */
+const smartUnref = val => {
+  // Non-ref object?  Go deeper!
+  if(val !== null && ! isRef(val) && typeof val === "object") {
+    return deepUnref(val);
+  }
+
+  return unref(val);
+};
+
+/**
+ * Unref an array, recursively.
+ *
+ * @param {Array} arr - The array to unref.
+ *
+ * @return {Array}
+ */
+const unrefArray = arr => {
+  const unreffed = [];
+
+  arr.forEach(val => {
+    unreffed.push(smartUnref(val));
+  });
+
+  return unreffed;
+};
+
+/**
+ * Unref an object, recursively.
+ *
+ * @param {Object} obj - The object to unref.
+ *
+ * @return {Object}
+ */
+const unrefObject = obj => {
+  const unreffed = {};
+
+  // Object? un-ref it!
+  Object.keys(obj).forEach(key => {
+    unreffed[key] = smartUnref(obj[key]);
+  });
+
+  return unreffed;
+};
+
+// --- END OF `vue-deepunref` --- //
+
+export default function() {
+  return {
+    deepUnref
+  };
+}

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

@@ -0,0 +1,81 @@
+import { defineNuxtPlugin, useNuxtApp, useRoute, useRuntimeConfig } from "#app";
+import { useToken } from "#imports";
+
+export default defineNuxtPlugin({
+  name: "auth",
+  enforce: "pre",
+  setup(nuxtApp) {
+    const { public: { auth } } = useRuntimeConfig();
+    const token = useToken();
+    const { $fetchInterceptors, $router } = nuxtApp;
+
+    $fetchInterceptors.register(
+      "auth",
+      async({ request, options }, next) => {
+        // filters out any api call that already has an authorization header,
+        // such as refresh token api call
+        if(options.headers["Authorization"] || options.headers["authorization"]) {
+          return await next();
+        }
+
+        // try get current token
+        let result = await token.current(false);
+        if(!result || result.accessIsExpired()) {
+          // if api is anonymous no need to have a token, will continue
+          // anonymously
+          if(auth.anonymousApiRoutes.some(route => request?.includes(route))) { return await next(); }
+
+          // force get an access token
+          result = await token.current(true);
+        }
+
+        options.headers["Authorization"] = `Bearer ${result?.access}`;
+
+        return await next();
+      },
+      // runs before other interceptors, even early ones like cache
+      // this is to prevent any unintended result when user is not authorized while it should be
+      //
+      // -10 is to leave a room just in case it is needed
+      Number.MIN_SAFE_INTEGER - 10
+    );
+
+    $router.beforeEach(async to => {
+      const token = useToken();
+
+      for(const route of auth.anonymousPageRoutes) {
+        const pattern = new RegExp(route);
+        if(to.path.match(pattern)?.length > 0) {
+          return;
+        }
+      }
+
+      const toLogin = to.path.includes(auth.loginPage);
+      const current = await token.current(!toLogin);
+
+      if(current && toLogin) {
+        await $router.replace(to.query.redirect || "/");
+      } else if(!current && !toLogin) {
+        await $router.replace(`/${auth.loginPageRoute}?redirect=${to.fullPath}`);
+      }
+    });
+  },
+  hooks: {
+    "app:mounted"() {
+      const { $router } = useNuxtApp();
+      const { public: { auth } } = useRuntimeConfig();
+      const route = useRoute();
+      const token = useToken();
+
+      token.onChanged(() => {
+        token.current().then(current => {
+          if(current) {
+            $router.push(route.query.redirect || "/");
+          } else {
+            $router.push(`/${auth.loginPageRoute}`);
+          }
+        });
+      });
+    }
+  }
+});

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

@@ -0,0 +1,10 @@
+declare const _default: import("#app").Plugin<{
+    composables: {};
+    pages: {};
+    layouts: {};
+}> & import("#app").ObjectPlugin<{
+    composables: {};
+    pages: {};
+    layouts: {};
+}>;
+export default _default;

package/dist/runtime/plugins/baked.js

@@ -0,0 +1,50 @@
+import { defineNuxtPlugin } from "#app";
+
+export default defineNuxtPlugin({
+  name: "baked",
+  setup() {
+    const bakedComposables = import.meta.glob("../composables/*");
+    const projectComposables = import.meta.glob("@/composables/*");
+
+    const pages = import.meta.glob("@@/.baked/**/*.page.json");
+    const layouts = import.meta.glob("@@/.baked/**/*.layout.json");
+
+    return {
+      provide: {
+        composables: merge({
+          bakedImports: bakedComposables,
+          projectImports: projectComposables,
+          trimStart: "composables/",
+          trimEnd: "."
+        }),
+        pages: jsonFiles(pages, ".baked/", ".page.json"),
+        layouts: jsonFiles(layouts, ".baked/", ".layout.json")
+      }
+    };
+  }
+});
+
+function merge({ bakedImports, projectImports, trimStart, trimEnd }) {
+  return {
+    ...Object.keys(bakedImports).reduce((result, path) => {
+      result[path.slice(path.indexOf(trimStart) + trimStart.length, path.lastIndexOf(trimEnd))] = bakedImports[path];
+
+      return result;
+    }, { }),
+    ...Object.keys(projectImports).reduce((result, path) => {
+      result[path.slice(path.indexOf(trimStart) + trimStart.length, path.lastIndexOf(trimEnd))] = projectImports[path];
+
+      return result;
+    }, { })
+  };
+}
+
+function jsonFiles(imports, trimStart, trimEnd) {
+  return {
+    ...Object.keys(imports).reduce((result, path) => {
+      result[path.slice(path.indexOf(trimStart) + trimStart.length, path.lastIndexOf(trimEnd))] = imports[path];
+
+      return result;
+    }, { })
+  };
+}

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

@@ -0,0 +1,27 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#app";
+import { useCache } from "#imports";
+
+export default defineNuxtPlugin({
+  name: "cache-application",
+  enforce: "pre",
+  setup(nuxtApp) {
+    const { public: { cacheApplication } } = useRuntimeConfig();
+    const { expirationInMinutes } = cacheApplication;
+    const cache = useCache("cache:application", { expirationInMinutes });
+    const { $fetchInterceptors } = nuxtApp;
+
+    $fetchInterceptors.register(
+      "cache-application",
+      async({ request, options }, next) => {
+        if(options.attributes["client-cache"] !== "application") {
+          return await next();
+        }
+
+        const key = cache.buildKey({ path: request, query: options.query });
+        return await cache.getOrCreate({ key, create: next });
+      },
+      // should run before other interceptors
+      -10
+    );
+  }
+});

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

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