@ciwergrp/nuxid 1.0.2-release

package/dist/module.mjs

@@ -0,0 +1,439 @@
+import { addImports, addPlugin, addImportsDir, defineNuxtModule, createResolver, installModule } from '@nuxt/kit';
+import * as lodash from 'lodash-es';
+import { fileURLToPath } from 'node:url';
+export * from '../dist/runtime/form.js';
+export { default as useForm } from '../dist/runtime/form.js';
+export * from '../dist/runtime/validator.js';
+export * from '../dist/runtime/helper/index.js';
+
+const lodashExcludes = [
+  "wrapperValue",
+  "wrapperToIterator",
+  "wrapperReverse",
+  "wrapperPlant",
+  "wrapperNext",
+  "wrapperLodash",
+  "wrapperCommit",
+  "wrapperChain",
+  "wrapperAt",
+  "templateSettings",
+  "toIterator",
+  "VERSION",
+  "lodash",
+  "value",
+  "valueOf",
+  "toJSON",
+  "thru",
+  "plant",
+  "next",
+  "default",
+  "commit",
+  "head"
+];
+
+const lodashDefaults = {
+  enabled: false,
+  // prefix: false,
+  prefix: "ki",
+  prefixSkip: "is",
+  upperAfterPrefix: true,
+  exclude: [],
+  alias: []
+};
+const toArray = (value) => value ? Array.isArray(value) ? value : [value] : [];
+function resolveLodashOptions(input) {
+  if (input === false) {
+    return { ...lodashDefaults, enabled: false };
+  }
+  const overrides = typeof input === "boolean" || input === void 0 ? {} : input;
+  return {
+    ...lodashDefaults,
+    ...overrides,
+    enabled: overrides?.enabled ?? true,
+    exclude: [
+      ...lodashExcludes,
+      ...lodashDefaults.exclude,
+      ...overrides?.exclude ?? []
+    ],
+    alias: overrides?.alias ?? lodashDefaults.alias
+  };
+}
+function registerLodashFeature(options, resolve) {
+  if (!options.enabled) {
+    return;
+  }
+  const aliasMap = new Map(options.alias);
+  const excludes = new Set(options.exclude);
+  const skipPrefixes = toArray(options.prefixSkip);
+  for (const name of Object.keys(lodash)) {
+    if (excludes.has(name)) {
+      continue;
+    }
+    const alias = aliasMap.get(name) ?? name;
+    const shouldPrefix = options.prefix && !skipPrefixes.some((key) => alias.startsWith(key));
+    const as = shouldPrefix ? `${options.prefix}${options.upperAfterPrefix ? lodash.upperFirst(alias) : alias}` : alias;
+    addImports({ name, as, from: resolve("./runtime/lodash") });
+  }
+}
+
+const validatorDefaults = {
+  enabled: false
+};
+function resolveValidatorOptions(input) {
+  if (input === false) {
+    return { ...validatorDefaults, enabled: false };
+  }
+  const overrides = typeof input === "boolean" || input === void 0 ? {} : input;
+  return {
+    ...validatorDefaults,
+    ...overrides,
+    enabled: overrides?.enabled ?? true
+  };
+}
+function registerValidatorFeature(options, { from }) {
+  if (!options.enabled) {
+    return;
+  }
+  addImports({ name: "createValidationRules", as: "createValidationRules", from });
+  addImports({ name: "ValidationRule", as: "ValidationRule", from, type: true });
+  addImports({ name: "ValidationOptions", as: "ValidationOptions", from, type: true });
+}
+
+const iconDefaults = {
+  enabled: false,
+  config: {
+    componentName: "KIcon",
+    size: "1.25em",
+    class: "align-middle inline-block text-current",
+    mode: "svg"
+  }
+};
+function resolveIconOptions(input) {
+  if (input === false) {
+    return { ...iconDefaults, enabled: false };
+  }
+  if (input === void 0) {
+    return iconDefaults;
+  }
+  const overrides = typeof input === "boolean" ? {} : input;
+  return {
+    ...iconDefaults,
+    ...overrides,
+    enabled: overrides.enabled ?? true,
+    config: overrides.config ?? iconDefaults.config
+  };
+}
+
+const formDefaults = {
+  enabled: false
+};
+function resolveFormOptions(input) {
+  if (input === false) {
+    return { ...formDefaults, enabled: false };
+  }
+  const overrides = typeof input === "boolean" || input === void 0 ? {} : input;
+  return {
+    ...formDefaults,
+    ...overrides,
+    enabled: overrides?.enabled ?? true
+  };
+}
+function registerFormFeature(options, { from }) {
+  if (!options.enabled) {
+    return;
+  }
+  addImports({ name: "default", as: "useForm", from });
+  addImports({ name: "UseForm", as: "UseForm", from, type: true });
+  addImports({ name: "KibanFormOptions", as: "KibanFormOptions", from, type: true });
+}
+
+const elementPlusDefaults = {
+  enabled: false,
+  config: {}
+};
+function resolveElementPlusOptions(input) {
+  if (input === false) {
+    return { ...elementPlusDefaults, enabled: false };
+  }
+  if (input === void 0) {
+    return elementPlusDefaults;
+  }
+  const overrides = typeof input === "boolean" ? {} : input;
+  return {
+    ...elementPlusDefaults,
+    ...overrides,
+    enabled: overrides.enabled ?? true,
+    config: overrides.config ?? elementPlusDefaults.config
+  };
+}
+
+const helperDefaults = {
+  enabled: false,
+  config: {
+    style: "factory",
+    localeSource: "cookie",
+    localeKey: "lang",
+    localeFallback: "en",
+    defaultCurrency: "USD"
+  }
+};
+function resolveHelperOptions(input) {
+  if (input === false) {
+    return helperDefaults;
+  }
+  const overrides = typeof input === "boolean" || input === void 0 ? {} : input;
+  const config = overrides.config ?? {};
+  return {
+    enabled: overrides?.enabled ?? true,
+    config: {
+      style: config.style ?? helperDefaults.config.style,
+      localeSource: config.localeSource ?? helperDefaults.config.localeSource,
+      localeKey: config.localeKey ?? helperDefaults.config.localeKey,
+      localeFallback: config.localeFallback ?? helperDefaults.config.localeFallback,
+      defaultCurrency: config.defaultCurrency ?? helperDefaults.config.defaultCurrency
+    }
+  };
+}
+function registerHelperFeature(options, { from }) {
+  if (!options.enabled) {
+    return;
+  }
+  const style = options.config.style;
+  if (style === "factory") {
+    addImports({ name: "array", as: "array", from });
+    addImports({ name: "object", as: "object", from });
+    addImports({ name: "number", as: "number", from });
+    addImports({ name: "string", as: "string", from });
+    return;
+  }
+  const numberExports = [
+    "abbreviate",
+    "forHumans",
+    "clamp",
+    "currency",
+    "defaultCurrency",
+    "defaultLocale",
+    "fileSize",
+    "format",
+    "ordinal",
+    "pairs",
+    "parse",
+    "parseFloatNumber",
+    "parseIntNumber",
+    "percentage",
+    "spell",
+    "spellOrdinal",
+    "trim",
+    "useLocale",
+    "withLocale",
+    "useCurrency",
+    "withCurrency"
+  ];
+  const arrayExports = [
+    "collapse",
+    "crossJoin",
+    "every",
+    "first",
+    "flatten",
+    "join",
+    "last",
+    "map",
+    "mapSpread",
+    "partition",
+    "random",
+    "reject",
+    "shuffle",
+    "sole",
+    "some",
+    "sort",
+    "sortDesc",
+    "take",
+    "where",
+    "whereNotNull",
+    "wrap"
+  ];
+  const objectExports = [
+    "add",
+    "dot",
+    "except",
+    "forget",
+    "get",
+    "has",
+    "only",
+    "set",
+    "undot"
+  ];
+  const stringExports = [
+    "after",
+    "afterLast",
+    "ascii",
+    "defaultLocale",
+    "before",
+    "beforeLast",
+    "between",
+    "betweenFirst",
+    "camel",
+    "contains",
+    "containsAll",
+    "endsWith",
+    "finish",
+    "kebab",
+    "lcfirst",
+    "length",
+    "lower",
+    "padBoth",
+    "padLeft",
+    "padRight",
+    "plural",
+    "pluralStudly",
+    "remove",
+    "replace",
+    "replaceFirst",
+    "replaceLast",
+    "rtrim",
+    "singular",
+    "slug",
+    "snake",
+    "start",
+    "startsWith",
+    "studly",
+    "title",
+    "transliterate",
+    "ucfirst",
+    "upper",
+    "wordCount",
+    "words",
+    "wrap",
+    "useLocale",
+    "withLocale"
+  ];
+  for (const name of numberExports) {
+    const as = `${capitalize(name)}`;
+    addImports({ name, as, from });
+  }
+  for (const name of arrayExports) {
+    const as = `${capitalize(name)}`;
+    addImports({ name, as, from });
+  }
+  for (const name of objectExports) {
+    const as = `${capitalize(name)}`;
+    addImports({ name, as, from });
+  }
+  for (const name of stringExports) {
+    const as = `${capitalize(name)}`;
+    addImports({ name, as, from });
+  }
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+const piniaDefaults = {
+  enabled: false,
+  storesDirs: ["stores"]
+};
+function resolvePiniaOptions(input) {
+  if (input === false) {
+    return { ...piniaDefaults, enabled: false };
+  }
+  const overrides = typeof input === "boolean" || input === void 0 ? {} : input;
+  return {
+    ...piniaDefaults,
+    ...overrides,
+    enabled: overrides.enabled ?? true,
+    storesDirs: overrides.storesDirs ?? piniaDefaults.storesDirs
+  };
+}
+function registerPiniaFeature(options, nuxt, { runtimeDir, payload, plugin, composables, resolver }) {
+  if (!options.enabled) {
+    return;
+  }
+  nuxt.options.build.transpile.push(runtimeDir);
+  nuxt.options.vite.optimizeDeps ??= {};
+  nuxt.options.vite.optimizeDeps.exclude ??= [];
+  if (!nuxt.options.vite.optimizeDeps.exclude.includes("pinia")) {
+    nuxt.options.vite.optimizeDeps.exclude.push("pinia");
+  }
+  nuxt.hook("prepare:types", ({ references }) => {
+    references.push({ types: "@pinia/nuxt" });
+  });
+  nuxt.hook("modules:done", () => {
+    addPlugin(plugin);
+    addPlugin(payload);
+  });
+  addImports([
+    { from: composables, name: "defineStore" },
+    { from: composables, name: "acceptHMRUpdate" },
+    { from: composables, name: "usePinia" },
+    { from: composables, name: "storeToRefs" },
+    { from: composables, name: "defineStore", as: "definePiniaStore" }
+  ]);
+  for (const storeDir of options.storesDirs) {
+    addImportsDir(resolver.resolve(nuxt.options.srcDir, storeDir));
+  }
+}
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "nuxid",
+    configKey: "kiban"
+  },
+  moduleDependencies() {
+    const dependencies = {
+      "@sentry/nuxt": {
+        version: "10.32.1"
+      },
+      "@vueuse/nuxt": {
+        version: "14.1.0"
+      }
+    };
+    return dependencies;
+  },
+  async setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    const lodashOptions = resolveLodashOptions(options.lodash);
+    const validatorOptions = resolveValidatorOptions(options.validator);
+    const formOptions = resolveFormOptions(options.form);
+    const iconOptions = resolveIconOptions(options.icon);
+    const elementPlusOptions = resolveElementPlusOptions(options.elementPlus);
+    const helperOptions = resolveHelperOptions(options.helper);
+    const piniaOptions = resolvePiniaOptions(options.pinia);
+    if (iconOptions.enabled) {
+      await installModule("@nuxt/icon", iconOptions.config);
+    }
+    if (elementPlusOptions.enabled) {
+      await installModule("@element-plus/nuxt", elementPlusOptions.config);
+    }
+    if (lodashOptions.enabled) {
+      registerLodashFeature(lodashOptions, resolver.resolve);
+    }
+    if (validatorOptions.enabled) {
+      registerValidatorFeature(validatorOptions, {
+        from: resolver.resolve("./runtime/validator")
+      });
+    }
+    if (formOptions.enabled) {
+      registerFormFeature(formOptions, {
+        from: resolver.resolve("./runtime/form")
+      });
+    }
+    if (helperOptions.enabled) {
+      registerHelperFeature(helperOptions, {
+        from: resolver.resolve("./runtime/helper")
+      });
+    }
+    if (piniaOptions.enabled) {
+      const piniaRuntimeDir = fileURLToPath(new URL("./runtime/pinia", import.meta.url));
+      registerPiniaFeature(piniaOptions, nuxt, {
+        runtimeDir: resolver.resolve(piniaRuntimeDir),
+        payload: resolver.resolve(piniaRuntimeDir, "payload-plugin"),
+        plugin: resolver.resolve(piniaRuntimeDir, "plugin"),
+        composables: resolver.resolve(piniaRuntimeDir, "composables"),
+        resolver
+      });
+    }
+    addPlugin(resolver.resolve("./runtime/plugin"));
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/form.d.ts

