renusify 3.0.2 → 3.1.3

package/components/infinite/index.vue

@@ -4,7 +4,7 @@
          v-scroll="{handler:onScroll,target:target}"
          :style="{'max-height': height,'height': height}"
          :class="{'overflow-div':height}" class="infinite-page-container">
-      <transition-group :class="{'flex-column-reverse':isChat}"
+      <transition-group v-if="!noItem" :class="{'flex-column-reverse':isChat}"
                         :name="isChat?'slide-up':'slide-down'"
                         class="row"
                         tag="div">
@@ -16,23 +16,17 @@
         </r-col>
       </transition-group>
     </div>
-    <div v-if="noItem"
-         class="text-center title-2"
-    >{{ noItemMsg }}
-    </div>
+    <!-- noItem slot for empty contents. Provide noItem, noItemMsg props -->
+    <slot :noItem="noItem" :noItemMsg="noItemMsg" name="noItem">
+      <div v-if="noItem"
+           class="text-center title-2"
+      >{{ noItemMsg }}
+      </div>
+    </slot>
   </r-container>
 </template>
 <script setup>
-import {
-  ref,
-  computed,
-  onMounted,
-  onUnmounted,
-  onActivated,
-  onDeactivated,
-  watch,
-  inject, nextTick
-} from 'vue'
+import {computed, inject, nextTick, onActivated, onDeactivated, onMounted, onUnmounted, ref, watch} from 'vue'
 
 const props = defineProps({
   /**

package/components/table/crud/index.vue

@@ -259,7 +259,7 @@
 </template>
 
 <script setup>
-import {ref, computed, watch, onMounted, inject} from 'vue'
+import {computed, inject, onMounted, ref, watch} from 'vue'
 import ManageFooter from "./footer.vue";
 import ManageHeader from "./header.vue";
 
@@ -543,8 +543,6 @@ const sortSetup = (item) => {
 const ok = () => {
   table.value.startTime = false
   page.value = 1
-  sortBy.value = null
-  sortType.value = 0
   autoSend.value = false
   showForm.value = false
   refresh()

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.0.2",
-  "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();