@mpxjs/webpack-plugin 2.9.69 → 2.9.70-alpha.1

package/lib/tenon/processScript.js

@@ -0,0 +1,198 @@
+const genComponentTag = require('../utils/gen-component-tag')
+const loaderUtils = require('loader-utils')
+const normalize = require('../utils/normalize')
+const shallowStringify = require('../utils/shallow-stringify')
+const optionProcessorPath = normalize.lib('runtime/optionProcessor')
+const async = require('async')
+const createJSONHelper = require('../json-compiler/helper')
+const addQuery = require('../utils/add-query')
+
+const {
+  buildComponentsMap,
+  getRequireScript,
+  buildGlobalParams,
+  stringifyRequest
+} = require('./script-helper')
+
+module.exports = function (script, {
+  loaderContext,
+  ctorType,
+  srcMode,
+  moduleId,
+  isProduction,
+  componentGenerics,
+  jsonConfig,
+  outputPath,
+  builtInComponentsMap,
+  genericsInfo,
+  wxsModuleMap,
+  localComponentsMap,
+  localPagesMap
+}, callback) {
+  const { projectRoot, appInfo, webConfig } = loaderContext.getMpx()
+
+  // add entry
+  // const checkEntryDeps = (callback) => {
+  //   callback = callback || cacheCallback
+  //   if (callback && entryDeps.size === 0) {
+  //     callback()
+  //   } else {
+  //     cacheCallback = callback
+  //   }
+  // }
+
+  // const addEntryDep = (context, resource, name) => {
+  //   // 如果loader已经回调，就不再添加entry
+  //   if (callbacked) return
+  //   const dep = SingleEntryPlugin.createDependency(resource, name)
+  //   entryDeps.add(dep)
+  //   const virtualModule = new AddEntryDependency({
+  //     context: context._compiler.context,
+  //     dep,
+  //     name
+  //   })
+  //   /* eslint-disable camelcase */
+  //   context._module.__has_tenon_entry = true
+  //   context._module.addDependency(virtualModule)
+  //   entryDeps.delete(dep)
+  //   checkEntryDeps()
+  // }
+
+  const emitWarning = (msg) => {
+    loaderContext.emitWarning(
+      new Error('[tenon script processor][' + loaderContext.resource + ']: ' + msg)
+    )
+  }
+
+  const emitError = (msg) => {
+    loaderContext.emitError(
+      new Error('[tenon script processor][' + loaderContext.resource + ']: ' + msg)
+    )
+  }
+
+  const {
+    processPage,
+    processDynamicEntry
+  } = createJSONHelper({
+    loaderContext,
+    emitWarning,
+    emitError
+  })
+
+  // const { getRequire } = createHelpers(loaderContext)
+
+  // const stringifyRequest = r => loaderUtils.stringifyRequest(loaderContext, r)
+  // let tabBarPagesMap = {}
+  // if (tabBar && tabBarMap) {
+  //   // 挂载tabBar组件
+  //   const tabBarRequest = stringifyRequest(addQuery(tabBar.custom ? './custom-tab-bar/index' : tabBarPath, { component: true }))
+  //   tabBarPagesMap['mpx-tab-bar'] = `getComponent(require(${tabBarRequest}))`
+  //   // 挂载tabBar页面
+  //   Object.keys(tabBarMap).forEach((pagePath) => {
+  //     const pageCfg = localPagesMap[pagePath]
+  //     if (pageCfg) {
+  //       const pageRequest = stringifyRequest(pageCfg.resource)
+  //       if (pageCfg.async) {
+  //         tabBarPagesMap[pagePath] = `()=>import(${pageRequest}).then(res => getComponent(res, { __mpxPageRoute: ${JSON.stringify(pagePath)} }))`
+  //       } else {
+  //         tabBarPagesMap[pagePath] = `getComponent(require(${pageRequest}), { __mpxPageRoute: ${JSON.stringify(pagePath)} })`
+  //       }
+  //     } else {
+  //       emitWarning(`TabBar page path ${pagePath} is not exist in local page map, please check!`)
+  //     }
+  //   })
+  // }
+
+  let output = '/* script */\n'
+
+  let scriptSrcMode = srcMode
+  if (script) {
+    scriptSrcMode = script.mode || scriptSrcMode
+  } else {
+    script = {
+      tag: 'script',
+      content: ''
+    }
+    switch (ctorType) {
+      case 'app':
+        script.content = 'import {createApp} from "@mpxjs/core"\n' +
+          'createApp({})\n'
+        break
+      case 'page':
+        script.content = 'import {createPage} from "@mpxjs/core"\n' +
+          'createPage({})\n'
+        break
+      case 'component':
+        script.content = 'import {createComponent} from "@mpxjs/core"\n' +
+          'createComponent({})\n'
+    }
+  }
+  output += genComponentTag(script, {
+    attrs (script) {
+      const attrs = Object.assign({}, script.attrs)
+      // src改为内联require，删除
+      delete attrs.src
+      // script setup通过mpx处理，删除该属性避免vue报错
+      delete attrs.setup
+      return attrs
+    },
+    content (script) {
+      let content = `\n  import { processComponentOption, getComponent, getWxsMixin } from ${stringifyRequest(loaderContext, optionProcessorPath)}\n`
+      let hasApp = true
+      if (!appInfo.name) {
+        hasApp = false
+      }
+
+      // 获取组件集合
+      const componentsMap = buildComponentsMap({ localComponentsMap, builtInComponentsMap, loaderContext, jsonConfig })
+      // 获取pageConfig
+      const pageConfig = {}
+      if (ctorType === 'page') {
+        Object.assign(pageConfig, jsonConfig)
+        delete pageConfig.usingComponents
+        // content += `import * as Tenon from '@hummer/tenon-vue'\n`
+        // content += `var page = require(${stringifyRequest(loaderContext, addQuery(loaderContext.resource, { page: true }))}).default\n`
+      }
+
+      content += buildGlobalParams({ moduleId, scriptSrcMode, loaderContext, isProduction, webConfig, hasApp })
+      content += getRequireScript({ ctorType, script, loaderContext })
+      content += `
+  export default processComponentOption({
+    option: global.__mpxOptionsMap[${JSON.stringify(moduleId)}],
+    ctorType: ${JSON.stringify(ctorType)},
+    outputPath: ${JSON.stringify(outputPath)},
+    pageConfig: ${JSON.stringify(pageConfig)},
+    // @ts-ignore
+    componentsMap: ${shallowStringify(componentsMap)},
+    componentGenerics: ${JSON.stringify(componentGenerics)},
+    genericsInfo: ${JSON.stringify(genericsInfo)},
+    wxsMixin: null,
+    hasApp: ${hasApp}
+  })\n`
+
+  content += '\n__dynamic_page_slot__\n'
+
+      return content
+    }
+  })
+
+  output += '\n'
+  // 处理pages
+  const pageSet = new Set()
+  let dynamicPageStr = ''
+  async.each(localPagesMap, (pageCfg, callback) => {
+    if (typeof pageCfg !== 'string') pageCfg.src = addQuery(pageCfg.src, { tenon: true })
+    processPage(pageCfg, loaderContext.context, '', (err, entry, { key } = {}) => {
+      if (err) return callback()
+      if (pageSet.has(key)) return callback()
+      pageSet.add(key)
+      dynamicPageStr += `\n"${entry}"`
+      callback()
+    })
+  }, () => {
+    output = output.replace('__dynamic_page_slot__', processDynamicEntry(dynamicPageStr) || '')
+    callback(null, {
+      output
+    })
+  })
+}

