nuxt-glorious 1.2.0 → 1.2.9-5

package/dist/runtime/components/props/Timeline.mjs

@@ -0,0 +1,7 @@
+import { color } from "./common/index.mjs";
+export default {
+  ...color(),
+  items: {
+    required: true
+  }
+};

package/dist/runtime/components/props/common/index.d.ts

@@ -0,0 +1,161 @@
+import type { colors, sizes, rounded as roundedType } from '../../../../types';
+export declare const color: (def?: string) => {
+    color: {
+        required: boolean;
+        default: string;
+        type: () => colors;
+    };
+};
+export declare const size: (def?: sizes) => {
+    size: {
+        required: boolean;
+        default: sizes;
+        type: () => sizes;
+    };
+};
+export declare const rounded: {
+    size: {
+        required: boolean;
+        default: string;
+        type: () => roundedType;
+    };
+};
+export declare const disabled: {
+    disabled: {
+        required: boolean;
+        default: boolean;
+        type: BooleanConstructor;
+    };
+};
+export declare const loading: {
+    loading: {
+        required: boolean;
+        default: boolean;
+        type: BooleanConstructor;
+    };
+    loadingOption: {
+        required: boolean;
+        default: {
+            color: string;
+        };
+        type: {
+            color: StringConstructor;
+        };
+    };
+};
+export declare const to: {
+    to: {
+        required: boolean;
+        default: string;
+        type: StringConstructor;
+    };
+};
+export declare const ariaLabel: {
+    ariaLabel: {
+        required: boolean;
+        default: string;
+        type: StringConstructor;
+    };
+};
+export declare const checked: {
+    checked: {
+        required: boolean;
+        default: boolean;
+        type: BooleanConstructor;
+    };
+};
+export declare const error: {
+    error: {
+        required: boolean;
+        default: string;
+        type: StringConstructor;
+    };
+};
+export declare const placeholder: (def?: string) => {
+    placeholder: {
+        required: boolean;
+        default: string;
+        type: StringConstructor;
+    };
+};
+export declare const title: (def?: string) => {
+    title: {
+        required: boolean;
+        default: string;
+        type: StringConstructor;
+    };
+};
+export declare const text: (def?: string) => {
+    text: {
+        required: boolean;
+        default: string;
+        type: StringConstructor;
+    };
+};
+export declare const name: {
+    name: {
+        required: boolean;
+        type: StringConstructor;
+        default: string;
+    };
+};
+export declare const hashColor: {
+    color: {
+        required: boolean;
+        type: StringConstructor;
+        default: string;
+    };
+};
+export declare const intSize: (def?: number) => {
+    size: {
+        required: boolean;
+        type: NumberConstructor;
+        default: number;
+    };
+};
+export declare const stroke: (def?: number | null) => {
+    stroke: {
+        required: boolean;
+        type: (NumberConstructor | null)[];
+        default: number | null;
+    };
+};
+export declare const icon: {
+    icon: {
+        required: boolean;
+        default: string;
+        type: StringConstructor;
+    };
+};
+export declare const options: {
+    options: {
+        required: boolean;
+        default: never[];
+        type: {
+            (arrayLength: number): object[];
+            (...items: object[]): object[];
+            new (arrayLength: number): object[];
+            new (...items: object[]): object[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+    };
+    loadingOptions: {
+        required: boolean;
+        default: boolean;
+        type: BooleanConstructor;
+    };
+};
+export declare const value: () => {
+    value: {
+        required: boolean;
+        default: string;
+        type: StringConstructor;
+    };
+};

package/dist/runtime/components/props/common/index.mjs

@@ -0,0 +1,147 @@
+export const color = (def = "green") => ({
+  color: {
+    required: false,
+    default: def,
+    type: String
+  }
+});
+export const size = (def = "md") => ({
+  size: {
+    required: false,
+    default: def,
+    type: String
+  }
+});
+export const rounded = {
+  size: {
+    required: false,
+    default: "md",
+    type: String
+  }
+};
+export const disabled = {
+  disabled: {
+    required: false,
+    default: false,
+    type: Boolean
+  }
+};
+export const loading = {
+  loading: {
+    required: false,
+    default: false,
+    type: Boolean
+  },
+  loadingOption: {
+    required: false,
+    default: {
+      color: "green"
+    },
+    type: {
+      color: String
+    }
+  }
+};
+export const to = {
+  to: {
+    required: false,
+    default: "",
+    type: String
+  }
+};
+export const ariaLabel = {
+  ariaLabel: {
+    required: false,
+    default: "",
+    type: String
+  }
+};
+export const checked = {
+  checked: {
+    required: false,
+    default: false,
+    type: Boolean
+  }
+};
+export const error = {
+  error: {
+    required: false,
+    default: "|",
+    type: String
+  }
+};
+export const placeholder = (def = "") => ({
+  placeholder: {
+    required: false,
+    default: def,
+    type: String
+  }
+});
+export const title = (def = "") => ({
+  title: {
+    required: false,
+    default: def,
+    type: String
+  }
+});
+export const text = (def = "") => ({
+  text: {
+    required: false,
+    default: def,
+    type: String
+  }
+});
+export const name = {
+  name: {
+    required: true,
+    type: String,
+    default: ""
+  }
+};
+export const hashColor = {
+  color: {
+    required: false,
+    type: String,
+    default: "#000"
+  }
+};
+export const intSize = (def = 20) => ({
+  size: {
+    required: false,
+    type: Number,
+    default: def
+  }
+});
+export const stroke = (def = null) => ({
+  stroke: {
+    required: false,
+    type: [Number, null],
+    default: def
+  }
+});
+export const icon = {
+  icon: {
+    required: false,
+    default: "",
+    type: String
+  }
+};
+export const options = {
+  options: {
+    required: false,
+    default: [],
+    type: Array
+  },
+  loadingOptions: {
+    required: false,
+    default: false,
+    type: Boolean
+  }
+};
+export const value = () => ({
+  value: {
+    required: false,
+    default: "",
+    type: String
+  }
+});

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

@@ -1,3 +1,3 @@
 export declare const useGloriousCore: {
-    numbersWithSeperateSamePrice: (value: String) => string;
+    numbersWithSeparateSamePrice: (value: String) => string;
 };

package/dist/runtime/composables/useGloriousCore.mjs

@@ -1,5 +1,5 @@
 export const useGloriousCore = {
-  numbersWithSeperateSamePrice: (value) => {
+  numbersWithSeparateSamePrice: (value) => {
     let nStr = value.match(/\d+/g)?.join("") + "";
     nStr = nStr.replace(/\,/g, "");
     if (nStr === "undefined") nStr = "";

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

@@ -6,9 +6,10 @@ interface gloriousFetchOptions {
     lazy?: Boolean;
     headers?: Object;
     body?: Object;
-    bodyType?: "formData" | "formDataCustom" | "normal";
-    method?: "POST" | "GET" | "PATCH" | "PUT" | "DELETE" | "HEAD";
-    credentials?: "same-origin" | "include";
+    keepResponse?: Boolean;
+    bodyType?: 'formData' | 'formDataCustom' | 'normal';
+    method?: 'POST' | 'GET' | 'PATCH' | 'PUT' | 'DELETE' | 'HEAD';
+    credentials?: 'same-origin' | 'include';
     watch?: Array<Object>;
 }
 export default function (url: string, options?: gloriousFetchOptions): Promise<unknown>;

package/dist/runtime/composables/useGloriousFetch.mjs

@@ -6,6 +6,7 @@ const defaultOptions = {
   method: "GET",
   lazy: true,
   is$: true,
+  keepResponse: false,
   params: {},
   headers: {
     Accept: "application/json"
@@ -29,12 +30,11 @@ export default function(url, options = defaultOptions) {
       } catch (e) {
       }
     },
-    onResponse({ response: res }) {
+    onResponse({ response }) {
+      gs.response[gKey] = response._data;
       try {
         gs.loading[gKey] = false;
         gs.forms[gKey].errors = [];
-        if (res.status >= 200 && res.status <= 299 && Object.prototype.hasOwnProperty.call(options, "saveBody") && !options.saveBody)
-          gs.forms[gKey].form = {};
       } catch (e) {
       }
     },
@@ -55,6 +55,8 @@ export default function(url, options = defaultOptions) {
       }
     }
   };
+  if (opt.keepResponse && !gs.keepResponse.includes(gKey))
+    gs.keepResponse.push(gKey);
   if (opt.method === "GET" && typeof opt.body !== "undefined") {
     opt.method = "POST";
     return $fetch(url, opt);
@@ -83,9 +85,8 @@ function computeAuth() {
 function computeFormData(options) {
   const form = new FormData();
   Object.entries(options.body).forEach((item) => {
-    console.log(item[1]);
     if (item[1] === null) return;
-    if (typeof item[1] === "object" && typeof item[1].lastModifiedDate === "undefined" && (typeof item[1].type === "undefined" && typeof item[1].size === "undefined"))
+    if (typeof item[1] === "object" && typeof item[1].lastModifiedDate === "undefined" && typeof item[1].type === "undefined" && typeof item[1].size === "undefined")
       Object.entries(item[1]).forEach((nestedItem, index) => {
         form.append(`${item[0]}[${index}]`, nestedItem[1]);
       });

package/dist/runtime/middlewares/AuthStrategy.mjs

@@ -1,9 +1,5 @@
-import {
-  GloriousStore,
-  defineNuxtRouteMiddleware,
-  useCookie,
-  useNuxtApp
-} from "#imports";
+import { defineNuxtRouteMiddleware, useCookie, useNuxtApp } from "#imports";
+import { GloriousStore } from "../stores/GloriousStore.mjs";
 export default defineNuxtRouteMiddleware(() => {
   const nuxtApp = useNuxtApp();
   const moduleConfig = nuxtApp.$config.public.glorious;

package/dist/runtime/middlewares/ResponseGloriousStore.mjs

@@ -0,0 +1,9 @@
+import { defineNuxtRouteMiddleware } from "#imports";
+import { GloriousStore } from "../stores/GloriousStore.mjs";
+export default defineNuxtRouteMiddleware((to, from) => {
+  if (to.path === from.path) return;
+  const gs = GloriousStore();
+  Object.entries(gs.response).forEach((element) => {
+    if (!gs.keepResponse.includes(element[0])) delete gs.response[element[0]];
+  });
+});

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

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

package/dist/runtime/plugins/InputComponent.mjs

@@ -0,0 +1,13 @@
+import { defineNuxtPlugin } from "#imports";
+export default defineNuxtPlugin((nuxtApp) => {
+  nuxtApp.hook("app:beforeMount", () => {
+    window.addEventListener("click", (event) => {
+      if (!event.target.matches(".glorious-input-field")) {
+        const options = document.querySelectorAll(".glorious-input-options");
+        options.forEach((el) => {
+          el.classList.add("hidden");
+        });
+      }
+    });
+  });
+});

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

@@ -0,0 +1,4 @@
+export interface ModuleOptions {
+}
+declare const _default: import("@nuxt/schema").NuxtModule<ModuleOptions, ModuleOptions, false>;
+export default _default;

package/dist/runtime/plugins/module.mjs

@@ -0,0 +1,94 @@
+import {
+  defineNuxtModule,
+  addPlugin,
+  addComponentsDir,
+  createResolver,
+  addImportsDir,
+  installModule,
+  addRouteMiddleware
+} from "@nuxt/kit";
+import defu from "defu";
+export default defineNuxtModule({
+  meta: {
+    name: "glorious",
+    configKey: "glorious"
+  },
+  // Default configuration options of the Nuxt module
+  defaults: {},
+  async setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    nuxt.options.runtimeConfig.public.glorious = defu(nuxt.options.glorious, {
+      fetch: {
+        baseURL: "/",
+        credentials: "same-origin"
+      },
+      seo: {
+        suffix: "",
+        title: "",
+        description: ""
+      },
+      auth: {
+        cookie: {
+          name: "ga-token",
+          httpOnly: false
+        },
+        redirect: {
+          logout: "/login",
+          login: "/login"
+        },
+        strategy: {
+          provider: "",
+          //[laravel-passport]
+          endpoints: {
+            userInfo: {
+              url: "/",
+              method: "GET",
+              pick: ""
+            }
+          }
+        }
+      }
+    });
+    await installModule("@nuxtjs/tailwindcss", {
+      // module configuration
+      exposeConfig: true,
+      config: {
+        darkMode: "class",
+        content: {
+          files: [
+            resolver.resolve("./runtime/components/G/**/*.{vue,mjs,ts}"),
+            resolver.resolve("./runtime/*.{mjs,js,ts}")
+          ]
+        }
+      }
+    });
+    await installModule("@pinia/nuxt");
+    addImportsDir(resolver.resolve("runtime/composables"));
+    addImportsDir(resolver.resolve("runtime/stores"));
+    addImportsDir(resolver.resolve("runtime/middlewares"));
+    addComponentsDir({
+      path: resolver.resolve("runtime/components"),
+      global: true,
+      watch: false
+    });
+    nuxt.hook("nitro:config", async (nitro) => {
+      nitro.publicAssets.push({
+        dir: resolver.resolve("./runtime/assets")
+      });
+    });
+    addPlugin(resolver.resolve("./runtime/plugins/glorious-app-setting"));
+    addPlugin({
+      src: resolver.resolve("./runtime/plugins/InputComponent"),
+      mode: "client"
+    });
+    addRouteMiddleware({
+      name: "g-auth-strategy",
+      path: resolver.resolve("./runtime/middlewares/AuthStrategy"),
+      global: true
+    });
+    addRouteMiddleware({
+      name: "g-auth",
+      path: resolver.resolve("./runtime/middlewares/Auth")
+    });
+  }
+});

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

@@ -2,7 +2,6 @@ export declare const GloriousStore: import("pinia").StoreDefinition<"GloriousSto
     authIsLogin(): boolean;
 }, {
     formCreate(key: string | Array<string>): void;
-    modalCreate(key: string | Array<string>): void;
     authLogout(): void;
     authSetToken(token: string, to?: string | null): void;
     authParseToken(token: any): any;

package/dist/runtime/stores/GloriousStore.mjs

@@ -8,7 +8,9 @@ export const GloriousStore = defineStore("GloriousStore", {
     },
     loading: {},
     keepData: {},
-    forms: {}
+    forms: {},
+    response: {},
+    keepResponse: []
   }),
   getters: {
     authIsLogin() {
@@ -33,18 +35,6 @@ export const GloriousStore = defineStore("GloriousStore", {
           };
         });
     },
-    modalCreate(key) {
-      this.modals = {};
-      const defaultValue = {
-        show: false,
-        keepData: {}
-      };
-      if (typeof key === "string") this.modals[key] = defaultValue;
-      else
-        key.map((item) => {
-          this.modals[item] = defaultValue;
-        });
-    },
     authLogout() {
       const moduleConfig = useRuntimeConfig();
       const token = useCookie(moduleConfig.public.glorious.auth.cookie.name);

package/dist/runtime/style/components/alert.css

@@ -0,0 +1,33 @@
+.glorious-alert {
+  @apply p-3 rounded shadow;
+}
+.glorious-alert.color-orange {
+  @apply bg-orange-100;
+}
+.glorious-alert.color-blue {
+  @apply bg-blue-100;
+}
+.glorious-alert.color-gray {
+  @apply bg-gray-100;
+}
+.glorious-alert.color-red {
+  @apply bg-red-100;
+}
+.glorious-alert.color-green {
+  @apply bg-green-100;
+}
+.glorious-alert.color-orange {
+  @apply border border-orange-300;
+}
+.glorious-alert.color-blue {
+  @apply border border-blue-300;
+}
+.glorious-alert.color-gray {
+  @apply border border-gray-300;
+}
+.glorious-alert.color-red {
+  @apply border border-red-300;
+}
+.glorious-alert.color-green {
+  @apply border border-green-300;
+}

package/dist/runtime/style/components/alert.scss

@@ -0,0 +1,7 @@
+@use '../mixin.scss' as mixin;
+
+.glorious-alert {
+  @apply p-3 rounded shadow;
+  @include mixin.load-bg();
+  @include mixin.load-border();
+}

package/dist/runtime/style/components/avatar.css

@@ -0,0 +1,57 @@
+.glorious-avatar {
+  @apply overflow-hidden;
+}
+.glorious-avatar.size-5xl {
+  @apply w-[58px] h-[58px];
+}
+.glorious-avatar.size-5xl > img {
+  @apply w-[58px] h-[58px];
+}
+.glorious-avatar.size-4xl {
+  @apply w-[54px] h-[54px];
+}
+.glorious-avatar.size-4xl > img {
+  @apply w-[54px] h-[54px];
+}
+.glorious-avatar.size-3xl {
+  @apply w-[50px] h-[50px];
+}
+.glorious-avatar.size-3xl > img {
+  @apply w-[50px] h-[50px];
+}
+.glorious-avatar.size-2xl {
+  @apply w-[46px] h-[46px];
+}
+.glorious-avatar.size-2xl > img {
+  @apply w-[46px] h-[46px];
+}
+.glorious-avatar.size-xl {
+  @apply w-[42px] h-[42px];
+}
+.glorious-avatar.size-xl > img {
+  @apply w-[42px] h-[42px];
+}
+.glorious-avatar.size-lg {
+  @apply w-[36px] h-[36px];
+}
+.glorious-avatar.size-lg > img {
+  @apply w-[36px] h-[36px];
+}
+.glorious-avatar.size-md {
+  @apply w-[32px] h-[32px];
+}
+.glorious-avatar.size-md > img {
+  @apply w-[32px] h-[32px];
+}
+.glorious-avatar.size-sm {
+  @apply w-[28px] h-[28px];
+}
+.glorious-avatar.size-sm > img {
+  @apply w-[28px] h-[28px];
+}
+.glorious-avatar.size-xs {
+  @apply w-[24px] h-[24px];
+}
+.glorious-avatar.size-xs > img {
+  @apply w-[24px] h-[24px];
+}

package/dist/runtime/style/components/avatar.scss

@@ -0,0 +1,13 @@
+@use '../variable.scss' as var;
+
+.glorious-avatar {
+  @apply overflow-hidden;
+  @each $key, $value in var.$sizes {
+    &.#{'size-' + $key} {
+      @apply #{"w-[" + ($value + 4 ) + "px] h-[" + ($value + 4 ) + "px]"};
+      > img {
+        @apply #{"w-[" + ($value + 4 ) + "px] h-[" + ($value + 4 ) + "px]"};
+      }
+    }
+  }
+}

package/dist/runtime/style/components/breadcrumb.css

@@ -0,0 +1,6 @@
+.glorious-breadcrumb {
+  @apply text-xs;
+}
+.glorious-breadcrumb .end-text {
+  @apply font-bold;
+}

package/dist/runtime/style/components/breadcrumb.scss

@@ -0,0 +1,6 @@
+.glorious-breadcrumb{
+    @apply text-xs;
+    .end-text{
+        @apply font-bold
+    }
+}