morghulis 1.0.40 → 1.0.41

package/node_modules/@fortawesome/vue-fontawesome/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "@fortawesome/vue-fontawesome",
+  "description": "Official Vue component for Font Awesome 6",
+  "version": "3.0.8",
+  "main": "index.js",
+  "files": [
+    "README.md",
+    "LICENSE.txt",
+    "UPGRADING.md",
+    "CHANGELOG.md",
+    "index.d.ts",
+    "index.es.js",
+    "index.js",
+    "src/components/**.js",
+    "src/**.js"
+  ],
+  "jest": {
+    "verbose": true,
+    "testEnvironmentOptions": {
+      "customExportConditions": [
+        "node",
+        "node-addons"
+      ]
+    }
+  },
+  "module": "index.es.js",
+  "jsnext:main": "index.es.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/FortAwesome/vue-fontawesome",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/FortAwesome/vue-fontawesome.git"
+  },
+  "contributors": [
+    "Aaron Parker <github.com/parkeyparker>",
+    "Brandon Mork <github.com/brandon-mork>",
+    "btaens <github.com/btaens>",
+    "David Driscoll <github.com/david-driscoll>",
+    "Liu Xinyu <github.com/meteorlxy>",
+    "Michael Cozzolino <https://github.com/michaelcozzolino>",
+    "Okke Tijhuis <github.com/otijhuis>",
+    "Romain Failla <https://github.com/rigma>",
+    "SirLamer <github.com/SirLamer>",
+    "Tyranteon <github.com/tyranteon>",
+    "Vinicius Rangel <github.com/viniciuslrangel>",
+    "Xaver Schulz <github.com/schulz3000>",
+    "Yannick Ihmels <github.com/ihmels>",
+    "Brian Talbot <https://github.com/talbs>",
+    "Jason Lundien <https://github.com/jasonlundien>",
+    "Mike Wilkerson <https://github.com/mlwilkerson>",
+    "Rob Madole <rob@fontawesome.com>",
+    "Travis Chase <travis@fontawesome.com>"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "rollup -c rollup.config.js",
+    "dist": "cross-env NODE_ENV=production npm run build",
+    "test": "jest --silent",
+    "prepack": "npm run dist"
+  },
+  "lint-staged": {
+    "README.md": [
+      "markdown-toc -i",
+      "git add"
+    ]
+  },
+  "peerDependencies": {
+    "@fortawesome/fontawesome-svg-core": "~1 || ~6",
+    "vue": ">= 3.0.0 < 4"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.18.2",
+    "@babel/plugin-external-helpers": "^7.17.12",
+    "@babel/plugin-proposal-class-properties": "^7.17.12",
+    "@babel/plugin-proposal-json-strings": "^7.17.12",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-syntax-import-meta": "^7.10.4",
+    "@babel/preset-env": "^7.18.2",
+    "@fortawesome/fontawesome-svg-core": "~6",
+    "@fortawesome/free-solid-svg-icons": "^6",
+    "@rollup/plugin-babel": "^5.3.1",
+    "@rollup/plugin-commonjs": "^22.0.0",
+    "@rollup/plugin-node-resolve": "^13.3.0",
+    "@vue/test-utils": "^2.0.0-beta.2",
+    "babel-core": "^7.0.0-bridge.0",
+    "babel-jest": "^28.1.1",
+    "concurrently": "^7.2.1",
+    "cross-env": "^7.0.3",
+    "humps": "^2.0.1",
+    "husky": "^8.0.1",
+    "install": "^0.13.0",
+    "jest": "^28.1.1",
+    "jest-environment-jsdom": "^28.1.1",
+    "lint-staged": "^13.0.0",
+    "markdown-toc": "^1.2.0",
+    "npm": "^10.2.2",
+    "prettier": "^3.0.3",
+    "rollup": "^2.75.6",
+    "vue": "^3"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  }
+}

package/node_modules/@fortawesome/vue-fontawesome/src/components/FontAwesomeIcon.js

