@mythpe/quasar-ui-qui 0.1.84 → 0.1.86

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mythpe/quasar-ui-qui",
-  "version": "0.1.84",
+  "version": "0.1.86",
   "description": "MyTh Quasar UI Kit App Extension",
   "author": {
     "name": "MyTh Ahmed Faiz",
@@ -33,7 +33,6 @@
     "axios": "^1.7.8",
     "change-case": "^5.4.4",
     "ckeditor5": "^43.3.1",
-    "pluralize": "^8.0.0",
     "qs": "^6.13.1",
     "radash": "^12.1.0",
     "typed.js": "^2.1.0",
@@ -50,7 +49,6 @@
     "@rollup/plugin-replace": "^6.0.1",
     "@types/express": "^5.0.0",
     "@types/node": "^22.10.1",
-    "@types/pluralize": "^0.0.33",
     "@typescript-eslint/eslint-plugin": "^7.16.0",
     "@typescript-eslint/parser": "^7.16.0",
     "autoprefixer": "^10.4.20",

package/src/components/form/MMobile.vue

@@ -11,13 +11,26 @@
   setup
 >
 import type { MInputProps as Props, MInputSlots } from '../../types'
-import { useTemplateRef } from 'vue'
+import { computed, toValue, useTemplateRef } from 'vue'
 import MInput from './MInput.vue'
 import { useMyth } from '../../composable'
 
 const { props: pluginOptions, mobileRule: mobile } = useMyth()
 const modelValue = defineModel<Props['modelValue']>({ required: !1, default: undefined })
 const input = useTemplateRef<InstanceType<typeof MInput>>('input')
+const mobileLength = computed(() => {
+  const final = toValue(mobile)
+  if (typeof final === 'function') {
+    return final(modelValue.value)
+  }
+  if (final === !0) {
+    return 10
+  }
+  if (!final) {
+    return undefined
+  }
+  return parseInt(final?.toString() || '0') || undefined
+})
 defineExpose<{ input: typeof input }>({ input })
 defineOptions({
   name: 'MMobile',
@@ -29,7 +42,15 @@ defineOptions({
   <MInput
     ref="input"
     v-model="modelValue"
-    v-bind="{ type: 'tel', mobile, maxlength:mobile === !0 ? 10 : (mobile ?? 10), ...pluginOptions.mobile as any, ...$attrs }"
+    v-bind="{
+      type: 'tel',
+      mobile: typeof mobile === 'function' ? mobile(modelValue) : (
+        mobile !== !1 && mobile !== undefined && mobile !== null
+      ),
+      maxlength: mobileLength,
+      ...pluginOptions.mobile as any,
+      ...$attrs
+    }"
   >
     <template
       v-for="(_,slot) in $slots as Readonly<MInputSlots>"

package/src/types/myth-api.ts

@@ -38,5 +38,5 @@ export interface MythApi {
    * Default is true.
    * The Length must be 10.
    */
-  mobileRule?: boolean | string | number;
+  mobileRule?: boolean | string | number | ((value: unknown) => number | undefined);
 }

package/src/utils/Str.ts

@@ -6,9 +6,10 @@
  * Github: https://github.com/mythpe
  */
 
-// import { plural as pluralCase, singular as singularCase } from 'pluralize'
+// import { plural as pluralCase, singular as singularCase } from '__pluralize'
+import __pluralize from './copy_pluralize'
 import { camelCase, capitalCase, dotCase, kebabCase, pascalCase, snakeCase } from 'change-case'
-
+// console.log(__pluralize.plural())
 export const Str = {
   /**
    * Str vue3
@@ -92,14 +93,14 @@ export const Str = {
     return string ? dotCase(string?.toString() || '') : ''
   },
   pluralize (string?: unknown): string {
-    console.log(string)
-    // return string ? pluralCase(string?.toString() || '') : ''
-    return ''
+    // console.log(string)
+    return string ? __pluralize.plural(string?.toString() || '') : ''
+    // return ''
   },
   singular (string?: unknown): string {
-    console.log(string)
-    // return string ? singularCase(string?.toString() || '') : ''
-    return ''
+    // console.log(string)
+    return string ? __pluralize.singular(string?.toString() || '') : ''
+    // return ''
   },
   flipChoice (data: Record<any, any>) {
     const f: Record<any, any> = {}

package/src/utils/copy_pluralize.js

@@ -0,0 +1,241 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+
+// __pluralize.js
+
+// Rule storage - __pluralize and singularize need to be run sequentially,
+// while other rules can be optimized using an object for instant lookups.
+const pluralRules = []
+const singularRules = []
+const uncountables = {}
+const irregularPlurals = {}
+const irregularSingles = {}
+
+/**
+ * Sanitize a pluralization rule to a usable regular expression.
+ * @param {(RegExp|string)} rule
+ * @return {RegExp}
+ */
+function sanitizeRule (rule) {
+  return typeof rule === 'string' ? new RegExp(`^${rule}$`, 'i') : rule
+}
+
+/**
+ * Pass in a word token to produce a function that can replicate the case on another word.
+ * @param {string} word
+ * @param {string} token
+ * @return {string}
+ */
+function restoreCase (word, token) {
+  if (word === token) return token
+  if (word === word.toLowerCase()) return token.toLowerCase()
+  if (word === word.toUpperCase()) return token.toUpperCase()
+  if (word[0] === word[0].toUpperCase()) {
+    return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase()
+  }
+  return token.toLowerCase()
+}
+
+/**
+ * Interpolate a regexp string.
+ * @param {string} str
+ * @param {Array} args
+ * @return {string}
+ */
+function interpolate (str, args) {
+  return str.replace(/\$(\d{1,2})/g, (match, index) => args[index] || '')
+}
+
+/**
+ * Replace a word using a rule.
+ * @param {string} word
+ * @param {Array} rule
+ * @return {string}
+ */
+function replace (word, rule) {
+  return word.replace(rule[0], (match, ...args) => {
+    const result = interpolate(rule[1], args)
+    return match === '' ? restoreCase(word[args[args.length - 2] - 1], result) : restoreCase(match, result)
+  })
+}
+
+/**
+ * Sanitize a word by passing in the word and sanitization rules.
+ * @param {string} token
+ * @param {string} word
+ * @param {Array} rules
+ * @return {string}
+ */
+function sanitizeWord (token, word, rules) {
+  if (!token.length || uncountables.hasOwnProperty(token)) return word
+
+  for (let i = rules.length - 1; i >= 0; i--) {
+    const rule = rules[i]
+    if (rule[0].test(word)) return replace(word, rule)
+  }
+
+  return word
+}
+
+/**
+ * Replace a word with the updated word.
+ * @param {Object} replaceMap
+ * @param {Object} keepMap
+ * @param {Array} rules
+ * @return {Function}
+ */
+function replaceWord (replaceMap, keepMap, rules) {
+  return function (word) {
+    const token = word.toLowerCase()
+
+    if (keepMap.hasOwnProperty(token)) return restoreCase(word, token)
+    if (replaceMap.hasOwnProperty(token)) return restoreCase(word, replaceMap[token])
+
+    return sanitizeWord(token, word, rules)
+  }
+}
+
+/**
+ * Check if a word is part of the map.
+ */
+function checkWord (replaceMap, keepMap, rules) {
+  return function (word) {
+    const token = word.toLowerCase()
+    if (keepMap.hasOwnProperty(token)) return true
+    if (replaceMap.hasOwnProperty(token)) return false
+    return sanitizeWord(token, token, rules) === token
+  }
+}
+
+/**
+ * Pluralize or singularize a word based on the passed in count.
+ * @param {string} word The word to __pluralize
+ * @param {number} count How many of the word exist
+ * @param {boolean} inclusive Whether to prefix with the number (e.g. 3 ducks)
+ * @return {string}
+ */
+function __pluralize (word, count, inclusive) {
+  const pluralized = count === 1 ? __pluralize.singular(word) : __pluralize.plural(word)
+  return (inclusive ? `${count} ` : '') + pluralized
+}
+
+// Attach methods to __pluralize function
+__pluralize.plural = replaceWord(irregularSingles, irregularPlurals, pluralRules)
+__pluralize.isPlural = checkWord(irregularSingles, irregularPlurals, pluralRules)
+__pluralize.singular = replaceWord(irregularPlurals, irregularSingles, singularRules)
+__pluralize.isSingular = checkWord(irregularPlurals, irregularSingles, singularRules)
+
+/**
+ * Add a pluralization rule to the collection.
+ * @param {(string|RegExp)} rule
+ * @param {string} replacement
+ */
+__pluralize.addPluralRule = function (rule, replacement) {
+  pluralRules.push([sanitizeRule(rule), replacement])
+}
+
+/**
+ * Add a singularization rule to the collection.
+ * @param {(string|RegExp)} rule
+ * @param {string} replacement
+ */
+__pluralize.addSingularRule = function (rule, replacement) {
+  singularRules.push([sanitizeRule(rule), replacement])
+}
+
+/**
+ * Add an uncountable word rule.
+ * @param {(string|RegExp)} word
+ */
+__pluralize.addUncountableRule = function (word) {
+  if (typeof word === 'string') {
+    uncountables[word.toLowerCase()] = true
+    return
+  }
+  __pluralize.addPluralRule(word, '$0')
+  __pluralize.addSingularRule(word, '$0')
+}
+
+/**
+ * Add an irregular word definition.
+ * @param {string} single
+ * @param {string} plural
+ */
+__pluralize.addIrregularRule = function (single, plural) {
+  const pluralLower = plural.toLowerCase()
+  const singleLower = single.toLowerCase()
+  irregularSingles[singleLower] = pluralLower
+  irregularPlurals[pluralLower] = singleLower
+};
+
+// Irregular rules
+[
+  ['I', 'we'], ['me', 'us'], ['he', 'they'], ['she', 'they'], ['them', 'them'],
+  ['myself', 'ourselves'], ['yourself', 'yourselves'], ['itself', 'themselves'],
+  ['herself', 'themselves'], ['himself', 'themselves'], ['themself', 'themselves'],
+  ['is', 'are'], ['was', 'were'], ['has', 'have'], ['this', 'these'], ['that', 'those'],
+  ['echo', 'echoes'], ['dingo', 'dingoes'], ['volcano', 'volcanoes'], ['tornado', 'tornadoes'],
+  ['torpedo', 'torpedoes'], ['genus', 'genera'], ['viscus', 'viscera'], ['stigma', 'stigmata'],
+  ['stoma', 'stomata'], ['dogma', 'dogmata'], ['lemma', 'lemmata'], ['schema', 'schemata'],
+  ['anathema', 'anathemata'], ['ox', 'oxen'], ['axe', 'axes'], ['die', 'dice'], ['yes', 'yeses'],
+  ['foot', 'feet'], ['eave', 'eaves'], ['goose', 'geese'], ['tooth', 'teeth'], ['quiz', 'quizzes'],
+  ['human', 'humans'], ['proof', 'proofs'], ['carve', 'carves'], ['valve', 'valves'],
+  ['looey', 'looies'], ['thief', 'thieves'], ['groove', 'grooves'], ['pickaxe', 'pickaxes'],
+  ['passerby', 'passersby']
+].forEach(([single, plural]) => __pluralize.addIrregularRule(single, plural));
+
+// Pluralization rules
+[
+  [/s?$/i, 's'], [/[^\u0000-\u007F]$/i, '$0'], [/([^aeiou]ese)$/i, '$1'],
+  [/(ax|test)is$/i, '$1es'], [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, '$1es'],
+  [/(e[mn]u)s?$/i, '$1s'], [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, '$1'],
+  [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, '$1i'],
+  [/(alumn|alg|vertebr)(?:a|ae)$/i, '$1ae'], [/(seraph|cherub)(?:im)?$/i, '$1im'],
+  [/(her|at|gr)o$/i, '$1oes'],
+  [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, '$1a'],
+  [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, '$1a'],
+  [/sis$/i, 'ses'], [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, '$1$2ves'],
+  [/([^aeiouy]|qu)y$/i, '$1ies'], [/([^ch][ieo][ln])ey$/i, '$1ies'],
+  [/(x|ch|ss|sh|zz)$/i, '$1es'], [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, '$1ices'],
+  [/\b((?:tit)?m|l)(?:ice|ouse)$/i, '$1ice'], [/(pe)(?:rson|ople)$/i, '$1ople'],
+  [/(child)(?:ren)?$/i, '$1ren'], [/eaux$/i, '$0'], [/m[ae]n$/i, 'men'], ['thou', 'you']
+].forEach(([rule, replacement]) => __pluralize.addPluralRule(rule, replacement));
+
+// Singularization rules
+[
+  [/s$/i, ''], [/(ss)$/i, '$1'], [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, '$1fe'],
+  [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, '$1f'], [/ies$/i, 'y'],
+  [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, '$1ie'],
+  [/\b(mon|smil)ies$/i, '$1ey'], [/\b((?:tit)?m|l)ice$/i, '$1ouse'],
+  [/(seraph|cherub)im$/i, '$1'], [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, '$1'],
+  [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, '$1sis'],
+  [/(movie|twelve|abuse|e[mn]u)s$/i, '$1'], [/(test)(?:is|es)$/i, '$1is'],
+  [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, '$1us'],
+  [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, '$1um'],
+  [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, '$1on'],
+  [/(alumn|alg|vertebr)ae$/i, '$1a'], [/(cod|mur|sil|vert|ind)ices$/i, '$1ex'],
+  [/(matr|append)ices$/i, '$1ix'], [/(pe)(rson|ople)$/i, '$1rson'], [/(child)ren$/i, '$1'],
+  [/(eau)x?$/i, '$1'], [/men$/i, 'man']
+].forEach(([rule, replacement]) => __pluralize.addSingularRule(rule, replacement));
+
+// Uncountable rules
+[
+  'adulthood', 'advice', 'agenda', 'aid', 'aircraft', 'alcohol', 'ammo', 'analytics',
+  'anime', 'athletics', 'audio', 'bison', 'blood', 'bream', 'buffalo', 'butter',
+  'carp', 'cash', 'chassis', 'chess', 'clothing', 'cod', 'commerce', 'cooperation',
+  'corps', 'debris', 'diabetes', 'digestion', 'elk', 'energy', 'equipment',
+  'excretion', 'expertise', 'firmware', 'flounder', 'fun', 'gallows', 'garbage',
+  'graffiti', 'hardware', 'headquarters', 'health', 'herpes', 'highjinks', 'homework',
+  'housework', 'information', 'jeans', 'justice', 'kudos', 'labour', 'literature',
+  'machinery', 'mackerel', 'mail', 'media', 'mews', 'moose', 'music', 'mud', 'manga',
+  'news', 'only', 'personnel', 'pike', 'plankton', 'pliers', 'police', 'pollution',
+  'premises', 'rain', 'research', 'rice', 'salmon', 'scissors', 'series', 'sewage',
+  'shambles', 'shrimp', 'software', 'species', 'staff', 'swine', 'tennis', 'traffic',
+  'transportation', 'trout', 'tuna', 'wealth', 'welfare', 'whiting', 'wildebeest',
+  'wildlife', 'you', /pok[eé]mon$/i, /[^aeiou]ese$/i, /deer$/i, /fish$/i,
+  /measles$/i, /o[iu]s$/i, /pox$/i, /sheep$/i
+].forEach(__pluralize.addUncountableRule)
+
+export default __pluralize