renusify 3.1.0 → 3.1.3

package/directive/animate/index.js

@@ -1,4 +1,4 @@
-import 'renusify/directive/animate/style.scss'
+import './style.scss'
 
 /**
  * @example // v-animate usage

package/index.d.ts

@@ -0,0 +1,73 @@
+// Auto-generated Vue component type declarations
+// Do not edit manually - run `npm run build` to update
+declare module 'vue' {
+  export interface GlobalComponents {
+    rApp: typeof import('./components/app/index.js')['rApp']
+    rAvatar: typeof import('./components/avatar/index.js')['rAvatar']
+    rBtn: typeof import('./components/button/index.js')['rBtn']
+    rBtnConfirm: typeof import('./components/button/buttonConfirm.js')['rBtnConfirm']
+    rBtnGroup: typeof import('./components/button/buttonGroup.js')['rBtnGroup']
+    rCalendar: typeof import('./components/calendar/index.js')['rCalendar']
+    rCard: typeof import('./components/card/index.js')['rCard']
+    rCodeEditor: typeof import('./components/codeEditor/index.js')['rCodeEditor']
+    rConfirm: typeof import('./components/confirm/index.js')['rConfirm']
+    rContainer: typeof import('./components/container/index.js')['rContainer']
+    rRow: typeof import('./components/container/row.js')['rRow']
+    rCol: typeof import('./components/container/col.js')['rCol']
+    rSpacer: typeof import('./components/container/spacer.js')['rSpacer']
+    rDivider: typeof import('./components/container/divider.js')['rDivider']
+    rContent: typeof import('./components/content/index.js')['rContent']
+    rCropper: typeof import('./components/cropper/index.js')['rCropper']
+    rFloat: typeof import('./components/float/index.js')['rFloat']
+    rForm: typeof import('./components/form/index.js')['rForm']
+    rInput: typeof import('./components/form/input/index.js')['rInput']
+    rColorInput: typeof import('./components/form/colorInput/index.js')['rColorInput']
+    rDateInput: typeof import('./components/form/dateInput/index.js')['rDateInput']
+    rFileInput: typeof import('./components/form/fileInput/index.js')['rFileInput']
+    rTelInput: typeof import('./components/form/telInput/index.js')['rTelInput']
+    rJsonInput: typeof import('./components/form/jsonInput/index.js')['rJsonInput']
+    rTextEditor: typeof import('./components/form/textEditor/index.js')['rTextEditor']
+    rTextEditorPreview: typeof import('./components/form/textEditor/preview.js')['rTextEditorPreview']
+    rTimeInput: typeof import('./components/form/timeInput/index.js')['rTimeInput']
+    rTimeRangeInput: typeof import('./components/form/timeInput/range.js')['rTimeRangeInput']
+    rUniqueInput: typeof import('./components/form/uniqueInput/index.js')['rUniqueInput']
+    rAddressInput: typeof import('./components/form/addressInput/index.js')['rAddressInput']
+    rCamInput: typeof import('./components/form/camInput/index.js')['rCamInput']
+    rCheckInput: typeof import('./components/form/checkInput/index.js')['rCheckInput']
+    rCheckboxInput: typeof import('./components/form/checkboxInput/index.js')['rCheckboxInput']
+    rGroupInput: typeof import('./components/form/groupInput/index.js')['rGroupInput']
+    rMaskInput: typeof import('./components/form/maskInput/index.js')['rMaskInput']
+    rNumberInput: typeof import('./components/form/numberInput/index.js')['rNumberInput']
+    rPasswordInput: typeof import('./components/form/passwordInput/index.js')['rPasswordInput']
+    rRadioInput: typeof import('./components/form/radioInput/index.js')['rRadioInput']
+    rRangeInput: typeof import('./components/form/rangeInput/index.js')['rRangeInput']
+    rRatingInput: typeof import('./components/form/ratingInput/index.js')['rRatingInput']
+    rSelectInput: typeof import('./components/form/selectInput/index.js')['rSelectInput']
+    rSwitchInput: typeof import('./components/form/switchInput/index.js')['rSwitchInput']
+    rTextArea: typeof import('./components/form/textArea/index.js')['rTextArea']
+    rTextInput: typeof import('./components/form/textInput/index.js')['rTextInput']
+    rUnitInput: typeof import('./components/form/unitInput/index.js')['rUnitInput']
+    rFormCreator: typeof import('./components/formCreator/index.js')['rFormCreator']
+    rIcon: typeof import('./components/icon/index.js')['rIcon']
+    rImg: typeof import('./components/img/index.js')['rImg']
+    rInfinite: typeof import('./components/infinite/index.js')['rInfinite']
+    rMap: typeof import('./components/map/index.js')['rMap']
+    rMapSelect: typeof import('./components/map/select.js')['rMapSelect']
+    rMapRoute: typeof import('./components/map/route.js')['rMapRoute']
+    rMenu: typeof import('./components/menu/index.js')['rMenu']
+    rMeta: typeof import('./components/meta/index.js')['rMeta']
+    rModal: typeof import('./components/modal/index.js')['rModal']
+    rNotify: typeof import('./components/notify/index.js')['rNotify']
+    rProgressCircle: typeof import('./components/progress/circle.js')['rProgressCircle']
+    rProgressLine: typeof import('./components/progress/line.js')['rProgressLine']
+    rSearchBox: typeof import('./components/searchBox/index.js')['rSearchBox']
+    rSlider: typeof import('./components/slider/index.js')['rSlider']
+    rSwiper: typeof import('./components/swiper/index.js')['rSwiper']
+    rTable: typeof import('./components/table/index.js')['rTable']
+    rTableCrud: typeof import('./components/table/crud/index.js')['rTableCrud']
+    rTimeAgo: typeof import('./components/timeAgo/index.js')['rTimeAgo']
+    rTour: typeof import('./components/tour/index.js')['rTour']
+    rTree: typeof import('./components/tree/index.js')['rTree']
+    rHighlight: typeof import('./components/highlight/index.js')['rHighlight']
+  }
+}

package/package.json

@@ -1,30 +1,38 @@
-{
-  "name": "renusify",
-  "version": "3.1.0",
-  "description": "Vue3 Framework",
-  "keywords": [
-    "vuejs",
-    "vue framework",
-    "ui framework",
-    "component framework",
-    "ui library",
-    "component library",
-    "material components",
-    "renusify"
-  ],
-  "homepage": "https://github.com/smkoBa/renusify",
-  "main": "index.js",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/smkoBa/renusify.git"
-  },
-  "author": {
-    "name": "Smko Bayazidi",
-    "email": "ba.smko@gmail.com"
-  },
-  "license": "BSD",
-  "private": false,
-  "scripts": {
-    "docs:generate": "node scripts/generate-docs.mjs"
-  }
-}
+{
+  "name": "renusify",
+  "version": "3.1.3",
+  "description": "Vue3 Framework",
+  "keywords": [
+    "vuejs",
+    "vue framework",
+    "ui framework",
+    "component framework",
+    "ui library",
+    "component library",
+    "material components",
+    "renusify"
+  ],
+  "homepage": "https://github.com/smkoBa/renusify",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/smkoBa/renusify.git"
+  },
+  "author": {
+    "name": "Smko Bayazidi",
+    "email": "ba.smko@gmail.com"
+  },
+  "license": "BSD",
+  "private": false,
+  "scripts": {
+    "docs:generate": "node scripts/generate-docs.mjs",
+    "build:types": "node scripts/generate-types.mjs",
+    "build": "npm run docs:generate && npm run build:types"
+  },
+  "peerDependencies": {
+    "sass": "^1.69.0",
+    "vue": "^3.3.0",
+    "vue-router": "^4.5.0"
+  }
+}

package/plugins/auto-loader.mjs

@@ -0,0 +1,314 @@
+import fs from 'fs'
+import path from 'path'
+
+export default function renusifyAutoPlugin(options = {}) {
+  const { prefix = 'r', debug = false } = options
+
+  const state = {
+    usedComponents: new Set(),
+    usedDirectives: new Set(),
+    componentsMap: new Map(),
+    directivesMap: new Map(),
+    rootDir: '',
+  }
+
+
+  function parseExports(filePath, exclude = []) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8')
+      const clean = content
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/\/\/.*$/gm, '')
+
+      const regex = /export\s+\*\s+as\s+([a-zA-Z_]\w*)\s+from\s+['"]([^'"]+)['"]/g
+      const map = new Map()
+      let m
+      while ((m = regex.exec(clean)) !== null) {
+        const [, name, relPath] = m
+        if (exclude.includes(name)) continue
+        let p = relPath.replace(/^\.\//, '')
+        if (!p.match(/\.(js|vue|ts|mjs)$/)) p = `${p}/index.js`
+        map.set(name, p)
+      }
+      return map
+    } catch (err) {
+      console.warn(`[renusify-auto] Could not parse ${filePath}:`, err.message)
+      return new Map()
+    }
+  }
+
+
+  function kebab2camel(s) {
+    return s.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase())
+  }
+
+
+  function scanFile(filePath) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8')
+      const tmplMatch = content.match(/<template(?:\s[^>]*)?>([\s\S]*?)<\/template>/)
+      if (!tmplMatch) return
+
+      const tmpl = tmplMatch[1]
+
+      const tagRe = /<\s*\/?([a-zA-Z][a-zA-Z0-9-]*)/g
+      let m
+      while ((m = tagRe.exec(tmpl)) !== null) {
+        const tag = m[1]
+        if (!tag.startsWith(prefix)) continue
+        const camel = kebab2camel(tag)
+        if (state.componentsMap.has(camel)) state.usedComponents.add(camel)
+        else if (state.componentsMap.has(tag)) state.usedComponents.add(tag)
+      }
+
+      const dirRe = /\bv-([a-zA-Z][a-zA-Z0-9-]*)/g
+      const builtins = new Set([
+        'model', 'if', 'else', 'else-if', 'for', 'show', 'bind', 'on',
+        'slot', 'text', 'html', 'cloak', 'once', 'memo', 'pre'
+      ])
+
+      while ((m = dirRe.exec(tmpl)) !== null) {
+        const d = m[1]
+        if (builtins.has(d)) continue
+        const camel = kebab2camel(d)
+        const candidates = [d, camel, `v${camel.charAt(0).toUpperCase()}${camel.slice(1)}`]
+        for (const c of candidates) {
+          if (state.directivesMap.has(c)) {
+            state.usedDirectives.add(c)
+            break
+          }
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+
+  function scanDirSync(dir) {
+    let entries
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true })
+    } catch {
+      return
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name)
+      if (entry.isDirectory()) {
+        if (['node_modules', 'dist', '.git', '.nuxt', '.output'].includes(entry.name)) continue
+        scanDirSync(full)
+      } else if (entry.name.endsWith('.vue')) {
+        scanFile(full)
+      }
+    }
+  }
+
+
+   function generateImportStatements() {
+     const comps = [...state.usedComponents].sort()
+     const dirs = [...state.usedDirectives].sort()
+ 
+     if (comps.length === 0 && dirs.length === 0) return ''
+ 
+     let code = '\n'
+     if (comps.length > 0) {
+       code += `import {\n  ${comps.join(',\n  ')}\n} from 'renusify/components/index.js'\n`
+     }
+     if (dirs.length > 0) {
+       const dirNames = dirs.map(name => {
+         if (name.startsWith('v') || name.startsWith('V')) {
+           return name.charAt(1).toLowerCase() + name.slice(2)
+         }
+         return name
+       })
+       code += `import { ${dirNames.join(', ')} } from 'renusify/directive/index.js'\n`
+     }
+ 
+     return code
+   }
+
+
+  function generateComponentsObject() {
+    const comps = [...state.usedComponents].sort()
+    if (comps.length === 0) return null
+    return `components: {\n      ${comps.join(',\n      ')}\n    }`
+  }
+
+
+  function generateDirectivesObject() {
+    const dirs = [...state.usedDirectives].sort()
+    if (dirs.length === 0) return null
+    const dirNames = dirs.map(name => {
+      if (name.startsWith('v') || name.startsWith('V')) {
+        return name.charAt(1).toLowerCase() + name.slice(2)
+      }
+      return name
+    })
+    return `directives: { ${dirNames.join(', ')} }`
+  }
+
+  return {
+    name: 'vite-plugin-renusify-auto',
+    enforce: 'pre',
+
+    configResolved(config) {
+      state.rootDir = config.root
+      const renusifyPath = path.join(config.root, 'node_modules/renusify')
+
+      state.componentsMap = parseExports(
+        path.join(renusifyPath, 'components/index.js'),
+        ['_register']
+      )
+      state.directivesMap = parseExports(
+        path.join(renusifyPath, 'directive/index.js'),
+        ['_registers']
+      )
+
+      if (config.command === 'serve') {
+        state.usedComponents = new Set(state.componentsMap.keys())
+        state.usedDirectives = new Set(state.directivesMap.keys())
+        if (debug) {
+          console.log(`[renusify-auto] Dev mode: ALL ${state.componentsMap.size} components, ${state.directivesMap.size} directives`)
+        }
+      } else {
+        scanDirSync(path.join(config.root, 'src'))
+        if (debug) {
+          console.log(`[renusify-auto] Build mode: ${state.usedComponents.size} components, ${state.usedDirectives.size} directives`)
+          console.log('   Components:', [...state.usedComponents].join(', '))
+          console.log('   Directives:', [...state.usedDirectives].join(', '))
+        }
+      }
+    },
+
+    transform(code, id) {
+      if (!/main\.(js|ts)$/.test(id)) return null
+      if (id.includes('node_modules')) return null
+
+      let newCode = code
+      let modified = false
+
+      const importStmts = generateImportStatements()
+      if (importStmts) {
+        const importRegex = /^import\s+[^;]+;?\s*$/gm
+        const allImports = code.match(importRegex)
+        
+        if (allImports && allImports.length > 0) {
+          const lastImport = allImports[allImports.length - 1]
+          const lastImportIndex = code.lastIndexOf(lastImport)
+          const insertPos = lastImportIndex + lastImport.length
+          newCode = newCode.slice(0, insertPos) + importStmts + newCode.slice(insertPos)
+        } else {
+          newCode = importStmts + '\n' + newCode
+        }
+        modified = true
+      }
+
+      const renusifyRegex = /\.use\s*\(\s*renusify\s*,\s*\{/
+      const useMatch = newCode.match(renusifyRegex)
+
+      if (useMatch) {
+        const matchIndex = useMatch.index
+        const startOfOptions = matchIndex + useMatch[0].length
+
+        let braceCount = 1
+        let i = startOfOptions
+        while (i < newCode.length && braceCount > 0) {
+          if (newCode[i] === '{') braceCount++
+          else if (newCode[i] === '}') braceCount--
+          if (braceCount > 0) i++
+        }
+
+        if (braceCount === 0) {
+          const endOfOptions = i
+          const optionsContent = newCode.slice(startOfOptions, endOfOptions)
+          let cleanedOptions = optionsContent
+
+          cleanedOptions = removeProperty(cleanedOptions, 'components')
+          cleanedOptions = removeProperty(cleanedOptions, 'directives')
+
+          cleanedOptions = cleanedOptions.replace(/,(\s*)}/g, '$1}')
+          cleanedOptions = cleanedOptions.trim()
+
+          const componentsObj = generateComponentsObject()
+          const directivesObj = generateDirectivesObject()
+
+          let newOptionsContent = cleanedOptions
+
+          if (componentsObj || directivesObj) {
+            const needsComma = newOptionsContent.trim().length > 0 && !newOptionsContent.trim().endsWith(',')
+            const comma = needsComma ? ',' : ''
+            
+            let additions = ''
+            if (componentsObj) additions += '\n    ' + componentsObj
+            if (directivesObj) additions += (additions ? ',' : '') + '\n    ' + directivesObj
+
+            if (newOptionsContent.trim().length === 0) {
+              newOptionsContent = additions + '\n  '
+            } else {
+              newOptionsContent = newOptionsContent + comma + additions + '\n  '
+            }
+          }
+
+          newCode = newCode.slice(0, startOfOptions) + newOptionsContent + newCode.slice(endOfOptions)
+          modified = true
+        }
+      }
+
+      if (modified) {
+        if (debug) {
+          console.log(`[renusify-auto] Transformed ${path.basename(id)}`)
+        }
+        return { code: newCode, map: null }
+      }
+
+      return null
+    },
+  }
+}
+
+function removeProperty(optionsStr, propName) {
+  const propRegex = new RegExp(`,?\\s*${propName}\\s*:\\s*`)
+  const match = propRegex.exec(optionsStr)
+  
+  if (!match) return optionsStr
+
+  const startIndex = match.index
+  const valueStart = startIndex + match[0].length
+
+  
+  let endIndex = valueStart
+  const firstChar = optionsStr[valueStart]
+
+  if (firstChar === '{') {
+    
+    let braceCount = 1
+    let i = valueStart + 1
+    while (i < optionsStr.length && braceCount > 0) {
+      if (optionsStr[i] === '{') braceCount++
+      else if (optionsStr[i] === '}') braceCount--
+      i++
+    }
+    endIndex = i
+  } else if (firstChar === '[') {
+    let bracketCount = 1
+    let i = valueStart + 1
+    while (i < optionsStr.length && bracketCount > 0) {
+      if (optionsStr[i] === '[') bracketCount++
+      else if (optionsStr[i] === ']') bracketCount--
+      i++
+    }
+    endIndex = i
+  } else {
+    let i = valueStart
+    while (i < optionsStr.length && optionsStr[i] !== ',' && optionsStr[i] !== '}') {
+      i++
+    }
+    endIndex = i
+  }
+
+  if (endIndex < optionsStr.length && optionsStr[endIndex] === ',') {
+    endIndex++
+  }
+
+  return optionsStr.slice(0, startIndex) + optionsStr.slice(endIndex)
+}

package/plugins/storage/index.js

@@ -1,35 +1,164 @@
 class Storage {
-    stringfy(value){
-        return JSON.stringify(value)
+  constructor(encryptionKey) {
+    this._key = encryptionKey || this._loadKeyFromEnv();
+    this._available = this._checkAvailability();
+    if (!this._key) {
+      console.warn('[Storage] ⚠️ No encryption key provided. Safe methods will throw.');
     }
-    parse(value){
-        return JSON.parse(value)
-    }
-    set(key, value) {
-        localStorage.setItem(key,this.stringfy(value))
+  }
+
+  _loadKeyFromEnv() {
+    if (typeof import.meta !== 'undefined' && import.meta.env?.VITE_STORAGE_KEY)
+      return import.meta.env.VITE_STORAGE_KEY;
+    if (typeof process !== 'undefined' && process.env?.STORAGE_KEY)
+      return process.env.STORAGE_KEY;
+    return null;
+  }
+
+  _checkAvailability() {
+    try {
+      const test = '__storage_test__';
+      localStorage.setItem(test, '1');
+      localStorage.removeItem(test);
+      return true;
+    } catch {
+      return false;
     }
+  }
+
+  _arrayBufferToBase64(buffer) {
+    const bytes = new Uint8Array(buffer);
+    let binary = '';
+    for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+    return btoa(binary);
+  }
+
+  _base64ToArrayBuffer(base64) {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+    return bytes.buffer;
+  }
+
+  async _deriveKey(password, salt) {
+    const enc = new TextEncoder();
+    const keyMaterial = await crypto.subtle.importKey(
+        'raw', enc.encode(password), 'PBKDF2', false, ['deriveKey']
+    );
+    return crypto.subtle.deriveKey(
+        {name: 'PBKDF2', salt, iterations: 100000, hash: 'SHA-256'},
+        keyMaterial,
+        {name: 'AES-GCM', length: 256},
+        false,
+        ['encrypt', 'decrypt']
+    );
+  }
+
+  async _encrypt(plaintext) {
+    const salt = crypto.getRandomValues(new Uint8Array(16));
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const key = await this._deriveKey(this._key, salt);
+    const cipher = await crypto.subtle.encrypt(
+        {name: 'AES-GCM', iv}, key, new TextEncoder().encode(plaintext)
+    );
+    return JSON.stringify({
+      salt: this._arrayBufferToBase64(salt),
+      iv: this._arrayBufferToBase64(iv),
+      data: this._arrayBufferToBase64(cipher)
+    });
+  }
 
-    has(key) {
-        return this.get(key)!==null
+  async _decrypt(payloadString) {
+    const {salt, iv, data} = JSON.parse(payloadString);
+    const key = await this._deriveKey(this._key, this._base64ToArrayBuffer(salt));
+    const decrypted = await crypto.subtle.decrypt(
+        {name: 'AES-GCM', iv: this._base64ToArrayBuffer(iv)},
+        key,
+        this._base64ToArrayBuffer(data)
+    );
+    return new TextDecoder().decode(decrypted);
+  }
+
+  stringify(value) {
+    return JSON.stringify(value);
+  }
+
+  parse(value) {
+    return JSON.parse(value);
+  }
+
+  set(key, value) {
+    if (!this._available) return false;
+    try {
+      localStorage.setItem(String(key), this.stringify(value));
+      return true;
+    } catch (err) {
+      console.error(`[Storage] set failed:`, err);
+      return false;
     }
+  }
+
+  has(key) {
+    if (!this._available) return false;
+    return localStorage.getItem(String(key)) !== null;
+  }
 
-    get(key,def=null) {
-        let i=localStorage.getItem(key)
-        if(i===null){
-            return def
-        }
-        return this.parse(i)
+  get(key, def = null) {
+    if (!this._available) return def;
+    const raw = localStorage.getItem(String(key));
+    if (raw === null) return def;
+    try {
+      return this.parse(raw);
+    } catch {
+      return def;
     }
+  }
 
-    remove(key) {
-        return localStorage.removeItem(key)
+  remove(key) {
+    if (!this._available) return false;
+    localStorage.removeItem(String(key));
+    return true;
+  }
+
+  pull(key, def = null) {
+    const data = this.get(key, def);
+    this.remove(key);
+    return data;
+  }
+
+  async setSafe(key, value) {
+    if (!this._key) throw new Error('[Storage] Encryption key not configured.');
+    if (!this._available) return false;
+    try {
+      const plaintext = this.stringify(value);
+      const encrypted = await this._encrypt(plaintext);
+      localStorage.setItem(String(key), encrypted);
+      return true;
+    } catch (err) {
+      console.error(`[Storage] setSafe failed:`, err);
+      return false;
     }
+  }
 
-    pull(key){
-        const d=this.get(key)
-        this.remove(key)
-        return d
+  async getSafe(key, def = null) {
+    if (!this._key) throw new Error('[Storage] Encryption key not configured.');
+    if (!this._available) return def;
+    const raw = localStorage.getItem(String(key));
+    if (raw === null) return def;
+    try {
+      const decrypted = await this._decrypt(raw);
+      return this.parse(decrypted);
+    } catch (err) {
+      console.warn(`[Storage] getSafe failed (tampered/invalid):`, err);
+      return def;
     }
+  }
+
+  async pullSafe(key, def = null) {
+    const data = await this.getSafe(key, def);
+    this.remove(key);
+    return data;
+  }
 }
 
-export default new Storage();
+export default new Storage();

package/scripts/generate-types.mjs

@@ -0,0 +1,83 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const CONFIG = {
+  inputFile: path.resolve(__dirname, '../components/index.js'),
+  outputFile: path.resolve(__dirname, '../index.d.ts'),
+  importPathPrefix: './components',
+};
+
+
+function parseExports(content) {
+  return content
+    .split('\n')
+    .map(line => line.trim())
+    .filter(line => line && !line.startsWith('//'))
+    .map(line => {
+      const match = line.match(/^export\s+\*\s+as\s+(\w+)\s+from\s+['"](.+)['"]\s*;?$/);
+      return match ? { componentName: match[1], relativePath: match[2] } : null;
+    })
+    .filter(item => item !== null);
+}
+
+
+function transformImportPath(relativePath, prefix) {
+  if (relativePath.startsWith('./')) {
+    return `${prefix}${relativePath.slice(1)}`;
+  }
+  return relativePath;
+}
+
+
+function generateDeclaration(components, prefix) {
+  const lines = [
+    '// Auto-generated Vue component type declarations',
+    '// Do not edit manually - run `npm run build` to update',
+    `declare module 'vue' {`,
+    `  export interface GlobalComponents {`,
+  ];
+
+  for (const { componentName, relativePath } of components) {
+    const importPath = transformImportPath(relativePath, prefix);
+    lines.push(`    ${componentName}: typeof import('${importPath}')['${componentName}']`);
+  }
+
+  lines.push(`  }`, `}`, '');
+  return lines.join('\n');
+}
+
+
+function main() {
+  try {
+    console.log(`Reading exports from: ${CONFIG.inputFile}`);
+
+    if (!fs.existsSync(CONFIG.inputFile)) {
+      throw new Error(`Input file not found: ${CONFIG.inputFile}`);
+    }
+
+    const content = fs.readFileSync(CONFIG.inputFile, 'utf-8');
+    const components = parseExports(content);
+
+    if (components.length === 0) {
+      console.warn('No component exports found. Check your input file format.');
+    } else {
+      console.log(`Found ${components.length} component exports`);
+    }
+
+    const declaration = generateDeclaration(components, CONFIG.importPathPrefix);
+
+    fs.writeFileSync(CONFIG.outputFile, declaration, 'utf-8');
+    console.log(`Generated: ${CONFIG.outputFile}`);
+    console.log(`Total components: ${components.length}`);
+
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/plugins/crypt/crypt.js

@@ -1,281 +0,0 @@
-import SimpleRng from "./random";
-
-export default class Cryptor {
-    constructor() {
-        this.matrix = 32;
-    }
-
-    packUint32BE(value) {
-        const bytes = new Uint8Array(4);
-        bytes[0] = (value >> 24) & 0xFF;
-        bytes[1] = (value >> 16) & 0xFF;
-        bytes[2] = (value >> 8) & 0xFF;
-        bytes[3] = value & 0xFF;
-        return bytes;
-    }
-
-    unpackUint32BE(bytes, offset = 0) {
-        return ((bytes[offset] << 24) |
-            (bytes[offset + 1] << 16) |
-            (bytes[offset + 2] << 8) |
-            bytes[offset + 3]) >>> 0;
-    }
-
-    encrypt(data, key) {
-        const matrixSize = this.matrix;
-        const pad = (matrixSize - ((10 + data.length) % matrixSize)) % matrixSize;
-        const keyBytes = this.generatePassword(matrixSize, this.stringToBytes(key));
-
-        const dataSize = this.packUint32BE(data.length);
-
-        const randomPrefix = this.getRandomBytes(6);
-        const seedRandom = randomPrefix.reduce((sum, b) => sum + b, 0);
-
-        const paddedText = new Uint8Array(10 + data.length + pad);
-        paddedText.set(dataSize, 0);
-        paddedText.set(randomPrefix, 4);
-        paddedText.set(data, 10);
-
-        if (pad > 0) {
-            paddedText.fill(1, 10 + data.length, 10 + data.length + pad);
-        }
-
-        const seedSum = keyBytes.reduce((sum, b) => sum + b, 0);
-        this.shuffle(paddedText, seedSum + seedRandom, 5);
-
-        for (let i = 0; i < paddedText.length; i += matrixSize) {
-            const end = Math.min(i + matrixSize, paddedText.length);
-            const seed = (i + matrixSize < paddedText.length) ? paddedText[i + matrixSize] : keyBytes[0];
-            const chunkCopy = new Uint8Array(paddedText.slice(i, end));
-            this.shuffle(chunkCopy, seed + seedRandom, 2);
-            paddedText.set(chunkCopy, i);
-        }
-
-        this.mix(matrixSize, paddedText, keyBytes);
-
-        const result = new Uint8Array(paddedText.length + 2);
-        result.set(paddedText, 0);
-        result[paddedText.length] = (seedRandom >> 8) & 0xFF;
-        result[paddedText.length + 1] = seedRandom & 0xFF;
-
-        return result;
-    }
-
-    encryptText(text, key) {
-        const data = this.stringToBytes(text);
-        const encrypted = this.encrypt(data, key);
-        return this.base64UrlEncode(encrypted);
-    }
-
-    decrypt(encoded, key) {
-        if (encoded.length < 8) {
-            throw new Error('Invalid Token Matrix Length.');
-        }
-
-        const seedRandom = (encoded[encoded.length - 2] << 8) | encoded[encoded.length - 1];
-        const decoded = new Uint8Array(encoded.slice(0, -2));
-        const matrixSize = this.matrix;
-
-        const keyBytes = this.generatePassword(matrixSize, this.stringToBytes(key));
-        this.unmix(matrixSize, decoded, keyBytes);
-
-        for (let i = Math.floor(decoded.length / matrixSize) * matrixSize; i >= 0; i -= matrixSize) {
-            const end = Math.min(i + matrixSize, decoded.length);
-            const seed = (i + matrixSize < decoded.length) ? decoded[i + matrixSize] : keyBytes[0];
-            const chunkCopy = new Uint8Array(decoded.slice(i, end));
-            this.unshuffle(chunkCopy, seed + seedRandom, 2);
-            decoded.set(chunkCopy, i);
-        }
-
-        const seedSum = keyBytes.reduce((sum, b) => sum + b, 0);
-        this.unshuffle(decoded, seedSum + seedRandom, 5);
-
-        const dataSize = this.unpackUint32BE(decoded, 0);
-
-        if (decoded.length < dataSize + 10) {
-            throw new Error('Invalid Token Matrix Length');
-        }
-
-        return decoded.slice(10, 10 + dataSize);
-    }
-
-    decryptText(encoded, key) {
-        const padding = encoded.length % 4;
-        const paddedInput = padding === 0 ? encoded : encoded + '='.repeat(4 - padding);
-
-        const data = this.base64UrlDecode(paddedInput);
-        const decrypted = this.decrypt(data, key);
-        return this.bytesToString(decrypted);
-    }
-
-    setMatrix(size) {
-        if (size > 0) {
-            this.matrix = size;
-        }
-    }
-
-    generatePassword(matrix, password) {
-        const result = new Uint8Array(matrix);
-        const passwordLen = password.length;
-
-        if (passwordLen === 0) {
-            return result;
-        }
-
-        const repeats = Math.floor(matrix / passwordLen);
-        const remainder = matrix % passwordLen;
-
-        for (let i = 0; i < repeats; i++) {
-            const start = i * passwordLen;
-            result.set(password, start);
-        }
-
-        if (remainder > 0) {
-            const start = repeats * passwordLen;
-            result.set(password.slice(0, remainder), start);
-        }
-
-        return result;
-    }
-
-    shuffle(data, seed, step) {
-        const rng = new SimpleRng(seed);
-        const length = data.length;
-
-        for (let i = length - 1; i > 0; i -= step) {
-            const j = Math.floor(rng.genRange(0, i));
-            [data[i], data[j]] = [data[j], data[i]];
-        }
-    }
-
-    unshuffle(data, seed, step) {
-        const rng = new SimpleRng(seed);
-        const length = data.length;
-        const swaps = [];
-
-        for (let i = length - 1; i > 0; i -= step) {
-            const j = Math.floor(rng.genRange(0, i));
-            swaps.push([i, j]);
-        }
-
-        for (let k = swaps.length - 1; k >= 0; k--) {
-            const [i, j] = swaps[k];
-            [data[i], data[j]] = [data[j], data[i]];
-        }
-    }
-
-    mix(blockSize, buf, key) {
-        let prevBlock = new Uint8Array(key);
-
-        for (let i = 0; i < buf.length; i += blockSize) {
-            const blockEnd = Math.min(i + blockSize, buf.length);
-            for (let j = 0; j < blockEnd - i && j < prevBlock.length; j++) {
-                buf[i + j] ^= prevBlock[j];
-            }
-            prevBlock = new Uint8Array(buf.slice(i, blockEnd));
-        }
-    }
-
-    unmix(blockSize, buf, key) {
-        const blocks = [];
-        for (let i = 0; i < buf.length; i += blockSize) {
-            const end = Math.min(i + blockSize, buf.length);
-            blocks.push(new Uint8Array(buf.slice(i, end)));
-        }
-
-        for (let i = blocks.length - 1; i >= 0; i--) {
-            if (i === 0) {
-                for (let j = 0; j < blocks[i].length && j < key.length; j++) {
-                    blocks[i][j] ^= key[j];
-                }
-            } else {
-                for (let j = 0; j < blocks[i].length && j < blocks[i - 1].length; j++) {
-                    blocks[i][j] ^= blocks[i - 1][j];
-                }
-            }
-        }
-
-        let offset = 0;
-        for (const block of blocks) {
-            buf.set(block, offset);
-            offset += block.length;
-        }
-    }
-
-    getRandomBytes(length) {
-        const rng = new SimpleRng(Date.now());
-        return rng.getRandomBytes(length);
-    }
-
-    base64UrlEncode(data) {
-        if (typeof Buffer !== 'undefined') {
-            // Node.js
-            return Buffer.from(data)
-                .toString('base64')
-                .replace(/\+/g, '-')
-                .replace(/\//g, '_')
-                .replace(/=+$/, '');
-        } else {
-            // Browser
-            let binary = '';
-            for (let i = 0; i < data.length; i++) {
-                binary += String.fromCharCode(data[i]);
-            }
-            return btoa(binary)
-                .replace(/\+/g, '-')
-                .replace(/\//g, '_')
-                .replace(/=+$/, '');
-        }
-    }
-
-    base64UrlDecode(encoded) {
-        let padded = encoded;
-        const padding = encoded.length % 4;
-        if (padding !== 0) {
-            padded += '='.repeat(4 - padding);
-        }
-        const base64 = padded.replace(/-/g, '+').replace(/_/g, '/');
-
-        if (typeof Buffer !== 'undefined') {
-            // Node.js
-            return new Uint8Array(Buffer.from(base64, 'base64'));
-        } else {
-            // Browser
-            const binary = atob(base64);
-            const bytes = new Uint8Array(binary.length);
-            for (let i = 0; i < binary.length; i++) {
-                bytes[i] = binary.charCodeAt(i);
-            }
-            return bytes;
-        }
-    }
-
-    stringToBytes(str) {
-        if (typeof TextEncoder !== 'undefined') {
-            return new TextEncoder().encode(str);
-        }
-        if (typeof Buffer !== 'undefined') {
-            return new Uint8Array(Buffer.from(str, 'utf-8'));
-        }
-        const bytes = new Uint8Array(str.length);
-        for (let i = 0; i < str.length; i++) {
-            bytes[i] = str.charCodeAt(i) & 0xFF;
-        }
-        return bytes;
-    }
-
-    bytesToString(bytes) {
-        if (typeof TextDecoder !== 'undefined') {
-            return new TextDecoder('utf-8').decode(bytes);
-        }
-        if (typeof Buffer !== 'undefined') {
-            return Buffer.from(bytes).toString('utf-8');
-        }
-
-        let str = '';
-        for (let i = 0; i < bytes.length; i++) {
-            str += String.fromCharCode(bytes[i]);
-        }
-        return str;
-    }
-}

package/plugins/crypt/random.js

@@ -1,52 +0,0 @@
-export default class SimpleRng {
-    constructor(seed) {
-        this.state = BigInt(seed) & 0xFFFFFFFFFFFFFFFFn;
-    }
-
-    static newWithTimeSeed() {
-        return new SimpleRng(Date.now());
-    }
-
-    nextU32() {
-        this.state = (this.state * 6364136223846793005n + 1442695040888963407n) & 0xFFFFFFFFFFFFFFFFn;
-        return Number((this.state >> 32n) & 0xFFFFFFFFn);
-    }
-
-    nextU64() {
-        const high = this.nextU32();
-        const low = this.nextU32();
-        return (high << 32) | low;
-    }
-
-    nextF64() {
-        const val = this.nextU32();
-        return val / 4294967295.0;
-    }
-
-    genRange(low, high) {
-        return low + (high - low) * this.nextF64();
-    }
-
-    getRandomBytes(length) {
-        const byteArray = new Uint8Array(length);
-        const chunks = Math.floor(length / 4);
-        const remainder = length % 4;
-
-        for (let i = 0; i < chunks; i++) {
-            const random = this.nextU32();
-            byteArray[i * 4] = random & 0xFF;
-            byteArray[i * 4 + 1] = (random >> 8) & 0xFF;
-            byteArray[i * 4 + 2] = (random >> 16) & 0xFF;
-            byteArray[i * 4 + 3] = (random >> 24) & 0xFF;
-        }
-
-        if (remainder > 0) {
-            const random = this.nextU32();
-            for (let i = 0; i < remainder; i++) {
-                byteArray[chunks * 4 + i] = (random >> (i * 8)) & 0xFF;
-            }
-        }
-
-        return byteArray;
-    }
-}