@nocobase/client-v2 2.0.0-alpha.20

package/lib/Plugin.js

@@ -0,0 +1,89 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Plugin_exports = {};
+__export(Plugin_exports, {
+  Plugin: () => Plugin
+});
+module.exports = __toCommonJS(Plugin_exports);
+const _Plugin = class _Plugin {
+  constructor(options, app) {
+    this.options = options;
+    this.app = app;
+    this.options = options;
+    this.app = app;
+  }
+  get pluginManager() {
+    return this.app.pluginManager;
+  }
+  get context() {
+    return this.app.context;
+  }
+  get flowEngine() {
+    return this.app.flowEngine;
+  }
+  get engine() {
+    return this.app.flowEngine;
+  }
+  get pm() {
+    return this.app.pm;
+  }
+  get router() {
+    return this.app.router;
+  }
+  get pluginSettingsManager() {
+    return this.app.pluginSettingsManager;
+  }
+  get pluginSettingsRouter() {
+    return this.app.pluginSettingsManager;
+  }
+  get schemaInitializerManager() {
+    return this.app.schemaInitializerManager;
+  }
+  get schemaSettingsManager() {
+    return this.app.schemaSettingsManager;
+  }
+  get dataSourceManager() {
+    return this.app.dataSourceManager;
+  }
+  async afterAdd() {
+  }
+  async beforeLoad() {
+  }
+  async load() {
+  }
+  t(text, options = {}) {
+    var _a;
+    return this.app.i18n.t(text, { ns: (_a = this.options) == null ? void 0 : _a["packageName"], ...options });
+  }
+};
+__name(_Plugin, "Plugin");
+let Plugin = _Plugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Plugin
+});

package/lib/PluginManager.d.ts

@@ -0,0 +1,46 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { Application } from './Application';
+import type { Plugin } from './Plugin';
+export type PluginOptions<T = any> = {
+    name?: string;
+    packageName?: string;
+    config?: T;
+};
+export type PluginType<Opts = any> = typeof Plugin | [typeof Plugin<Opts>, PluginOptions<Opts>];
+export type PluginData = {
+    name: string;
+    packageName: string;
+    version: string;
+    url: string;
+    type: 'local' | 'upload' | 'npm';
+};
+export declare class PluginManager {
+    protected _plugins: PluginType[];
+    protected loadRemotePlugins: boolean;
+    protected app: Application;
+    protected pluginInstances: Map<typeof Plugin, Plugin>;
+    protected pluginsAliases: Record<string, Plugin>;
+    private initPlugins;
+    constructor(_plugins: PluginType[], loadRemotePlugins: boolean, app: Application);
+    /**
+     * @internal
+     */
+    init(_plugins: PluginType[]): Promise<void>;
+    private initStaticPlugins;
+    private initRemotePlugins;
+    add<T = any>(plugin: typeof Plugin, opts?: PluginOptions<T>): Promise<void>;
+    get<T extends typeof Plugin>(PluginClass: T): InstanceType<T>;
+    get<T extends {}>(name: string): T;
+    private getInstance;
+    /**
+     * @internal
+     */
+    load(): Promise<void>;
+}

package/lib/PluginManager.js

