classNameList = Array.from(new Set(classNameList)).map((item) => '.' + item)

let cssObject = getCssObjectFromStyleStr(css)

let styleStr = ''

Object.entries(cssObject).forEach(([key, value]) => {

// 只要选择器包含目标类名，就复制

if (classNameList.some((classNameItem) => key.includes(classNameItem))) {

styleStr += `${key} {\n${value}\n}\n`

}

})

return styleStr

const content = schema?.properties?.[0]?.content || []

let emitList = []

let emitListCopies = {}

Object.keys(methods).forEach((key) => {

let item = JSON.stringify(methods[key].value).match(/emit..*?\)/g)

if (item?.length) {

emitList = [...emitList, ...item]

}

})

emitList.forEach((e) => {

let key = e.match(/'.*?'/g)[0].replace(/'/g, '')

key = `on${key[0].toLocaleUpperCase() + key.slice(1, key.length)}`

if (schema?.events[key]) {

emitListCopies[key] = schema?.events[key]

}

})

const schemaCopies = {

properties: [

{

...extend(true, {}, DEFAULT_PROPERTIES[0]),

content: content.filter((item) => contentList.includes(item.property))

}

],

events: emitListCopies || {}

}

return schemaCopies

const methodsListCopies = {}

// 因为methods方法里面大部分是用户的业务代码（无法复用）,所以只需要拷贝一个空方法即可

Object.entries(schema).forEach(([key, value]) => {

const ast = parseExpression(value.value)

// 清空函数体

if (ast.body?.body) {

ast.body.body = []

}

methodsListCopies[key] = {

type: 'JSFunction',

value: ast2String(ast)

}

})

return methodsListCopies

let stateCopies = {}

const stateKey = Object.keys(stateObj).map((e) => `state.${e} `)

stateKey.forEach((e) => {

Object.keys(methodsObj).forEach((key) => {

if (methodsObj[key].value.indexOf(e) !== -1) {

const key = e.replace('state.', '').replace(' ', '')

stateCopies[key] = stateObj[key]

}

})

})

return stateCopies

if (prop.type === SCHEMA_DATA_TYPE.I18n) {

data.langs[prop.key] = langs[prop.key]

} else if (prop.type === SCHEMA_DATA_TYPE.JSExpression) {

if (/\.state\./.test(prop.value)) {

const key = prop.value.replace('this.state.', '')

data.state[key] = state[key]

} else if (/\.props\./.test(prop.value)) {

const key = prop.value.replace('this.props.', '')

data.contentList.push(key)

} else {

const key = prop.value.replace('this.', '').replace(/\(.*?\)/, '')

data.methods[key] = methods[key]

}

}

(parseChildProps) =>

({ children = [], langs = {}, methods = {}, state = {} }) => {

const data = {

langs: {},

methods: {},

state: {},

classNameList: [],

contentList: []

}

if (Array.isArray(children)) {

children.forEach((child) => {

parseChildProps(data, { child, langs, state, methods })

})

}

return data

if (child.props) {

Object.entries(child.props).forEach(([propKey, prop]) => {

if (typeof prop === 'object') {

parsePropToData(data, { prop, langs, state, methods })

} else {

if (propKey === 'className' && prop) {

data.classNameList.push(...prop.split(' ').filter((item) => item))

}

}

})

}

if (Array.isArray(child.children)) {

const filterData = filterDataFn(parseChildProps)

const childData = filterData({ children: child.children, langs, methods, state })

Object.assign(data.langs, childData.langs)

Object.assign(data.methods, childData.methods)

Object.assign(data.state, childData.state)

data.classNameList = [...data.classNameList, ...childData.classNameList]

data.contentList = [...data.contentList, ...childData.contentList]

}

const content = block?.content || {}

content.componentName = content.componentName || content.blockName

return content

const { resetBlockCanvasState, setSaved } = useCanvas()

const { setBreadcrumbBlock } = useBreadcrumb()

// 把区块的schema传递给画布

await resetBlockCanvasState({ pageSchema: getBlockPageSchema(block) })

// 这一步操作很重要，让区块管理面板和画布共同维护同一份区块schema

block.content = useCanvas().canvasApi.value?.getSchema()

setCurrentBlock(block)

setBreadcrumbBlock([block[nameCn] || block.label], block.histories)

// 如果是点击区块管理列表进来的则不需要执行以下操作

if (!isEdit) {

// 非编辑状态即为新增，新增默认锁定画布

block.occupier = useEditorInfo().userInfo

useLayout().layoutState.pageStatus = getCanvasStatus(block.occupier)

addBlock(block)

setSaved(false)

}

const { pageState } = useCanvas()

const schema = extend(true, {}, pageState.currentSchema)

// 选中 body 节点创建区块时需传递子节点数据

const children = schema.componentName === NODE_TYPE_PAGE ? schema.children : [schema]

// 过滤只有新区块内使用到的数据

const { getLangs } = useTranslate()

const filterData = filterDataFn(parseChildProps)

const { langs, methods, state, classNameList, contentList } = extend(

true,

{},

filterData({

children,

langs: getLangs(),

methods: pageState.pageSchema.methods,

state: pageState.pageSchema.state

})

)

const css = copyCss(pageState.pageSchema.css, classNameList)

const methodsCopies = copyMethods(methods)

Object.assign(methods, methodsCopies)

const schemaCopies = copySchema(pageState.pageSchema.schema, contentList, methods)

const stateCopies = copyState(pageState.pageSchema.state, methods)

Object.assign(state, stateCopies)

const block = {

path,

[nameCn]: name_cn,

label,

histories: [],

categories,

public: BLOCK_OPENNESS.Open,

framework: getGlobalConfig()?.dslMode,

content: {

...extend(true, {}, DEFAULT_BLOCK),

fileName: label,

css,

methods,

state,

children,

schema: schemaCopies

}

}

initBlock(block, langs)

const block = {

path,

[nameCn]: name_cn,

label,

categories,

public: BLOCK_OPENNESS.Open,

framework: getGlobalConfig()?.dslMode,

content: {

...extend(true, {}, DEFAULT_BLOCK),

fileName: label

}

}

initBlock(block)

const { schema } = useCanvas().canvasApi.value?.getCurrent() || {}

if (!propertyName || !schema) {

return

}

schema.props = schema.props || {}

schema.props[propertyName] = value

if (!block) {

return

}

if (!block.content) {

block.content = {}

}

if (!block.content.schema) {

block.content.schema = {}

}

if (!block.content.schema.properties) {

block.content.schema.properties = copyArray(DEFAULT_PROPERTIES)

}

block.content.schema.properties[0].content.push(property)

if (property.linked) {

setComponentLinkedValue({

propertyName: property.linked.property,

value: {

type: SCHEMA_DATA_TYPE.JSExpression,

value: `this.props.${property.property}`

}

})

}

if (property.linked) {

const value = {

type: SCHEMA_DATA_TYPE.JSExpression,

value: `this.props.${property.property}`

}

setComponentLinkedValue({

propertyName: data?.property,

value

})

data.widget.props.modelValue = value

}

const linked = componentProperty.linked

componentProperty.linked = null

const properties = getBlockProperties(getCurrentBlock())

properties.forEach((property) => {

if (property.linked && property.property === linked.blockProperty) {

if (componentProperty.widget?.props?.modelValue) {

componentProperty.widget.props.modelValue = property.defaultValue

}

setComponentLinkedValue({

propertyName: property.linked.property,

value: property.defaultValue

})

property.linked = null

}

})

if (!block) {

return

}

if (!block.content) {

block.content = {}

}

if (!block.content.schema) {

block.content.schema = {}

}

if (!block.content.schema.events) {

block.content.schema.events = {}

}

block.content.schema.events[name] = event

const events = getBlockEvents(getCurrentBlock())

Object.entries(events).forEach(([name, event]) => {

if (linkedEventName === name) {

event.linked = null

}

})

if (!eventName || !functionName) {

return

}

const { PLUGIN_NAME, getPluginApi } = useLayout()

const getMethods = getPluginApi(PLUGIN_NAME.PageController)?.getMethods

if (getMethods && typeof getMethods === 'function') {

const method = getMethods()?.[functionName]

if (method?.type === SCHEMA_DATA_TYPE.JSFunction) {

const ast = parseExpression(method.value)

const params = ast.params.map((param) => param.name)

const emitContent = `this.emit('${hyphenate(eventName.replace(/^on/i, ''))}', ${params.join(',')})`

// 如果方法里面已经有了相同的emit语句就不添加了

if (!method?.value?.includes(emitContent)) {

ast.body.body.push(parseExpression(emitContent))

}

method.value = ast2String(ast)

}

}

if (!group) return

// 需要改变selectedGroup的引用地址才能触发tiny-select组件的watch事件

selectedGroup.value = {

groupId: group.groupId || group.id,

groupName: group.groupName || group.name

}

const result = DEFAULT_GROUPS.map((group) => ({

label: group.groupName,

value: group

}))

groups.forEach((item) => {

result.push({

label: item.name,

value: {

groupId: item.id,

groupName: item.name

}

})

})

setGroupList(groups)

return result

const { nowDayOfWeek, nowDay, nowMonth, nowYear } = date

const weekStartDate = new Date(nowYear, nowMonth, nowDay - nowDayOfWeek + 1)

return weekStartDate.setHours(0, 0, 0, 0)

const { nowMonth, nowYear } = date

const monthStartDate = new Date(nowYear, nowMonth, 1)

return monthStartDate.setHours(0, 0, 0, 0)

const { nowYear, lastMonth } = date

const lastMonthStartDate = new Date(nowYear, lastMonth, 1)

return lastMonthStartDate.setHours(0, 0, 0, 0)

// 当前日期

const now = new Date()

const nowDay = now.getDate()

const nowMonth = now.getMonth()

const nowYear = now.getFullYear()

// 今天是本周的第几天

const nowDayOfWeek = now.getDay() || 7

// 上月日期

const lastMonthDate = new Date()

lastMonthDate.setDate(1)

lastMonthDate.setMonth(lastMonthDate.getMonth() - 1)

const lastMonth = lastMonthDate.getMonth()

const date = { nowDayOfWeek, nowDay, nowMonth, nowYear, lastMonth }

// 存在currentDateStart与currentWeekStart相同的情况，故不可以用currentDateStart作key

const dateMap = new Map([

['今天', getCurrentDate],

['本周', () => getCurrentWeek(date)],

['本月', () => getCurrentMonth(date)],

['上月', () => getLastMonth(date)],

['更久以前', () => '']

])

for (let [key, value] of dateMap) {

if (timeStamp >= value()) {

return key

}

}

return undefined

const backupList = {}

if (!data || !data.length) return backupList

data.sort((backup1, backup2) => new Date(backup2.updated_at) - new Date(backup1.updated_at))

data.forEach((item) => {

const updateTime = item.updated_at && new Date(item.updated_at)

const title = getDateFromNow(updateTime?.getTime()) || ''

backupList[title] = backupList[title] || []

backupList[title].push({

backupTitle: item.message,

backupTime: format(updateTime),

id: item.id

})

})

return backupList

if (blockList.length === 0) return blockList

if (sortTypeHandlerMap[type]) {

sortTypeHandlerMap[type](blockList)

} else {

// 默认按照时间倒序进行排序

sortTypeHandlerMap[SORT_TYPE.timeDesc](blockList)

}

return blockList

const index = blockList.indexOf(block)

blockList.splice(index, 1)

selectedBlockArray.value.push(block)

return blockList

const index = selectedBlockArray.value.indexOf(block)

selectedBlockArray.value.splice(index, 1)

blockList.push(block)

return blockList

let assets = block.assets

if (version) {

const replaceUri = (uri) => uri.replace(/@\d{1,3}(\.\d{1,3}){0,2}\//, `@${version}/`)

assets = {

...block.assets,

scripts: block.assets.scripts.map(replaceUri),

styles: block.assets.styles.map(replaceUri)

}

}

return assets