@cbjwwwcode/common 0.0.1

package/src/vtj/provider.ts

@@ -0,0 +1,113 @@
+import type { BlockSchema, ProjectSchema } from '@vtj/core';
+import type { Provider, ProviderOptions } from '@vtj/renderer';
+
+import type { App } from 'vue';
+
+import type { JsonNodeProps } from './node';
+import type { IRequestOptions, IStaticRequest } from './request';
+import type { UseStoreServiceReturn } from './stores';
+
+import { inject, reactive } from 'vue';
+
+import { makeUuid } from '../common';
+import { ContextMode, createProvider } from '@vtj/renderer';
+
+import { createNodeRequest } from './request';
+import { NodeService } from './service';
+
+export type { BlockSchema };
+export { ContextMode };
+
+declare interface VTJConfig {
+  id?: string;
+  name?: string;
+  onInst?: (provider: Provider) => void;
+  onReady?: () => void;
+  providerOptions?: Partial<ProviderOptions>;
+  requestInst?: (request: IStaticRequest) => void;
+  requestOptions?: IRequestOptions;
+  storage?: UseStoreServiceReturn;
+}
+
+export const vtjSymbol = Symbol('vtj-provider');
+
+export function initProvider(app: App, config?: VTJConfig) {
+  const cacheNodes = reactive<any>({});
+  const service = new NodeService(config?.storage);
+  const { provider, onReady } = createProvider({
+    service,
+    dependencies: {
+      Vue: ()=> import('vue')
+    },
+    ...config?.providerOptions,
+  });
+  provider.adapter.request = createNodeRequest(
+    config?.requestOptions,
+    config?.requestInst,
+  );
+  if (config?.onInst && typeof config?.onInst === 'function') {
+    config.onInst(provider);
+  }
+  if (config?.onReady && typeof config?.onReady === 'function') {
+    onReady(config.onReady);
+  }
+
+  const updateBlocks = async (blocks?: BlockSchema[]) => {
+    blocks?.forEach((block: BlockSchema) => {
+      // @ts-ignore
+      service.publishFile(project, block);
+    });
+  };
+
+  const project = reactive<ProjectSchema>({
+    id: config?.id || makeUuid(),
+    name: config?.name || 'VTJAdmin',
+    platform: 'web',
+    config: {
+      themeSwitchable: false,
+    },
+  });
+
+  async function initProject(props: JsonNodeProps) {
+    Object.assign(project, {
+      apis: props.apis || [],
+      meta: props.meta || [],
+      dependencies: props.dependencies || [
+        {
+          package: 'common',
+          version: 'latest',
+          library: 'Vue',
+          urls: ['libs/common.min.js'],
+          assetsLibrary: 'VueMaterial',
+          required: true,
+          official: true,
+          enabled: true,
+          platform: ['web', 'h5']
+        },
+      ],
+    });
+    await service.saveProject(project as ProjectSchema);
+    // @ts-ignore
+    await provider.load(project);
+    await updateBlocks(props.blocks);
+    provider.mode = ContextMode[props.mode || 'Runtime'];
+    return provider;
+  }
+  // app.use(provider);
+  // provider.install(app);
+
+  const stores = {
+    provider,
+    updateBlocks,
+    cacheNodes,
+    initProject,
+  };
+  app.provide(vtjSymbol, stores);
+  return stores;
+}
+
+declare type ProviderStore = ReturnType<typeof initProvider>;
+
+export function useGlobalProvider() {
+  return inject(vtjSymbol, {} as ProviderStore);
+}

package/src/vtj/request.ts

@@ -0,0 +1,34 @@
+import type { IRequestOptions, IStaticRequest } from '@vtj/utils';
+
+import { createRequest } from '@vtj/utils';
+
+export type { IRequestOptions, IStaticRequest };
+
+export function createNodeRequest(
+  options?: IRequestOptions,
+  requestInst?: (request: IStaticRequest) => void,
+) {
+  const request = createRequest({
+    ...options,
+    settings: {
+      type: 'form',
+      validSuccess: false,
+      originResponse: false,
+      loading: true,
+      failMessage: false,
+      ...options?.settings,
+    },
+  });
+
+  request.useRequest(async (config: any) => {
+    // const accessStore = useAccessStore();
+    // config.headers.Authorization = formatToken(accessStore.accessToken);
+    // config.headers['Accept-Language'] = preferences.app.locale;
+    return config;
+  });
+
+  if (requestInst && typeof requestInst === 'function') {
+    requestInst(request);
+  }
+  return request;
+}

package/src/vtj/service.ts