@@ -0,0 +1,21 @@
+import type { HTTPMethod } from 'h3';
+import type { NitroFetchOptions, NitroFetchRequest } from 'nitropack';
+export type FormFetcher = <T = any>(request: NitroFetchRequest, opts?: NitroFetchOptions<NitroFetchRequest>) => Promise<T>;
+export interface UseForm<DefaultResponseType = any> {
+    _method?: HTTPMethod;
+    submit: <APIResponseType = DefaultResponseType>(method: HTTPMethod, url: NitroFetchRequest, options?: NitroFetchOptions<NitroFetchRequest>) => Promise<APIResponseType>;
+    post: <APIResponseType = DefaultResponseType>(url: NitroFetchRequest, options?: NitroFetchOptions<NitroFetchRequest>) => Promise<APIResponseType>;
+    patch: <APIResponseType = DefaultResponseType>(url: NitroFetchRequest, options?: NitroFetchOptions<NitroFetchRequest>) => Promise<APIResponseType>;
+    put: <APIResponseType = DefaultResponseType>(url: NitroFetchRequest, options?: NitroFetchOptions<NitroFetchRequest>) => Promise<APIResponseType>;
+    delete: <APIResponseType = DefaultResponseType>(url: NitroFetchRequest, options?: NitroFetchOptions<NitroFetchRequest>) => Promise<APIResponseType>;
+    processing: boolean;
+    errors: any;
+    response: Record<string, any> | null;
+    [key: string]: any;
+}
+export interface FormComposableOptions {
+    alwaysFormData?: boolean;
+    fetcher?: FormFetcher;
+    fetchOptions?: NitroFetchOptions<NitroFetchRequest>;
+}
+export default function useForm<TData extends object, DefaultResponseType = any>(initialData: TData, formOptions?: FormComposableOptions): TData & UseForm<DefaultResponseType>;