package/lib/tenon/processStyles.js

@@ -0,0 +1,21 @@
+const genComponentTag = require('../utils/gen-component-tag')
+
+module.exports = function (styles, options, callback) {
+  let output = '/* styles */\n'
+  if (styles.length) {
+    styles.forEach((style) => {
+      output += genComponentTag(style, {
+        attrs (style) {
+          const attrs = Object.assign({}, style.attrs)
+          if (options.autoScope) attrs.scoped = true
+          return attrs
+        }
+      })
+      output += '\n'
+    })
+    output += '\n'
+  }
+  callback(null, {
+    output
+  })
+}

package/lib/tenon/processTemplate.js

@@ -0,0 +1,125 @@
+const templateCompiler = require('../template-compiler/compiler')
+const genComponentTag = require('../utils/gen-component-tag')
+const addQuery = require('../utils/add-query')
+const path = require('path')
+const parseRequest = require('../utils/parse-request')
+
+module.exports = function (template, {
+  loaderContext,
+  hasScoped,
+  hasComment,
+  isNative,
+  srcMode,
+  moduleId,
+  ctorType,
+  usingComponentsInfo,
+  componentGenerics
+}, callback) {
+  const mpx = loaderContext.getMpx()
+  const {
+    mode,
+    env,
+    defs,
+    wxsContentMap,
+    decodeHTMLText,
+    externalClasses,
+    checkUsingComponents,
+    webConfig,
+    autoVirtualHostRules
+  } = mpx
+  const { resourcePath } = parseRequest(loaderContext.resource)
+  const builtInComponentsMap = {}
+  let wxsModuleMap, genericsInfo
+  let output = '/* template */\n'
+
+  if (ctorType === 'app') {
+    template = {
+      tag: 'template',
+      content: '<div class="app">this is app</div>'
+    }
+  }
+
+  if (template) {
+    // 由于远端src template资源引用的相对路径可能发生变化，暂时不支持。
+    if (template.src) {
+      return callback(new Error('[mpx loader][' + loaderContext.resource + ']: ' + 'template content must be inline in .mpx files!'))
+    }
+    if (template.lang) {
+      return callback(new Error('[mpx loader][' + loaderContext.resource + ']: ' + 'template lang is not supported in trans web mode temporarily, we will support it in the future!'))
+    }
+
+    output += genComponentTag(template, (template) => {
+      if (ctorType === 'app') {
+        return template.content
+      }
+      if (template.content) {
+        const templateSrcMode = template.mode || srcMode
+        const parsed = templateCompiler.parse(template.content, {
+          warn: (msg) => {
+            loaderContext.emitWarning(
+              new Error('[template compiler][' + loaderContext.resource + ']: ' + msg)
+            )
+          },
+          error: (msg) => {
+            loaderContext.emitError(
+              new Error('[template compiler][' + loaderContext.resource + ']: ' + msg)
+            )
+          },
+          usingComponentsInfo,
+          hasComment,
+          isNative,
+          basename: path.basename(resourcePath),
+          isComponent: ctorType === 'component',
+          mode,
+          srcMode: templateSrcMode,
+          defs,
+          decodeHTMLText,
+          // externalClasses: options.externalClasses,
+          hasScoped: false,
+          moduleId,
+          filePath: loaderContext.resourcePath,
+          i18n: null,
+          checkUsingComponents,
+          // web模式下全局组件不会被合入usingComponents中，故globalComponents可以传空
+          globalComponents: [],
+          // web模式下实现抽象组件
+          componentGenerics
+        })
+        // if (parsed.meta.wxsModuleMap) {
+        //   wxsModuleMap = parsed.meta.wxsModuleMap
+        // }
+        // if (parsed.meta.wxsContentMap) {
+        //   for (let module in parsed.meta.wxsContentMap) {
+        //     wxsContentMap[`${resourcePath}~${module}`] = parsed.meta.wxsContentMap[module]
+        //   }
+        // }
+        if (parsed.meta.builtInComponentsMap) {
+          Object.keys(parsed.meta.builtInComponentsMap).forEach((name) => {
+            builtInComponentsMap[name] = {
+              resource: addQuery(parsed.meta.builtInComponentsMap[name], { component: true })
+            }
+          })
+        }
+        // if (parsed.meta.genericsInfo) {
+        //   genericsInfo = parsed.meta.genericsInfo
+        // }
+        // 输出H5有多个root element时, 使用div标签包裹
+        // if (parsed.root.tag === 'temp-node') {
+        //   const childLen = calculateRootEleChild(parsed.root.children)
+        //   if (childLen >= 2) {
+        //     parsed.root.tag = 'div'
+        //   }
+        // }
+        return templateCompiler.serialize(parsed.root)
+      }
+    })
+    output += '\n\n'
+  }
+
+  callback(null, {
+    output,
+    builtInComponentsMap,
+    genericsInfo,
+    wxsModuleMap
+  })
+}

