409 lines
10 KiB
JavaScript
409 lines
10 KiB
JavaScript
/*
|
||
* XmlDigitalTeaching v0.0.1
|
||
* Copyright ©Mon Jul 22 2024 15:42:53 GMT+0800 (中国标准时间) smile
|
||
* Released under the ISC License.
|
||
*/
|
||
var singleGroupMixin = {
|
||
props: {
|
||
activeIndex: {
|
||
type: Number,
|
||
default: -1
|
||
},
|
||
location: {
|
||
type: String,
|
||
default: ''
|
||
},
|
||
islast: {
|
||
type: Boolean,
|
||
default: false
|
||
}
|
||
},
|
||
provide() {
|
||
return {
|
||
getSingleGroupLocation: () => this.location
|
||
};
|
||
},
|
||
computed: {
|
||
groupIsActive() {
|
||
return this.ruleIndex === this.activeIndex;
|
||
}
|
||
},
|
||
watch: {
|
||
pGroupData: {
|
||
handler() {
|
||
if (this.pGroupData.options?.marginTop !== undefined && this.pGroupData.options.marginTop !== -1) {
|
||
this.$nextTick(() => {
|
||
this.$el && this.$el.style.setProperty('--book-marginTop', this.pGroupData.options.marginTop + 'px');
|
||
});
|
||
}
|
||
},
|
||
deep: true,
|
||
immediate: true
|
||
}
|
||
},
|
||
created() {
|
||
if (this.pGroupData.options?.marginTop === undefined) {
|
||
let options = this.pGroupData.options ? {
|
||
...this.pGroupData.options,
|
||
marginTop: -1
|
||
} : {
|
||
marginTop: -1
|
||
};
|
||
this.$emit('updateModel', {
|
||
key: 'pGroupData',
|
||
value: {
|
||
...this.pGroupData,
|
||
options
|
||
}
|
||
});
|
||
}
|
||
},
|
||
mounted() {
|
||
if (this.islast) {
|
||
this.$nextTick(() => {
|
||
this.$EventBus.$emit('mounted_success');
|
||
});
|
||
}
|
||
},
|
||
methods: {
|
||
emitClick(e) {
|
||
this.$emit('click', e, this.ruleIndex, this.currentRule);
|
||
}
|
||
}
|
||
};
|
||
|
||
//
|
||
/**
|
||
* 单文本组合
|
||
*/
|
||
var script = {
|
||
name: 'XmlSingleTextGroupRender',
|
||
mixins: [singleGroupMixin],
|
||
// components: { },
|
||
data() {
|
||
return {
|
||
typeText: '文本',
|
||
textDataName: 'textData',
|
||
showComponentButtons: false,
|
||
groupData: {}
|
||
};
|
||
},
|
||
props: {
|
||
//模式：preview 预览 (默认)，editor 编辑
|
||
mode: {
|
||
type: String,
|
||
default: function () {
|
||
return 'editor';
|
||
}
|
||
},
|
||
//必须有此属性，接收初始化值
|
||
pGroupData: {
|
||
type: Object,
|
||
default: function () {
|
||
return {};
|
||
}
|
||
},
|
||
//必须有此属性，页面类型，取值h5、pc、pad
|
||
pageType: {
|
||
type: String,
|
||
default: 'h5'
|
||
},
|
||
resourceBasisPath: {
|
||
type: String,
|
||
default: ''
|
||
},
|
||
ruleIndex: Number,
|
||
//当前所处组的规则
|
||
currentRule: {
|
||
type: Object,
|
||
default: function () {
|
||
return {};
|
||
}
|
||
},
|
||
extendParams: {
|
||
type: Object,
|
||
default: function () {
|
||
return {};
|
||
}
|
||
},
|
||
projectId: {
|
||
type: String,
|
||
default: ''
|
||
}
|
||
},
|
||
created() {
|
||
this.groupData = this.pGroupData;
|
||
},
|
||
methods: {
|
||
//
|
||
/***
|
||
* 固定方法。接收固定参数
|
||
* 此方法接收块儿点击事件，事件传递块相关参数
|
||
* @param blockData 块中的data属性数据
|
||
* @param dataName 块data数据在组中时，属性key
|
||
* @param propertyComponentsName 块儿对应的属性组件名
|
||
*/
|
||
handleBlockClick({
|
||
blockData,
|
||
dataName,
|
||
propertyComponentsName,
|
||
blockId,
|
||
ruleIndex
|
||
}) {
|
||
this.$emit('blockclick', {
|
||
groupData: this.groupData,
|
||
blockData,
|
||
dataName,
|
||
propertyComponentsName,
|
||
currentRule: this.currentRule,
|
||
blockId,
|
||
ruleIndex
|
||
});
|
||
},
|
||
groupDataChange({
|
||
ruleIndex,
|
||
dataName,
|
||
data
|
||
}) {
|
||
this.$emit('groupDataChange', {
|
||
ruleIndex,
|
||
dataName,
|
||
data
|
||
});
|
||
}
|
||
}
|
||
};
|
||
|
||
function normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier /* server only */, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {
|
||
if (typeof shadowMode !== 'boolean') {
|
||
createInjectorSSR = createInjector;
|
||
createInjector = shadowMode;
|
||
shadowMode = false;
|
||
}
|
||
// Vue.extend constructor export interop.
|
||
const options = typeof script === 'function' ? script.options : script;
|
||
// render functions
|
||
if (template && template.render) {
|
||
options.render = template.render;
|
||
options.staticRenderFns = template.staticRenderFns;
|
||
options._compiled = true;
|
||
// functional template
|
||
if (isFunctionalTemplate) {
|
||
options.functional = true;
|
||
}
|
||
}
|
||
// scopedId
|
||
if (scopeId) {
|
||
options._scopeId = scopeId;
|
||
}
|
||
let hook;
|
||
if (moduleIdentifier) {
|
||
// server build
|
||
hook = function (context) {
|
||
// 2.3 injection
|
||
context = context ||
|
||
// cached call
|
||
this.$vnode && this.$vnode.ssrContext ||
|
||
// stateful
|
||
this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext; // functional
|
||
// 2.2 with runInNewContext: true
|
||
if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
|
||
context = __VUE_SSR_CONTEXT__;
|
||
}
|
||
// inject component styles
|
||
if (style) {
|
||
style.call(this, createInjectorSSR(context));
|
||
}
|
||
// register component module identifier for async chunk inference
|
||
if (context && context._registeredComponents) {
|
||
context._registeredComponents.add(moduleIdentifier);
|
||
}
|
||
};
|
||
// used by ssr in case component is cached and beforeCreate
|
||
// never gets called
|
||
options._ssrRegister = hook;
|
||
} else if (style) {
|
||
hook = shadowMode ? function (context) {
|
||
style.call(this, createInjectorShadow(context, this.$root.$options.shadowRoot));
|
||
} : function (context) {
|
||
style.call(this, createInjector(context));
|
||
};
|
||
}
|
||
if (hook) {
|
||
if (options.functional) {
|
||
// register for functional component in vue file
|
||
const originalRender = options.render;
|
||
options.render = function renderWithStyleInjection(h, context) {
|
||
hook.call(context);
|
||
return originalRender(h, context);
|
||
};
|
||
} else {
|
||
// inject component registration as beforeCreate hook
|
||
const existing = options.beforeCreate;
|
||
options.beforeCreate = existing ? [].concat(existing, hook) : [hook];
|
||
}
|
||
}
|
||
return script;
|
||
}
|
||
|
||
/* script */
|
||
const __vue_script__ = script;
|
||
/* template */
|
||
var __vue_render__ = function () {
|
||
var _vm = this;
|
||
var _h = _vm.$createElement;
|
||
var _c = _vm._self._c || _h;
|
||
return _c(
|
||
"div",
|
||
{
|
||
staticClass: "parent-group parent-group-mark text-body-mark",
|
||
class: [
|
||
"xml-single-text-group",
|
||
"xml-single-text-group-" + _vm.pageType,
|
||
_vm.groupIsActive ? "active" : "",
|
||
],
|
||
on: { click: _vm.emitClick },
|
||
},
|
||
[
|
||
_c(
|
||
"xml-group-render",
|
||
{
|
||
ref: "xmlGroup",
|
||
staticClass: "optional-text",
|
||
attrs: {
|
||
"page-type": _vm.pageType,
|
||
"type-text": _vm.typeText,
|
||
projectId: _vm.projectId,
|
||
mode: _vm.mode,
|
||
showLine: false,
|
||
"rule-index": _vm.ruleIndex,
|
||
},
|
||
scopedSlots: _vm._u(
|
||
[
|
||
{
|
||
key: "action-buttons",
|
||
fn: function () {
|
||
return [_vm._t("default")]
|
||
},
|
||
proxy: true,
|
||
},
|
||
],
|
||
null,
|
||
true
|
||
),
|
||
},
|
||
[
|
||
_vm._v(" "),
|
||
_c("xml-text-render", {
|
||
ref: "xmlText",
|
||
attrs: {
|
||
projectId: _vm.projectId,
|
||
pBlockData: _vm.groupData[_vm.textDataName],
|
||
"block-data-name": _vm.textDataName,
|
||
"extend-params": _vm.extendParams,
|
||
"rule-index": _vm.ruleIndex,
|
||
currentRule: _vm.currentRule,
|
||
"css-theme": "default",
|
||
"container-class": "text-container",
|
||
"text-container": "default-text-container",
|
||
resourceBasisPath: _vm.resourceBasisPath,
|
||
mode: _vm.mode,
|
||
"page-type": _vm.pageType,
|
||
scopedSlots: { $scopedSlots: _vm.$scopedSlots },
|
||
},
|
||
on: {
|
||
"update:pBlockData": function ($event) {
|
||
return _vm.$set(_vm.groupData, _vm.textDataName, $event)
|
||
},
|
||
"update:p-block-data": function ($event) {
|
||
return _vm.$set(_vm.groupData, _vm.textDataName, $event)
|
||
},
|
||
blockclick: _vm.handleBlockClick,
|
||
groupDataChange: _vm.groupDataChange,
|
||
},
|
||
scopedSlots: _vm._u(
|
||
[
|
||
_vm._l(_vm.$scopedSlots, function (index, name) {
|
||
return {
|
||
key: name,
|
||
fn: function (deliver) {
|
||
return [_vm._t(name, null, null, deliver)]
|
||
},
|
||
}
|
||
}),
|
||
],
|
||
null,
|
||
true
|
||
),
|
||
}),
|
||
],
|
||
1
|
||
),
|
||
],
|
||
1
|
||
)
|
||
};
|
||
var __vue_staticRenderFns__ = [];
|
||
__vue_render__._withStripped = true;
|
||
|
||
/* style */
|
||
const __vue_inject_styles__ = undefined;
|
||
/* scoped */
|
||
const __vue_scope_id__ = "data-v-a8e0b970";
|
||
/* module identifier */
|
||
const __vue_module_identifier__ = undefined;
|
||
/* functional template */
|
||
const __vue_is_functional_template__ = false;
|
||
/* style inject */
|
||
|
||
/* style inject SSR */
|
||
|
||
/* style inject shadow dom */
|
||
|
||
|
||
|
||
const __vue_component__ = /*#__PURE__*/normalizeComponent(
|
||
{ render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },
|
||
__vue_inject_styles__,
|
||
__vue_script__,
|
||
__vue_scope_id__,
|
||
__vue_is_functional_template__,
|
||
__vue_module_identifier__,
|
||
false,
|
||
undefined,
|
||
undefined,
|
||
undefined
|
||
);
|
||
|
||
let componentNamespace = 'xml';
|
||
// 组件前缀命名只能更新一次，防止重复执行修改组件注册出错
|
||
let isUpdated = false;
|
||
function createNamespace(name, {
|
||
prefix,
|
||
isUnPrefix
|
||
}) {
|
||
let useNamespace;
|
||
if (!isUpdated) {
|
||
isUpdated = true;
|
||
useNamespace = prefix || componentNamespace; // 更改前缀
|
||
}
|
||
if (prefix) {
|
||
if (name.indexOf(componentNamespace) === 0) {
|
||
return name.replace(componentNamespace, prefix);
|
||
}
|
||
return useNamespace.charAt(0).toUpperCase() + useNamespace.substr(1) + name;
|
||
}
|
||
if (name.indexOf(componentNamespace) === 0 || name.indexOf(componentNamespace.charAt(0).toUpperCase()) === 0) {
|
||
return name.charAt(0).toUpperCase() + name.substr(1);
|
||
}
|
||
return isUnPrefix ? name.charAt(0).toLowerCase() + name.substr(1) : componentNamespace + name.charAt(0).toUpperCase() + name.substr(1);
|
||
}
|
||
|
||
__vue_component__.install = (Vue, options = {}) => {
|
||
Vue.component(createNamespace('single-text-group-render', {
|
||
prefix: options.prefix
|
||
}), __vue_component__);
|
||
};
|
||
|
||
export { __vue_component__ as default };
|