package/dist/runtime/form.js

@@ -0,0 +1,161 @@
+import { reactive, ref, toRaw } from "vue";
+function normalizeStringWhitespace(value) {
+  return value.trim().replace(/\s{2,}/g, " ");
+}
+function normalizeValue(value) {
+  if (typeof value === "string") {
+    return normalizeStringWhitespace(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeValue(item));
+  }
+  if (value && typeof value === "object" && !(value instanceof File) && Object.prototype.toString.call(value) === "[object Object]") {
+    return Object.keys(value).reduce((normalized, key) => {
+      normalized[key] = normalizeValue(value[key]);
+      return normalized;
+    }, {});
+  }
+  return value;
+}
+export default function useForm(initialData, formOptions) {
+  const form = reactive({
+    ...initialData,
+    response: null,
+    errors: {},
+    processing: false,
+    submit: async (method, url, options) => {
+      const isMultipart = ref(false);
+      const formDataBody = new FormData();
+      form.processing = true;
+      form.response = null;
+      form.errors = {};
+      const excludedKeys = [
+        "errors",
+        "processing",
+        "response",
+        "post",
+        "patch",
+        "put",
+        "delete",
+        "submit",
+        "rules"
+      ];
+      const plainBodyObject = {};
+      const formData = { ...toRaw(form) };
+      for (const key in formData) {
+        if (!Object.prototype.hasOwnProperty.call(formData, key) || excludedKeys.includes(key)) {
+          continue;
+        }
+        const value = normalizeValue(formData[key]);
+        form[key] = value;
+        if (value instanceof File || Array.isArray(value) && value.some((item) => item instanceof File)) {
+          isMultipart.value = true;
+        }
+        if (value instanceof File) {
+          formDataBody.append(key, value);
+        } else if (Array.isArray(value) && value.every((item) => item instanceof File)) {
+          value.forEach((file) => formDataBody.append(`${key}[]`, file));
+        } else if (Array.isArray(value)) {
+          value.forEach((item, index) => {
+            if (typeof item === "object" && item !== null && !(item instanceof File)) {
+              Object.keys(item).forEach((subKey) => {
+                const fieldName = `${key}[${index}][${subKey}]`;
+                formDataBody.append(fieldName, String(item[subKey] || ""));
+              });
+            } else {
+              const fieldName = `${key}[${index}]`;
+              formDataBody.append(fieldName, String(item));
+            }
+          });
+          plainBodyObject[key] = value;
+        } else if (typeof value === "object" && value !== null && !(value instanceof File)) {
+          Object.keys(value).forEach((subKey) => {
+            const fieldName = `${key}[${subKey}]`;
+            if (Array.isArray(value[subKey])) {
+              value[subKey].forEach((arrayItem, arrayIndex) => {
+                const arrayFieldName = `${fieldName}[${arrayIndex}]`;
+                formDataBody.append(arrayFieldName, String(arrayItem));
+              });
+            } else {
+              formDataBody.append(fieldName, String(value[subKey] || ""));
+            }
+          });
+          plainBodyObject[key] = value;
+        } else {
+          if (value !== null && value !== void 0) {
+            formDataBody.append(key, String(value));
+          } else if (value === null) {
+            formDataBody.append(key, "");
+          }
+          plainBodyObject[key] = value;
+        }
+      }
+      const fetchOptions = {
+        ...formOptions?.fetchOptions,
+        ...options,
+        method,
+        body: formOptions?.alwaysFormData || isMultipart.value ? formDataBody : plainBodyObject,
+        onRequestError(context) {
+          form.processing = false;
+          if (typeof formOptions?.fetchOptions?.onRequestError === "function") {
+            formOptions.fetchOptions.onRequestError(context);
+          }
+          if (typeof options?.onRequestError === "function") {
+            options.onRequestError(context);
+          }
+        },
+        onResponse(context) {
+          if (context.response.ok) {
+            form.response = context.response._data;
+          }
+          form.errors = {};
+          form.processing = false;
+          if (typeof formOptions?.fetchOptions?.onResponse === "function") {
+            formOptions.fetchOptions.onResponse(context);
+          }
+          if (typeof options?.onResponse === "function") {
+            options.onResponse(context);
+          }
+        },
+        async onResponseError(context) {
+          if (context.response._data && typeof context.response._data === "object") {
+            const responseData = context.response._data;
+            if (responseData.errors) {
+              form.errors = responseData.errors;
+            } else if (responseData.message || responseData.error) {
+              form.errors = responseData;
+            } else {
+              form.errors = responseData;
+            }
+          } else {
+            form.errors = {};
+          }
+          if (typeof formOptions?.fetchOptions?.onResponseError === "function") {
+            formOptions.fetchOptions.onResponseError(context);
+          }
+          if (typeof options?.onResponseError === "function") {
+            options.onResponseError(context);
+          }
+        }
+      };
+      const fetcher = formOptions?.fetcher ?? globalThis.$fetch;
+      if (!fetcher) {
+        throw new Error("Nuxt $fetch is not available in the current context");
+      }
+      return fetcher(url, fetchOptions);
+    },
+    post: (url, options) => {
+      return form.submit("POST", url, options);
+    },
+    patch: (url, options) => {
+      return form.submit("PATCH", url, options);
+    },
+    put: (url, options) => {
+      return form.submit("PUT", url, options);
+    },
+    delete: (url, options) => {
+      return form.submit("DELETE", url, options);
+    }
+  });
+  return form;
+}