@@ -0,0 +1,93 @@
+import type {
+  BlockFile,
+  BlockSchema,
+  MaterialDescription,
+  NodeFromPlugin,
+  PageFile,
+  ProjectSchema,
+  StaticFileInfo,
+} from '@vtj/core';
+
+import { StoresService } from './stores';
+
+const notification = {
+  warning: (options: any) => {
+    console.warn(options);
+  },
+};
+
+export class NodeService extends StoresService {
+  override async createRawPage(_file: PageFile): Promise<boolean> {
+    notification.warning({
+      title: '提示',
+      content: '在线演示版本不支持源码模式页面，如需体验请下载本地版本。',
+    });
+    return false;
+  }
+  override genVueContent(
+    _project: ProjectSchema,
+    _dsl: BlockSchema,
+  ): Promise<string> {
+    notification.warning({
+      title: '提示',
+      content: '在线演示版本不支持源码生成功能，如需体验请下载本地版本。',
+    });
+
+    return Promise.resolve('');
+  }
+  override async getPluginMaterial(
+    _from: NodeFromPlugin,
+  ): Promise<MaterialDescription | null> {
+    notification.warning({
+      title: '提示',
+      content: '在线演示版本不支持引用和插件，如需体验请下载本地版本。',
+    });
+    return null;
+  }
+  override async getStaticFiles(_projectId: string): Promise<StaticFileInfo[]> {
+    notification.warning({
+      title: '提示',
+      content: '在线演示版本不支持文件上传，如需体验请下载本地版本。',
+    });
+    return [];
+  }
+
+  override publish(_project: ProjectSchema): Promise<boolean> {
+    notification.warning({
+      title: '提示',
+      content: '在线演示版本不支持发布功能，如需体验请下载本地版本。',
+    });
+    return Promise.resolve(false);
+  }
+
+  override publishFile(
+    _project: ProjectSchema,
+    _file: BlockFile | BlockSchema | PageFile,
+  ): Promise<boolean> {
+    if ('dsl' in _file) {
+      _file.dsl && this.saveFile(_file.dsl);
+    } else {
+      _file && this.saveFile(_file);
+    }
+    return Promise.resolve(false);
+  }
+
+  override async removeRawPage(_id: string): Promise<boolean> {
+    notification.warning({
+      title: '提示',
+      content: '在线演示版本不支持源码模式页面，如需体验请下载本地版本。',
+    });
+    return false;
+  }
+
+  override async uploadStaticFile(
+    _file: File,
+    _rojectId: string,
+  ): Promise<null | StaticFileInfo> {
+    notification.warning({
+      title: '提示',
+      content: '在线演示版本不支持文件上传，如需体验请下载本地版本。',
+    });
+    return null;
+  }
+}

package/src/vtj/stores.ts

@@ -0,0 +1,144 @@
+import type {
+  BlockSchema,
+  HistoryItem,
+  HistorySchema,
+  MaterialDescription,
+  ProjectSchema,
+} from '@vtj/core';
+
+import { reactive } from 'vue';
+
+import { HistoryModel, ProjectModel } from '@vtj/core';
+import { BaseService } from '@vtj/renderer';
+
+/**
+ * Map转键值对
+ *
+ * @param map
+ */
+export function mapToObject<V = any>(map: Map<any, V>) {
+  return [...map.entries()].reduce(
+    (obj, [key, value]) => {
+      obj[key] = value;
+      return obj;
+    },
+    {} as Record<any, V>,
+  );
+}
+
+export const useStoreService = () => {
+  return {
+    storage: reactive<Record<string, any>>({}),
+    save(id: string, value: any) {
+      this.storage[id] = value;
+    },
+    get(id: string) {
+      return this.storage[id] || null;
+    },
+    remove(id: string) {
+      if (this.storage[id] !== undefined) {
+        delete this.storage[id];
+      }
+    },
+  };
+};
+
+export declare type UseStoreServiceReturn = typeof useStoreService;
+
+export class StoresService extends BaseService {
+  protected stores: any;
+  constructor(stores?: UseStoreServiceReturn) {
+    super();
+    this.stores = stores ? stores() : useStoreService();
+  }
+  public override getFile(id: string): Promise<BlockSchema> {
+    const dsl = this.stores.get(`file_${id}`);
+    return dsl ? Promise.resolve(dsl as BlockSchema) : Promise.reject(null);
+  }
+
+  public override getHistory(id: string): Promise<HistorySchema> {
+    const dsl = this.stores.get(`history_${id}`);
+    const history = new HistoryModel(dsl || { id });
+    return Promise.resolve(history.toDsl());
+  }
+
+  public override getHistoryItem(
+    fId: string,
+    id: string,
+  ): Promise<HistoryItem> {
+    const item = this.stores.get(`history_${fId}_${id}`);
+    return Promise.resolve(item);
+  }
+
+  public override init(project: ProjectSchema): Promise<ProjectSchema> {
+    const model = new ProjectModel(project);
+    const match = this.stores.get(`project_${model.id}`);
+    const dsl = Object.assign(model.toDsl(), match || {});
+    this.stores.save(`project_${model.id}`, dsl);
+    return Promise.resolve(dsl);
+  }
+
+  public override removeFile(id: string): Promise<boolean> {
+    this.stores.remove(`file_${id}`);
+    return Promise.resolve(true);
+  }
+
+  public override async removeHistory(id: string): Promise<boolean> {
+    const history = this.stores.get(`history_${id}`) as HistorySchema;
+    if (history) {
+      const items = history.items || [];
+      const ids = items.map((item) => item.id);
+      await this.removeHistoryItem(id, ids);
+      this.stores.remove(`history_${id}`);
+    }
+
+    return Promise.resolve(true);
+  }
+
+  /**
+   * @param fId
+   * @param ids
+   * @override
+   */
+  public override removeHistoryItem(
+    fId: string,
+    ids: string[],
+  ): Promise<boolean> {
+    ids.forEach((id) => {
+      this.stores.remove(`history_${fId}_${id}`);
+    });
+    return Promise.resolve(true);
+  }
+
+  public override saveFile(file: BlockSchema): Promise<boolean> {
+    this.stores.save(`file_${file.id}`, file);
+    return Promise.resolve(true);
+  }
+
+  public override saveHistory(history: HistorySchema): Promise<boolean> {
+    this.stores.save(`history_${history.id}`, history);
+    return Promise.resolve(true);
+  }
+
+  public override saveHistoryItem(
+    fId: string,
+    item: HistoryItem,
+  ): Promise<boolean> {
+    this.stores.save(`history_${fId}_${item.id}`, item);
+    return Promise.resolve(true);
+  }
+
+  public override saveMaterials(
+    project: ProjectSchema,
+    materials: Map<string, MaterialDescription>,
+  ): Promise<boolean> {
+    this.stores.save(`materials_${project.id}`, mapToObject(materials));
+    return Promise.resolve(true);
+  }
+
+  public override saveProject(project: ProjectSchema): Promise<boolean> {
+    const model = new ProjectModel(project);
+    this.stores.save(`project_${model.id}`, model.toDsl());
+    return Promise.resolve(true);
+  }
+}