package/lib/tenon/script-helper.js

@@ -0,0 +1,223 @@
+const loaderUtils = require('loader-utils')
+const normalize = require('../utils/normalize')
+const createHelpers = require('../helpers')
+const tabBarContainerPath = normalize.lib('runtime/components/web/mpx-tab-bar-container.vue')
+const tabBarPath = normalize.lib('runtime/components/web/mpx-tab-bar.vue')
+const addQuery = require('../utils/add-query')
+const parseRequest = require('../utils/parse-request')
+const shallowStringify = require('../utils/shallow-stringify')
+
+function stringifyRequest (loaderContext, request) {
+  return loaderUtils.stringifyRequest(loaderContext, request)
+}
+
+function getAsyncChunkName (chunkName) {
+  if (chunkName && typeof chunkName !== 'boolean') {
+    return `/* webpackChunkName: "${chunkName}" */`
+  }
+  return ''
+}
+
+function buildComponentsMap ({ localComponentsMap, builtInComponentsMap, loaderContext, jsonConfig }) {
+  const componentsMap = {}
+  if (localComponentsMap) {
+    Object.keys(localComponentsMap).forEach((componentName) => {
+      const componentCfg = localComponentsMap[componentName]
+      const componentRequest = stringifyRequest(loaderContext, componentCfg.resource)
+      if (componentCfg.async) {
+        // todo 暂时只处理局部注册的组件作为componentPlaceholder，暂不支持全局组件和原生组件，如使用了支持范围外的组件将不进行placeholder渲染及替换
+        if (jsonConfig.componentPlaceholder && jsonConfig.componentPlaceholder[componentName] && localComponentsMap[jsonConfig.componentPlaceholder[componentName]]) {
+          const placeholder = jsonConfig.componentPlaceholder[componentName]
+          const placeholderCfg = localComponentsMap[placeholder]
+          const placeholderRequest = stringifyRequest(loaderContext, placeholderCfg.resource)
+          if (placeholderCfg.async) {
+            loaderContext.emitWarning(
+              new Error(`[json processor][${loaderContext.resource}]: componentPlaceholder ${placeholder} should not be a async component, please check!`)
+            )
+          }
+          componentsMap[componentName] = `function(){return {component: import(${getAsyncChunkName(componentCfg.async)}${componentRequest}).then(function(res){return getComponent(res)}), loading: getComponent(require(${placeholderRequest}))}}`
+        } else {
+          componentsMap[componentName] = `function(){return import(${getAsyncChunkName(componentCfg.async)}${componentRequest}).then(function(res){return getComponent(res)})}`
+        }
+      } else {
+        componentsMap[componentName] = `getComponent(require(${componentRequest}))`
+      }
+    })
+  }
+  if (builtInComponentsMap) {
+    Object.keys(builtInComponentsMap).forEach((componentName) => {
+      const componentCfg = builtInComponentsMap[componentName]
+      const componentRequest = stringifyRequest(loaderContext, componentCfg.resource)
+      componentsMap[componentName] = `getComponent(require(${componentRequest}), {__mpxBuiltIn: true})`
+    })
+  }
+  return componentsMap
+}
+
+function buildPagesMap ({ localPagesMap, loaderContext, tabBar, tabBarMap, tabBarStr, jsonConfig }) {
+  let globalTabBar = ''
+  let firstPage = ''
+  const pagesMap = {}
+  const tabBarPagesMap = {}
+  if (tabBar && tabBarMap) {
+    // 挂载tabBar组件
+    const tabBarRequest = stringifyRequest(loaderContext, addQuery(tabBar.custom ? './custom-tab-bar/index' : tabBarPath, { isComponent: true }))
+    tabBarPagesMap['mpx-tab-bar'] = `getComponent(require(${tabBarRequest}))`
+    // 挂载tabBar页面
+    Object.keys(tabBarMap).forEach((pagePath) => {
+      const pageCfg = localPagesMap[pagePath]
+      if (pageCfg) {
+        const pageRequest = stringifyRequest(loaderContext, pageCfg.resource)
+        if (pageCfg.async) {
+          tabBarPagesMap[pagePath] = `function(){return import(${getAsyncChunkName(pageCfg.async)}${pageRequest}).then(function(res) {return getComponent(res, {__mpxPageRoute: ${JSON.stringify(pagePath)}})})}`
+        } else {
+          tabBarPagesMap[pagePath] = `getComponent(require(${pageRequest}), {__mpxPageRoute: ${JSON.stringify(pagePath)}})`
+        }
+      } else {
+        loaderContext.emitWarning(
+          new Error(`[json processor][${loaderContext.resource}]: TabBar page path ${pagePath} is not exist in local page map, please check!`)
+        )
+      }
+    })
+  }
+  if (tabBarStr && tabBarPagesMap) {
+    globalTabBar += `
+  global.__tabBar = ${tabBarStr}
+  Vue.observable(global.__tabBar)
+  // @ts-ignore
+  global.__tabBarPagesMap = ${shallowStringify(tabBarPagesMap)}\n`
+  }
+  Object.keys(localPagesMap).forEach((pagePath) => {
+    const pageCfg = localPagesMap[pagePath]
+    const pageRequest = stringifyRequest(loaderContext, pageCfg.resource)
+    if (tabBarMap && tabBarMap[pagePath]) {
+      pagesMap[pagePath] = `getComponent(require(${stringifyRequest(loaderContext, tabBarContainerPath)}), {__mpxBuiltIn: true})`
+    } else {
+      if (pageCfg.async) {
+        pagesMap[pagePath] = `function(){return import(${getAsyncChunkName(pageCfg.async)} ${pageRequest}).then(function(res){return getComponent(res, {__mpxPageRoute: ${JSON.stringify(pagePath)}})})}`
+      } else {
+        // 为了保持小程序中app->page->component的js执行顺序，所有的page和component都改为require引入
+        pagesMap[pagePath] = `getComponent(require(${pageRequest}), {__mpxPageRoute: ${JSON.stringify(pagePath)}})`
+      }
+    }
+
+    if (pagePath === jsonConfig.entryPagePath) {
+      firstPage = pagePath
+    }
+    if (!firstPage && pageCfg.isFirst) {
+      firstPage = pagePath
+    }
+  })
+  return {
+    pagesMap,
+    firstPage,
+    globalTabBar
+  }
+}
+
+function getRequireScript ({ script, ctorType, loaderContext }) {
+  let content = '  /** script content **/\n'
+  const { getRequire } = createHelpers(loaderContext)
+  const { resourcePath, queryObj } = parseRequest(loaderContext.resource)
+  const extraOptions = {
+    ...script.src
+      ? { ...queryObj, resourcePath }
+      : null,
+    ctorType,
+    lang: script.lang || 'js'
+  }
+  content += `  ${getRequire('script', script, extraOptions)}\n`
+  return content
+}
+
+function buildGlobalParams ({
+  moduleId,
+  scriptSrcMode,
+  loaderContext,
+  isProduction,
+  jsonConfig,
+  webConfig,
+  isMain,
+  globalTabBar,
+  hasApp
+}) {
+  let content = ''
+  if (isMain) {
+    content += `
+  global.getApp = function () {}
+  global.getCurrentPages = function () {
+    if (!(typeof window !== 'undefined')) {
+      console.error('[Mpx runtime error]: Dangerous API! global.getCurrentPages is running in non browser environment, It may cause some problems, please use this method with caution')
+    }
+    var router = global.__mpxRouter
+    if (!router) return []
+    // @ts-ignore
+    return (router.lastStack || router.stack).map(function (item) {
+      var page
+      var vnode = item.vnode
+      if (vnode && vnode.componentInstance) {
+        page = vnode.tag.endsWith('mpx-tab-bar-container') ? vnode.componentInstance.$refs.tabBarPage : vnode.componentInstance
+      }
+      return page || { route: item.path.slice(1) }
+    })
+  }
+  global.__networkTimeout = ${JSON.stringify(jsonConfig.networkTimeout)}
+  global.__mpxGenericsMap = {}
+  global.__mpxOptionsMap = {}
+  global.__style = ${JSON.stringify(jsonConfig.style || 'v1')}
+  global.__mpxPageConfig = ${JSON.stringify(jsonConfig.window)}
+  global.__mpxTransRpxFn = ${webConfig.transRpxFn}\n`
+    if (globalTabBar) {
+      content += globalTabBar
+    }
+  } else {
+    if (!hasApp) {
+      content += '  global.__mpxGenericsMap = global.__mpxGenericsMap || {}\n'
+      content += '  global.__mpxOptionsMap = global.__mpxOptionsMap || {}\n'
+      content += `  global.__mpxTransRpxFn = ${webConfig.transRpxFn}\n`
+    }
+    content += `  global.currentModuleId = ${JSON.stringify(moduleId)}\n`
+    content += `  global.currentSrcMode = ${JSON.stringify(scriptSrcMode)}\n`
+    content += `  global.currentInject = ${JSON.stringify({ moduleId })}\n`
+    if (!isProduction) {
+      content += `  global.currentResource = ${JSON.stringify(loaderContext.resourcePath)}\n`
+    }
+  }
+  return content
+}
+
+function buildI18n ({ i18n, loaderContext }) {
+  let i18nContent = ''
+  const i18nObj = Object.assign({}, i18n)
+  i18nContent += `
+  import VueI18n from 'vue-i18n'
+  import { createI18n } from 'vue-i18n-bridge'
+  Vue.use(VueI18n , { bridge: true })\n`
+  const requestObj = {}
+  const i18nKeys = ['messages', 'dateTimeFormats', 'numberFormats']
+  i18nKeys.forEach((key) => {
+    if (i18nObj[`${key}Path`]) {
+      requestObj[key] = stringifyRequest(loaderContext, i18nObj[`${key}Path`])
+      delete i18nObj[`${key}Path`]
+    }
+  })
+  i18nContent += `  var i18nCfg = ${JSON.stringify(i18nObj)}\n`
+  Object.keys(requestObj).forEach((key) => {
+    i18nContent += `  i18nCfg.${key} = require(${requestObj[key]})\n`
+  })
+  i18nContent += `
+  i18nCfg.legacy = false
+  var i18n = createI18n(i18nCfg, VueI18n)
+  Vue.use(i18n)
+  Mpx.i18n = i18n\n`
+  return i18nContent
+}
+
+module.exports = {
+  buildPagesMap,
+  buildComponentsMap,
+  getRequireScript,
+  buildGlobalParams,
+  stringifyRequest,
+  buildI18n
+}