package/dist/runtime/helper/array/collapse.d.ts

@@ -0,0 +1 @@
+export declare function collapse<T>(arrays: Array<T[]>): T[];

package/dist/runtime/helper/array/collapse.js

@@ -0,0 +1,9 @@
+export function collapse(arrays) {
+  const result = [];
+  for (const item of arrays) {
+    if (Array.isArray(item)) {
+      result.push(...item);
+    }
+  }
+  return result;
+}

package/dist/runtime/helper/array/crossJoin.d.ts

@@ -0,0 +1 @@
+export declare function crossJoin<T>(...arrays: T[][]): T[][];

package/dist/runtime/helper/array/crossJoin.js

@@ -0,0 +1,17 @@
+export function crossJoin(...arrays) {
+  if (arrays.length === 0) {
+    return [];
+  }
+  return arrays.reduce(
+    (acc, curr) => {
+      const next = [];
+      for (const prefix of acc) {
+        for (const value of curr) {
+          next.push([...prefix, value]);
+        }
+      }
+      return next;
+    },
+    [[]]
+  );
+}

package/dist/runtime/helper/array/every.d.ts

@@ -0,0 +1 @@
+export declare function every<T>(array: T[], predicate: (item: T, index: number) => boolean): boolean;

package/dist/runtime/helper/array/every.js