package/src/vue-router.ts

@@ -0,0 +1 @@
+export * as VueRouter from 'vue-router';

package/src/vue.ts

@@ -0,0 +1,3 @@
+export * as Vue from 'vue';
+
+// export * as VueDemi from 'vue-demi';

package/src/vueuse.ts

@@ -0,0 +1,13 @@
+export {
+  createGlobalState,
+  createReusableTemplate,
+  onClickOutside,
+  useClipboard,
+  useScriptTag,
+  useStorage,
+  useStyleTag,
+  useToggle,
+} from '@vueuse/core';
+
+export * as VueUse from '@vueuse/core';
+

package/src/window.ts

@@ -0,0 +1,60 @@
+/* eslint-disable */
+// @ts-nocheck
+import axios from 'axios';
+// @ts-ignore
+import mitt from 'mitt';
+
+import { CryptoJS } from './crypto';
+// import { Sortable } from './sortablejs';
+import { Vue } from './vue';
+import { VueRouter } from './vue-router';
+import { VueUse } from './vueuse';
+import { zod } from './zod';
+import { VueLowlight, hljs } from './lowlight';
+import { isPlainObject } from 'es-toolkit/compat';
+
+
+export const $mitt = mitt();
+
+export { axios };
+
+/**
+ * 判断是否是 ES Module 命名空间对象 import * as xxx from 'xxx'
+ */
+export function isModuleObject(value: unknown): value is Record<string, any> {
+  if (value && isPlainObject(value)){
+    const tag = (value as any)[Symbol.toStringTag];
+    return tag === 'Module';
+  }
+  return false;
+}
+
+export function registerWindow<T extends any>(key: string, value: T) {
+  if (typeof window !== 'undefined' && !Reflect.has(window, key)) {
+    Object.defineProperty(window, key, {
+      get: () => value,
+      enumerable: true,
+    });
+    if (!isModuleObject(window[key])){
+      Object.defineProperty(window[key], '__esModule', { value: true });
+    }
+  }
+}
+
+registerWindow('zod', zod);
+registerWindow('Vue', Vue);
+registerWindow('VueUse', VueUse);
+// registerWindow('VueDemi', VueDemi);
+registerWindow('VueRouter', VueRouter);
+registerWindow('axios', axios);
+registerWindow('CryptoJS', CryptoJS);
+registerWindow('VueLowlight', VueLowlight);
+registerWindow('hljs', hljs);
+// registerWindow('Sortable', Sortable);
+registerWindow('process', {
+  env: {
+    NODE_ENV: 'production',
+  },
+});
+
+

package/src/zod.ts

@@ -0,0 +1 @@
+export * as zod from 'zod';