@@ -0,0 +1,114 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var PluginManager_exports = {};
+__export(PluginManager_exports, {
+  PluginManager: () => PluginManager
+});
+module.exports = __toCommonJS(PluginManager_exports);
+var import_remotePlugins = require("./utils/remotePlugins");
+const _PluginManager = class _PluginManager {
+  constructor(_plugins, loadRemotePlugins, app) {
+    this._plugins = _plugins;
+    this.loadRemotePlugins = loadRemotePlugins;
+    this.app = app;
+    this.app = app;
+    this.initPlugins = this.init(_plugins);
+  }
+  pluginInstances = /* @__PURE__ */ new Map();
+  pluginsAliases = {};
+  initPlugins;
+  /**
+   * @internal
+   */
+  async init(_plugins) {
+    await this.initStaticPlugins(_plugins);
+    if (this.loadRemotePlugins) {
+      await this.initRemotePlugins();
+    }
+  }
+  async initStaticPlugins(_plugins = []) {
+    for await (const plugin of _plugins) {
+      const pluginClass = Array.isArray(plugin) ? plugin[0] : plugin;
+      const opts = Array.isArray(plugin) ? plugin[1] : void 0;
+      await this.add(pluginClass, opts);
+    }
+  }
+  async initRemotePlugins() {
+    var _a;
+    const res = await this.app.apiClient.request({ url: "pm:listEnabled" });
+    const pluginList = ((_a = res == null ? void 0 : res.data) == null ? void 0 : _a.data) || [];
+    const plugins = await (0, import_remotePlugins.getPlugins)({
+      requirejs: this.app.requirejs,
+      pluginData: pluginList,
+      devDynamicImport: this.app.devDynamicImport
+    });
+    for await (const [name, pluginClass] of plugins) {
+      const info = pluginList.find((item) => item.name === name);
+      await this.add(pluginClass, info);
+    }
+  }
+  async add(plugin, opts = {}) {
+    const instance = this.getInstance(plugin, opts);
+    this.pluginInstances.set(plugin, instance);
+    if (opts.name) {
+      this.pluginsAliases[opts.name] = instance;
+    }
+    if (opts.packageName) {
+      this.pluginsAliases[opts.packageName] = instance;
+    }
+    await instance.afterAdd();
+  }
+  get(nameOrPluginClass) {
+    if (typeof nameOrPluginClass === "string") {
+      return this.pluginsAliases[nameOrPluginClass];
+    }
+    return this.pluginInstances.get(nameOrPluginClass.default || nameOrPluginClass);
+  }
+  getInstance(plugin, opts) {
+    return new plugin(opts, this.app);
+  }
+  /**
+   * @internal
+   */
+  async load() {
+    await this.initPlugins;
+    for (const plugin of this.pluginInstances.values()) {
+      await plugin.beforeLoad();
+    }
+    for (const plugin of this.pluginInstances.values()) {
+      await plugin.load();
+      this.app.eventBus.dispatchEvent(new CustomEvent(`plugin:${plugin.options.name}:loaded`, { detail: plugin }));
+    }
+  }
+};
+__name(_PluginManager, "PluginManager");
+let PluginManager = _PluginManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginManager
+});

package/lib/PluginSettingsManager.d.ts

@@ -0,0 +1,67 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import React from 'react';
+import type { Application } from './Application';
+import type { RouteType } from './RouterManager';
+export declare const ADMIN_SETTINGS_KEY = "admin.settings.";
+export declare const ADMIN_SETTINGS_PATH = "/admin/settings/";
+export declare const SNIPPET_PREFIX = "pm.";
+export interface PluginSettingOptions {
+    title: any;
+    /**
+     * @default Outlet
+     */
+    Component?: RouteType['Component'];
+    icon?: string;
+    /**
+     * sort, the smaller the number, the higher the priority
+     * @default 0
+     */
+    sort?: number;
+    aclSnippet?: string;
+    link?: string;
+    isTopLevel?: boolean;
+    isPinned?: boolean;
+    [index: string]: any;
+}
+export interface PluginSettingsPageType {
+    label?: string | React.ReactElement;
+    title: string | React.ReactElement;
+    link?: string;
+    key: string;
+    icon: any;
+    path: string;
+    sort?: number;
+    name?: string;
+    isAllow?: boolean;
+    topLevelName?: string;
+    aclSnippet: string;
+    children?: PluginSettingsPageType[];
+    [index: string]: any;
+}
+export declare class PluginSettingsManager {
+    protected settings: Record<string, PluginSettingOptions>;
+    protected aclSnippets: string[];
+    app: Application;
+    private cachedList;
+    constructor(_pluginSettings: Record<string, PluginSettingOptions>, app: Application);
+    clearCache(): void;
+    setAclSnippets(aclSnippets: string[]): void;
+    getAclSnippet(name: string): string;
+    getRouteName(name: string): string;
+    getRoutePath(name: string): string;
+    add(name: string, options: PluginSettingOptions): void;
+    remove(name: string): void;
+    hasAuth(name: string): boolean;
+    getSetting(name: string): PluginSettingOptions;
+    has(name: string): boolean;
+    get(name: string, filterAuth?: boolean): PluginSettingsPageType;
+    getList(filterAuth?: boolean): PluginSettingsPageType[];
+    getAclSnippets(): string[];
+}