@@ -0,0 +1,3 @@
+export function every(array, predicate) {
+  return array.every(predicate);
+}

package/dist/runtime/helper/array/first.d.ts

@@ -0,0 +1 @@
+export declare function first<T>(array: T[], callback?: (item: T, index: number) => boolean, defaultValue?: T | null): T | null;

package/dist/runtime/helper/array/first.js

@@ -0,0 +1,11 @@
+export function first(array, callback, defaultValue = null) {
+  if (!callback) {
+    return array.length ? array[0] : defaultValue;
+  }
+  for (let i = 0; i < array.length; i++) {
+    if (callback(array[i], i)) {
+      return array[i];
+    }
+  }
+  return defaultValue;
+}

package/dist/runtime/helper/array/flatten.d.ts

@@ -0,0 +1 @@
+export declare function flatten<T>(input: T[], depth?: number): any[];

package/dist/runtime/helper/array/flatten.js

@@ -0,0 +1,14 @@
+export function flatten(input, depth = Infinity) {
+  if (depth <= 0) {
+    return [...input];
+  }
+  const result = [];
+  for (const item of input) {
+    if (Array.isArray(item) && depth > 0) {
+      result.push(...flatten(item, depth - 1));
+    } else {
+      result.push(item);
+    }
+  }
+  return result;
+}