@@ -0,0 +1,178 @@
+import { parse as faParse, icon as faIcon } from '@fortawesome/fontawesome-svg-core'
+import { defineComponent, computed, watch } from 'vue'
+import convert from '../converter'
+import log from '../logger'
+import { objectWithKey, classList } from '../utils'
+
+function normalizeIconArgs(icon) {
+  if (icon && typeof icon === 'object' && icon.prefix && icon.iconName && icon.icon) {
+    return icon
+  }
+
+  if (faParse.icon) {
+    return faParse.icon(icon)
+  }
+
+  if (icon === null) {
+    return null
+  }
+
+  if (typeof icon === 'object' && icon.prefix && icon.iconName) {
+    return icon
+  }
+
+  if (Array.isArray(icon) && icon.length === 2) {
+    return { prefix: icon[0], iconName: icon[1] }
+  }
+
+  if (typeof icon === 'string') {
+    return { prefix: 'fas', iconName: icon }
+  }
+}
+
+export default defineComponent({
+  name: 'FontAwesomeIcon',
+
+  props: {
+    border: {
+      type: Boolean,
+      default: false
+    },
+    fixedWidth: {
+      type: Boolean,
+      default: false
+    },
+    flip: {
+      type: [Boolean, String],
+      default: false,
+      validator: (value) => [true, false, 'horizontal', 'vertical', 'both'].indexOf(value) > -1
+    },
+    icon: {
+      type: [Object, Array, String],
+      required: true
+    },
+    mask: {
+      type: [Object, Array, String],
+      default: null
+    },
+    maskId: {
+      type: String,
+      default: null
+    },
+    listItem: {
+      type: Boolean,
+      default: false
+    },
+    pull: {
+      type: String,
+      default: null,
+      validator: (value) => ['right', 'left'].indexOf(value) > -1
+    },
+    pulse: {
+      type: Boolean,
+      default: false
+    },
+    rotation: {
+      type: [String, Number],
+      default: null,
+      validator: (value) => [90, 180, 270].indexOf(Number.parseInt(value, 10)) > -1
+    },
+    swapOpacity: {
+      type: Boolean,
+      default: false
+    },
+    size: {
+      type: String,
+      default: null,
+      validator: (value) => ['2xs', 'xs', 'sm', 'lg', 'xl', '2xl', '1x', '2x', '3x', '4x', '5x', '6x', '7x', '8x', '9x', '10x'].indexOf(value) > -1
+    },
+    spin: {
+      type: Boolean,
+      default: false
+    },
+    transform: {
+      type: [String, Object],
+      default: null
+    },
+    symbol: {
+      type: [Boolean, String],
+      default: false
+    },
+    title: {
+      type: String,
+      default: null
+    },
+    titleId: {
+      type: String,
+      default: null
+    },
+    inverse: {
+      type: Boolean,
+      default: false
+    },
+    bounce: {
+      type: Boolean,
+      default: false
+    },
+    shake: {
+      type: Boolean,
+      default: false
+    },
+    beat: {
+      type: Boolean,
+      default: false
+    },
+    fade: {
+      type: Boolean,
+      default: false
+    },
+    beatFade: {
+      type: Boolean,
+      default: false
+    },
+    flash: {
+      type: Boolean,
+      default: false
+    },
+    spinPulse: {
+      type: Boolean,
+      default: false
+    },
+    spinReverse: {
+      type: Boolean,
+      default: false
+    }
+  },
+
+  setup(props, { attrs }) {
+    const icon = computed(() => normalizeIconArgs(props.icon))
+    const classes = computed(() => objectWithKey('classes', classList(props)))
+    const transform = computed(() => objectWithKey('transform', typeof props.transform === 'string' ? faParse.transform(props.transform) : props.transform))
+    const mask = computed(() => objectWithKey('mask', normalizeIconArgs(props.mask)))
+
+    const renderedIcon = computed(() =>
+      faIcon(icon.value, {
+        ...classes.value,
+        ...transform.value,
+        ...mask.value,
+        symbol: props.symbol,
+        title: props.title,
+        titleId: props.titleId,
+        maskId: props.maskId
+      })
+    )
+
+    watch(
+      renderedIcon,
+      (value) => {
+        if (!value) {
+          return log('Could not find one or more icon(s)', icon.value, mask.value)
+        }
+      },
+      { immediate: true }
+    )
+
+    const vnode = computed(() => (renderedIcon.value ? convert(renderedIcon.value.abstract[0], {}, attrs) : null))
+    return () => vnode.value
+  }
+})

package/node_modules/@fortawesome/vue-fontawesome/src/components/FontAwesomeLayers.js