package/lib/PluginSettingsManager.js

@@ -0,0 +1,148 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var PluginSettingsManager_exports = {};
+__export(PluginSettingsManager_exports, {
+  ADMIN_SETTINGS_KEY: () => ADMIN_SETTINGS_KEY,
+  ADMIN_SETTINGS_PATH: () => ADMIN_SETTINGS_PATH,
+  PluginSettingsManager: () => PluginSettingsManager,
+  SNIPPET_PREFIX: () => SNIPPET_PREFIX
+});
+module.exports = __toCommonJS(PluginSettingsManager_exports);
+var import_lodash = require("lodash");
+var import_react_router_dom = require("react-router-dom");
+const ADMIN_SETTINGS_KEY = "admin.settings.";
+const ADMIN_SETTINGS_PATH = "/admin/settings/";
+const SNIPPET_PREFIX = "pm.";
+const _PluginSettingsManager = class _PluginSettingsManager {
+  settings = {};
+  aclSnippets = [];
+  app;
+  cachedList = {};
+  constructor(_pluginSettings, app) {
+    this.app = app;
+    Object.entries(_pluginSettings || {}).forEach(([name, pluginSettingOptions]) => {
+      this.add(name, pluginSettingOptions);
+    });
+  }
+  clearCache() {
+    this.cachedList = {};
+  }
+  setAclSnippets(aclSnippets) {
+    this.aclSnippets = aclSnippets;
+  }
+  getAclSnippet(name) {
+    const setting = this.settings[name];
+    if (setting == null ? void 0 : setting.skipAclConfigure) {
+      return null;
+    }
+    return (setting == null ? void 0 : setting.aclSnippet) ? setting.aclSnippet : `${SNIPPET_PREFIX}${name}`;
+  }
+  getRouteName(name) {
+    return `${ADMIN_SETTINGS_KEY}${name}`;
+  }
+  getRoutePath(name) {
+    return `${ADMIN_SETTINGS_PATH}${name.replaceAll(".", "/")}`;
+  }
+  add(name, options) {
+    const nameArr = name.split(".");
+    const topLevelName = nameArr[0];
+    this.settings[name] = {
+      ...this.settings[name],
+      Component: import_react_router_dom.Outlet,
+      ...options,
+      name,
+      topLevelName: options.topLevelName || topLevelName
+    };
+    if (nameArr.length > 1) {
+      (0, import_lodash.set)(this.settings, nameArr.join(".children."), this.settings[name]);
+    }
+    this.app.router.add(this.getRouteName(name), {
+      path: this.getRoutePath(name),
+      Component: this.settings[name].Component
+    });
+  }
+  remove(name) {
+    Object.keys(this.settings).forEach((key) => {
+      if (key.startsWith(name)) {
+        delete this.settings[key];
+        this.app.router.remove(`${ADMIN_SETTINGS_KEY}${key}`);
+      }
+    });
+  }
+  hasAuth(name) {
+    if (this.aclSnippets.includes(`!${this.getAclSnippet("*")}`)) return false;
+    return this.aclSnippets.includes(`!${this.getAclSnippet(name)}`) === false;
+  }
+  getSetting(name) {
+    return this.settings[name];
+  }
+  has(name) {
+    const hasAuth = this.hasAuth(name);
+    if (!hasAuth) return false;
+    return !!this.getSetting(name);
+  }
+  get(name, filterAuth = true) {
+    var _a, _b;
+    const isAllow = this.hasAuth(name);
+    const pluginSetting = this.getSetting(name);
+    if (filterAuth && !isAllow || !pluginSetting) return null;
+    const children = Object.keys(pluginSetting.children || {}).sort((a, b) => a.localeCompare(b)).map((key) => this.get(pluginSetting.children[key].name, filterAuth)).filter(Boolean).sort((a, b) => (a.sort || 0) - (b.sort || 0));
+    const { title, icon, aclSnippet, ...others } = pluginSetting;
+    return {
+      isTopLevel: name === pluginSetting.topLevelName,
+      ...others,
+      aclSnippet: this.getAclSnippet(name),
+      title,
+      isAllow,
+      label: title,
+      icon: (_b = (_a = this.app.flowEngine.context).renderIon) == null ? void 0 : _b.call(_a, icon),
+      path: this.getRoutePath(name),
+      key: name,
+      children: children.length ? children : void 0
+    };
+  }
+  getList(filterAuth = true) {
+    const cacheKey = JSON.stringify(filterAuth);
+    if (this.cachedList[cacheKey]) return this.cachedList[cacheKey];
+    return this.cachedList[cacheKey] = Array.from(
+      new Set(Object.values(this.settings).map((item) => item.topLevelName))
+    ).sort((a, b) => a.localeCompare(b)).map((name) => this.get(name, filterAuth)).filter(Boolean).sort((a, b) => (a.sort || 0) - (b.sort || 0));
+  }
+  getAclSnippets() {
+    return Object.keys(this.settings).map((name) => this.getAclSnippet(name)).filter(Boolean);
+  }
+};
+__name(_PluginSettingsManager, "PluginSettingsManager");
+let PluginSettingsManager = _PluginSettingsManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ADMIN_SETTINGS_KEY,
+  ADMIN_SETTINGS_PATH,
+  PluginSettingsManager,
+  SNIPPET_PREFIX
+});