package/lib/utils/env.js

@@ -6,12 +6,17 @@ function isWeb (mode) {
     return mode === 'web'
 }
 
+function isTenon (mode) {
+    return mode === 'tenon'
+}
+
 function isMiniProgram (mode) {
-    return !isWeb(mode) && !isReact(mode)
+    return !isWeb(mode) && !isReact(mode) && !isTenon(mode)
 }
 
 module.exports = {
     isWeb,
     isReact,
+    isTenon,
     isMiniProgram
 }

package/lib/utils/get-relative-path.js

@@ -0,0 +1,25 @@
+function getRelativePath (source, target) {
+  // make sure source and target are absolute path
+  /^\//.test(source) || (source = '/' + source);
+  /^\//.test(target) || (target = '/' + target)
+
+  source = source && source.replace(/\/[^/]*$/, '') // get dirname
+  // check if source or target is root path
+  const sourceArr = source.split('/').filter((item, index) => index !== 0 && !!item)
+  const targetArr = target.split('/').filter((item, index) => index !== 0 && !!item)
+  let i = 0
+  while (sourceArr[i] === targetArr[i] && i < sourceArr.length && i < targetArr.length) {
+    i++
+  }
+  let relativePath = ''
+  for (let j = 0; j < sourceArr.length - i; j++) {
+    relativePath += '../'
+  }
+  relativePath += targetArr.slice(i).join('/')
+  if (relativePath[0] !== '.') relativePath = './' + relativePath
+  return relativePath
+}
+
+module.exports = {
+  getRelativePath
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpxjs/webpack-plugin",
-  "version": "2.9.69",
+  "version": "2.9.70-alpha.1",
   "description": "mpx compile core",
   "keywords": [
     "mpx"
@@ -27,8 +27,11 @@
     "@better-scroll/slide": "^2.5.1",
     "@better-scroll/wheel": "^2.5.1",
     "@better-scroll/zoom": "^2.5.1",
+    "@hummer/tenon-dev-server-webpack-plugin": "0.0.2",
+    "@hummer/tenon-loader": "^1.2.0",
+    "@hummer/tenon-style-loader": "^0.2.0",
     "@mpxjs/template-engine": "^2.8.7",
-    "@mpxjs/utils": "^2.9.69",
+    "@mpxjs/utils": ">=2.9.69-alpha",
     "acorn": "^8.11.3",
     "acorn-walk": "^7.2.0",
     "async": "^2.6.0",
@@ -92,11 +95,12 @@
     "react-native-linear-gradient": "^2.8.3",
     "react-native-reanimated": "^3.15.2",
     "react-native-safe-area-context": "^4.12.0",
+    "react-native-svg": "^15.8.0",
     "react-native-webview": "^13.12.2",
     "rimraf": "^6.0.1"
   },
   "engines": {
     "node": ">=14.14.0"
   },
-  "gitHead": "e23c51acc4c2ffdd31fcc6c27aae1aed42d1ade2"
+  "gitHead": "2d37697869b9bdda3efab92dda8c910b68fd05c0"
 }