@@ -0,0 +1,24 @@
+import { config } from '@fortawesome/fontawesome-svg-core'
+import { defineComponent, h, computed } from 'vue'
+
+export default defineComponent({
+  name: 'FontAwesomeLayers',
+
+  props: {
+    fixedWidth: {
+      type: Boolean,
+      default: false
+    }
+  },
+
+  setup (props, { slots }) {
+    const { familyPrefix } = config
+
+    const className = computed(() => [
+      `${familyPrefix}-layers`,
+      ...(props.fixedWidth ? [`${familyPrefix}-fw`] : [])
+    ])
+
+    return () => h('div', { class: className.value }, slots.default ? slots.default() : [])
+  }
+})

package/node_modules/@fortawesome/vue-fontawesome/src/components/FontAwesomeLayersText.js

@@ -0,0 +1,49 @@
+import { config, parse, text } from '@fortawesome/fontawesome-svg-core'
+import { defineComponent, computed } from 'vue'
+import convert from '../converter'
+import { objectWithKey } from '../utils'
+
+export default defineComponent({
+  name: 'FontAwesomeLayersText',
+
+  props: {
+    value: {
+      type: [String, Number],
+      default: ''
+    },
+    transform: {
+      type: [String, Object],
+      default: null
+    },
+    counter: {
+      type: Boolean,
+      default: false
+    },
+    position: {
+      type: String,
+      default: null,
+      validator: (value) => ['bottom-left', 'bottom-right', 'top-left', 'top-right'].indexOf(value) > -1
+    },
+  },
+
+  setup (props, { attrs }) {
+    const { familyPrefix } = config
+
+    const classes = computed(() => objectWithKey('classes', [
+      ...(props.counter ? [`${familyPrefix}-layers-counter`] : []),
+      ...(props.position ? [`${familyPrefix}-layers-${props.position}`] : [])
+    ]))
+    const transform = computed(() => objectWithKey('transform', 
+      typeof props.transform === 'string' ? parse.transform(props.transform) : props.transform))
+    const abstractElement = computed(() => {
+      const { abstract } = text(props.value.toString(), { ...transform.value, ...classes.value })
+      if (props.counter) {
+        abstract[0].attributes.class = abstract[0].attributes.class.replace('fa-layers-text', '')
+      }
+      return abstract[0]
+    })
+
+    const vnode = computed(() => convert(abstractElement.value, {}, attrs))
+    return () => vnode.value
+  }
+})

package/node_modules/@fortawesome/vue-fontawesome/src/converter.js

@@ -0,0 +1,118 @@
+import { h } from 'vue'
+import humps from 'humps'
+
+/**
+ * Converts a CSS style into a plain Javascript object.
+ * @param {String} style The style to converts into a plain Javascript object.
+ * @returns {Object}
+ */
+function styleToObject (style) {
+  return style.split(';')
+    .map(s => s.trim())
+    .filter(s => s)
+    .reduce(
+      (output, pair) => {
+        const idx = pair.indexOf(':')
+        const prop = humps.camelize(pair.slice(0, idx))
+        const value = pair.slice(idx + 1).trim()
+
+        output[prop] = value
+        return output
+      },
+      {}
+    )
+}
+
+/**
+ * Converts a CSS class list into a plain Javascript object.
+ * @param {Array<String>} classes The class list to convert.
+ * @returns {Object}
+ */
+function classToObject (classes) {
+  return classes.split(/\s+/)
+    .reduce(
+      (output, className) => {
+        output[className] = true
+        return output
+      },
+      {}
+    )
+}
+
+/**
+ * Combines collections of style classes into one collection
+ * @param  {Array<String | String[]>} collections The collections to combine.
+ * @returns {Array<String>}
+ */
+function combineClassObjects (...collections) {
+  const finalSet = new Set([])
+
+  collections.forEach(set => {
+    if (Array.isArray(set)) {
+      finalSet.forEach(className => finalSet.add(className))
+    } else {
+      finalSet.add(set)
+    }
+  })
+
+  return Array.from(finalSet)
+}
+
+/**
+ * Converts a FontAwesome abstract element of an icon into a Vue VNode.
+ * @param {AbstractElement | String} abstractElement The element to convert.
+ * @param {Object} props The user-defined props.
+ * @param {Object} attrs The user-defined native HTML attributes.
+ * @returns {VNode}
+ */
+export default function convert (abstractElement, props = {}, attrs = {}) {
+  // If the abstract element is a string, we'll just return a string render function
+  if (typeof abstractElement === 'string') {
+    return abstractElement
+  }
+
+  // Converting abstract element children into Vue VNodes
+  const children = (abstractElement.children || [])
+    .map(child => convert(child))
+
+  // Converting abstract element attributes into valid Vue format
+  const mixins = Object.keys(abstractElement.attributes || {})
+    .reduce(
+      (mixins, key) => {
+        const value = abstractElement.attributes[key]
+
+        switch (key) {
+          case 'class':
+            mixins.class = classToObject(value)
+            break
+          case 'style':
+            mixins.style = styleToObject(value)
+            break
+          default:
+            mixins.attrs[key] = value
+        }
+
+        return mixins
+      },
+      {
+        attrs: {},
+        class: {},
+        style: {}
+      }
+    )
+
+  // Now, we'll return the VNode
+  const { class: _aClass = {}, style: aStyle = {}, ...otherAttrs } = attrs
+
+  return h(
+    abstractElement.tag,
+    {
+      ...props,
+      class: mixins.class,
+      style: { ...mixins.style, ...aStyle },
+      ...mixins.attrs,
+      ...otherAttrs
+    },
+    children
+  )
+}