package/lib/RouterManager.d.ts

@@ -0,0 +1,61 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import React, { ComponentType } from 'react';
+import { type BrowserRouterProps, type HashRouterProps, type MemoryRouterProps, type RouteObject } from 'react-router-dom';
+import { Application } from './Application';
+export interface BrowserRouterOptions extends Omit<BrowserRouterProps, 'children'> {
+    type?: 'browser';
+}
+export interface HashRouterOptions extends Omit<HashRouterProps, 'children'> {
+    type?: 'hash';
+}
+export interface MemoryRouterOptions extends Omit<MemoryRouterProps, 'children'> {
+    type?: 'memory';
+}
+export type RouterOptions = (HashRouterOptions | BrowserRouterOptions | MemoryRouterOptions) & {
+    renderComponent?: RenderComponentType;
+    routes?: Record<string, RouteType>;
+};
+export type ComponentTypeAndString<T = any> = ComponentType<T> | string;
+export interface RouteType extends Omit<RouteObject, 'children' | 'Component'> {
+    Component?: ComponentTypeAndString;
+    skipAuthCheck?: boolean;
+}
+export type RenderComponentType = (Component: ComponentTypeAndString, props?: any) => React.ReactNode;
+export declare class RouterManager {
+    protected routes: Record<string, RouteType>;
+    protected options: RouterOptions;
+    app: Application;
+    router: any;
+    get basename(): any;
+    get state(): any;
+    get navigate(): any;
+    constructor(options: RouterOptions, app: Application);
+    /**
+     * @internal
+     */
+    getRoutesTree(): RouteObject[];
+    getRoutes(): Record<string, RouteType>;
+    setType(type: RouterOptions['type']): void;
+    getBasename(): string;
+    setBasename(basename: string): void;
+    matchRoutes(pathname: string): import("@remix-run/router").AgnosticRouteMatch<string, RouteType>[];
+    isSkippedAuthCheckRoute(pathname: string): boolean;
+    /**
+     * @internal
+     */
+    getRouterComponent(children?: React.ReactNode): React.FC<{
+        BaseLayout?: ComponentType;
+    }>;
+    add(name: string, route: RouteType): void;
+    get(name: string): RouteType;
+    has(name: string): boolean;
+    remove(name: string): void;
+}
+export declare function createRouterManager(options?: RouterOptions, app?: Application): RouterManager;