package/node_modules/@fortawesome/vue-fontawesome/src/index.js

@@ -0,0 +1,3 @@
+export { default as FontAwesomeIcon } from './components/FontAwesomeIcon'
+export { default as FontAwesomeLayers } from './components/FontAwesomeLayers'
+export { default as FontAwesomeLayersText } from './components/FontAwesomeLayersText'

package/node_modules/@fortawesome/vue-fontawesome/src/logger.js

@@ -0,0 +1,11 @@
+let PRODUCTION = false
+
+try {
+  PRODUCTION = process.env.NODE_ENV === 'production'
+} catch (e) { }
+
+export default function (...args) {
+  if (!PRODUCTION && console && typeof console.error === 'function') {
+    console.error(...args)
+  }
+}

package/node_modules/@fortawesome/vue-fontawesome/src/utils.js

@@ -0,0 +1,39 @@
+export function objectWithKey (key, value) {
+  return ((Array.isArray(value) && value.length > 0) || (!Array.isArray(value) && value)) ? {[key]: value} : {}
+}
+
+export function classList (props) {
+  let classes = {
+    'fa-spin': props.spin,
+    'fa-pulse': props.pulse,
+    'fa-fw': props.fixedWidth,
+    'fa-border': props.border,
+    'fa-li': props.listItem,
+    'fa-inverse': props.inverse,
+    'fa-flip': props.flip === true,
+    'fa-flip-horizontal': props.flip === 'horizontal' || props.flip === 'both',
+    'fa-flip-vertical': props.flip === 'vertical' || props.flip === 'both',
+    [`fa-${props.size}`]: props.size !== null,
+    [`fa-rotate-${props.rotation}`]: props.rotation !== null,
+    [`fa-pull-${props.pull}`]: props.pull !== null,
+    'fa-swap-opacity': props.swapOpacity,
+    'fa-bounce': props.bounce,
+    'fa-shake': props.shake,
+    'fa-beat': props.beat,
+    'fa-fade': props.fade,
+    'fa-beat-fade': props.beatFade,
+    'fa-flash': props.flash,
+    'fa-spin-pulse': props.spinPulse,
+    'fa-spin-reverse': props.spinReverse
+  }
+
+  return Object.keys(classes)
+    .map(key => classes[key] ? key : null)
+    .filter(key => key)
+}
+
+export function addStaticClass(to, what) {
+  const val = (to || '').length === 0 ? [] : [to]
+
+  return val.concat(what).join(' ')
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "morghulis",
-  "version": "1.0.40",
+  "version": "1.0.41",
   "description": "数据库模型",
   "private": false,
   "type": "module",
@@ -34,7 +34,10 @@
     "lodash": "^4.17.21"
   },
   "bundleDependencies": [
-    "element-plus"
+    "element-plus",
+    "@fortawesome/fontawesome-svg-core",
+    "@fortawesome/free-solid-svg-icons",
+    "@fortawesome/vue-fontawesome"
   ],
   "devDependencies": {
     "@tsconfig/node22": "^22.0.1",