@_tc/template-core 0.0.1-bate.8 → 0.0.1-bate.9

package/esm/packages/core/loader/model.d.ts

@@ -0,0 +1,37 @@
+import { KoaApp } from '../types';
+/**
+ *  xx/model/* ->
+ *  [
+ *      {
+ *          model:{
+ *              key: '',
+ *              ...model.config
+ *          }
+ *          project: {
+ *              [projectKey]: {
+ *                  ...project.config,
+ *                  key:string,
+ *              }
+ *          }
+ *      }
+ *  ]
+ *
+ */
+export interface ModelItem {
+    model: {
+        key: string;
+        [k: string]: any;
+    };
+    project: {
+        key: string;
+        [k: string]: any;
+    };
+}
+export type ModelConfig = ModelItem[];
+/**
+ *
+ * @param app
+ */
+declare const modelLoader: (app: KoaApp) => ModelConfig;
+export default modelLoader;
+//# sourceMappingURL=model.d.ts.map

package/esm/packages/core/loader/model.js

@@ -0,0 +1,127 @@
+import { sep } from 'path';
+import { loadFileFn } from '../../utils/loadFile';
+import _ from 'lodash';
+/**
+ *
+ * @param app
+ */
+const modelLoader = (app) => {
+    /**
+     * @type {ModelConfig}
+     */
+    const modelConfig = [];
+    loadFileFn(app.baseDir, 'model', {
+        /**
+         *  1.遍历当前文件夹
+         *  2.根据路径区分 model ｜ project
+         *  3.根据不同的 类型后去key
+         */
+        loadFileCallback: (file) => {
+            // 只有不为model/index.js 的文件
+            if (file.indexOf(`model${sep}index.js`) === -1) {
+                const filePathChunk = file.split(sep);
+                const suspectedFileType = filePathChunk[filePathChunk.length - 2];
+                if (suspectedFileType === 'project') {
+                    // project
+                    const modelKey = filePathChunk[filePathChunk.length - 3];
+                    const projectKey = filePathChunk[filePathChunk.length - 1]?.split('.')[0];
+                    if (modelKey && projectKey) {
+                        setProject(modelConfig, modelKey, projectKey, file);
+                    }
+                }
+                else {
+                    // model
+                    const modelKey = filePathChunk[filePathChunk.length - 2];
+                    if (modelKey) {
+                        setModel(modelConfig, modelKey, file);
+                    }
+                }
+            }
+        },
+    });
+    // 数据进行继承
+    modelConfig.forEach((config) => {
+        const { model, project } = config;
+        for (const key in project) {
+            const projectConfig = project[key];
+            if (projectConfig) {
+                project[key] = etendsObj(model, projectConfig);
+            }
+        }
+    });
+    return modelConfig;
+};
+/**
+ *
+ * @param model
+ * @param project
+ */
+function etendsObj(model, project) {
+    return _.mergeWith({}, model, project, function customizer(modelValue, projectValue) {
+        // 处理数组合并
+        if (Array.isArray(modelValue) && Array.isArray(projectValue)) {
+            let result = [];
+            // 都存在 修改/覆盖 (重载)
+            // project 不存在  (继承)
+            // model 不存在    (拓展)
+            // 修改 ｜ 保留
+            for (let index = 0; index < modelValue.length; index++) {
+                const modelItem = modelValue[index];
+                const projectItem = projectValue.find((p) => p.key === modelItem.key);
+                result.push(projectItem
+                    ? etendsObj(modelItem, projectItem)
+                    : modelItem);
+            }
+            // 新增
+            for (let index = 0; index < projectValue.length; index++) {
+                const projectItem = projectValue[index];
+                const modelItem = modelValue.find((m) => m.key === projectItem.key);
+                if (!modelItem) {
+                    result.push(projectItem);
+                }
+            }
+            return result;
+        }
+    });
+}
+/**
+ *
+ * 副作用函数
+ * @param config
+ * @param modelKey
+ * @param key
+ * @param file
+ */
+const setProject = (config, modelKey, key, file) => {
+    const currentModel = setModel(config, modelKey);
+    const projectItem = {
+        key,
+        modelKey,
+        ...require(file),
+    };
+    currentModel.project[key] = projectItem;
+};
+/**
+ *
+ * 副作用函数
+ * @param config
+ * @param key
+ * @param filePath
+ */
+const setModel = (config, key, filePath) => {
+    let modelItem = config.find((i) => i.model.key === key);
+    // 初始化model数据
+    if (!modelItem) {
+        const newModel = {
+            model: { key },
+            project: { key },
+        };
+        config.push(newModel);
+        modelItem = newModel;
+    }
+    if (filePath) {
+        modelItem.model = { ...require(filePath), key };
+    }
+    return modelItem;
+};
+export default modelLoader;

package/esm/packages/core/loader/router-schema.d.ts

@@ -0,0 +1,19 @@
+import { KoaApp } from '../types';
+/**
+ *
+ *  router-schema loader 只处理一级
+ *
+ * @param app
+ *
+ * xx/app/router-schema/**.js
+ *
+ * 输出：
+ *  app.routerSchema = {
+ *      [api1]: jsonSchema
+ *  }
+ *
+ *
+ */
+declare const _default: (app: KoaApp) => void;
+export default _default;
+//# sourceMappingURL=router-schema.d.ts.map

package/esm/packages/core/loader/router-schema.js

@@ -0,0 +1,33 @@
+import { loadFileFn } from '../../utils/loadFile';
+import { resolve } from '../../utils/path';
+import { getAppPaths } from '../paths';
+/**
+ *
+ *  router-schema loader 只处理一级
+ *
+ * @param app
+ *
+ * xx/app/router-schema/**.js
+ *
+ * 输出：
+ *  app.routerSchema = {
+ *      [api1]: jsonSchema
+ *  }
+ *
+ *
+ */
+export default (app) => {
+    // 加载 app/router-schema/**.js
+    let routerSchema = {};
+    getAppPaths(app).forEach((currentPath) => {
+        loadFileFn(currentPath, 'router-schema', {
+            preProcessingFileCallback(file) {
+                routerSchema = {
+                    ...routerSchema,
+                    ...require(resolve(file)),
+                };
+            },
+        });
+    });
+    app.routerSchema = routerSchema;
+};

package/esm/packages/core/loader/router.d.ts

@@ -0,0 +1,9 @@
+import { KoaApp } from "../types";
+/**
+ * reouter loader
+ *
+ * 解析 xx/app/router/下的所有文件 加载到 koa-router上
+ */
+declare const _default: (app: KoaApp) => void;
+export default _default;
+//# sourceMappingURL=router.d.ts.map

package/esm/packages/core/loader/router.js

@@ -0,0 +1,57 @@
+import KoaRouter from "koa-router";
+import { loadFileFn } from "../../utils/loadFile";
+import { resolve } from "../../utils/path";
+import { getAppPath, getAppPaths } from "../paths";
+import { runFileFn } from "../../utils/index.js";
+/**
+ * reouter loader
+ *
+ * 解析 xx/app/router/下的所有文件 加载到 koa-router上
+ */
+export default (app) => {
+    // 找到路由文件
+    // 实例化 KoaRouter
+    // 注册所有路由
+    // 路由}
+    const router = new KoaRouter();
+    let routerGuard;
+    try {
+        // 在app目录下寻找
+        const businessPath = getAppPath(app, "business");
+        if (businessPath) {
+            routerGuard = runFileFn(require(resolve(businessPath, "router-guard.js")))(app);
+        }
+    }
+    catch (error) {
+        console.info("-- [router-guard] -- not router-guard.js file");
+    }
+    getAppPaths(app).forEach((currentPath) => {
+        loadFileFn(currentPath, "router", {
+            preProcessingFileCallback: (filePath) => {
+                /**
+                 *  module.export = (app,router) => {
+                 *      router.get('/xxx/xxxx', app.controller)
+                 *  }
+                 */
+                runFileFn(require(resolve(filePath)))(app, router);
+            },
+        });
+    });
+    router.get("(.*)", async (ctx, _next) => {
+        console.info("\x1b[31m%s\x1b[0m", `-- notFound path: ${ctx.path} --`);
+        ctx.status = 302; // 临时重定向
+        const executionResults = routerGuard?.(ctx);
+        if (executionResults) {
+            ctx.redirect(executionResults ?? "/");
+        }
+        else {
+            ctx.redirect(app.options?.homePage ?? "/");
+        }
+        // throw new Error();
+        return;
+        // await next();
+    });
+    app.use(router.routes()); // koa 注入路由 中间件
+    app.use(router.allowedMethods()); // 允许所有请求方式
+    app.currentUseRouter = router;
+};

package/esm/packages/core/loader/service.d.ts

@@ -0,0 +1,18 @@
+import type { KoaApp } from '../types';
+/**
+* 加载 xx/app/service 文件夹下所有文件 可通过'app.service.$｛目录｝.．｝，访问
+*
+例子：
+    app/service
+
+        |-- cuStom-moduLe
+
+        |-- custom-midd Leware.js
+
+    => app.service.customModule. customMiddleware
+ *
+ * @param app
+ */
+declare const _default: (app: KoaApp) => void;
+export default _default;
+//# sourceMappingURL=service.d.ts.map

package/esm/packages/core/loader/service.js

@@ -0,0 +1,28 @@
+import { loadFileFn } from '../../utils/loadFile';
+import { getAppPaths } from '../paths';
+import { runFileFn } from '../../utils/index.js';
+/**
+* 加载 xx/app/service 文件夹下所有文件 可通过'app.service.$｛目录｝.．｝，访问
+*
+例子：
+    app/service
+
+        |-- cuStom-moduLe
+
+        |-- custom-midd Leware.js
+
+    => app.service.customModule. customMiddleware
+ *
+ * @param app
+ */
+export default (app) => {
+    app.service = getAppPaths(app).reduce((preData, currentPath) => ({
+        ...preData,
+        ...loadFileFn(currentPath, 'service', {
+            loadFileCallback: (file) => {
+                const Service = runFileFn(require(file))(app);
+                return new Service();
+            },
+        }),
+    }), {});
+};

package/esm/packages/core/paths.js

@@ -0,0 +1,6 @@
+export function getAppPath(app, type) {
+    return app.paths?.find((p) => p.type === type)?.path;
+}
+export function getAppPaths(app) {
+    return (app.paths ?? []).map((p) => p.path);
+}

package/esm/packages/core/types.d.ts

@@ -0,0 +1,75 @@
+import Koa from "koa";
+import type Router from "koa-router";
+import type { EnvReturn } from "./env";
+import type { AppPathInfo } from "./paths";
+export interface IService {
+    [key: string]: unknown;
+}
+export interface IController {
+    [key: string]: unknown;
+}
+export interface IExtends {
+    [key: string]: unknown;
+}
+export interface IMiddlewares {
+    [key: string]: unknown;
+}
+export declare namespace FrameworkAugment {
+    interface IServiceAugmented {
+    }
+    interface IControllerAugmented {
+    }
+    interface IExtendsAugmented {
+    }
+    interface IMiddlewaresAugmented {
+    }
+    interface AppConfigAugmented {
+    }
+}
+export type ICTX = Parameters<Router.IMiddleware<any, {}>>[0];
+export interface KoaAppExtensions {
+    baseDir: string;
+    frameBaseDir: string;
+    businessPath: string;
+    paths: AppPathInfo[];
+    framePath: string;
+    envs: EnvReturn;
+    config: FrameworkAugment.AppConfigAugmented;
+    extends: FrameworkAugment.IExtendsAugmented;
+    controller: FrameworkAugment.IControllerAugmented;
+    service: FrameworkAugment.IServiceAugmented;
+    middlewares: FrameworkAugment.IMiddlewaresAugmented;
+    model: unknown[];
+    routerSchema: Record<string, unknown>;
+    currentUseRouter: Router;
+    options: AppOptions;
+    logger?: {
+        info: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+        warn: (...args: unknown[]) => void;
+    };
+    [key: string]: unknown;
+}
+export interface AppConfigBase {
+    port?: number;
+    host?: string;
+    env?: string;
+}
+export interface AppConfig extends AppConfigBase {
+    [key: string]: unknown;
+}
+export interface StartOptions {
+    name?: string;
+    homePage?: string;
+    frameBaseDir?: string;
+}
+export interface AppOptions extends StartOptions {
+    overwriteOriginalLogs?: boolean;
+    [key: string]: unknown;
+}
+export type KoaApp = Koa & KoaAppExtensions;
+export type KoaMiddleware = Koa.Middleware;
+export type { EnvType, EnvKeys } from "./env";
+/** 文件处理回调函数 */
+export type ProcessingFileCallbackFN = <T extends Record<string, unknown>>(fileName: string, filePath: string, isDir: boolean, tempData: T) => T | undefined;
+//# sourceMappingURL=types.d.ts.map

package/esm/packages/core/types.js

@@ -0,0 +1 @@
+export {};

package/esm/packages/utils/getAllFilesInFolder.d.ts

@@ -0,0 +1,10 @@
+export interface GetAllFilesInFolder {
+    /**
+     *
+     * @param paths
+     * @returns filesPath
+     */
+    getAllFilesInFolder(...paths: string[]): string[];
+}
+export declare const getAllFilesInFolder: (...paths: string[]) => string[];
+//# sourceMappingURL=getAllFilesInFolder.d.ts.map

package/esm/packages/utils/getAllFilesInFolder.js

@@ -0,0 +1,8 @@
+import { resolve } from "./path";
+import * as glob from "glob";
+export const getAllFilesInFolder = (...paths) => {
+    const filePath = resolve(...paths);
+    const fileList = glob.sync(resolve(filePath, "**", "*.js"));
+    const tFileList = glob.sync(resolve(filePath, "**", "*.ts")).filter(f => f.indexOf('.d.ts') === -1);
+    return [...fileList, ...tFileList];
+};

package/esm/packages/utils/getAllFnReturnValue.js

@@ -0,0 +1,6 @@
+"use strict";
+// export const getAllFnReturnValue =<T>(fnValue: T | Promise<T> ) =>{
+// if(fnValue instanceof Promise){
+//     retu
+// }
+// }

package/esm/packages/utils/index.js

@@ -0,0 +1,4 @@
+export * from "./path";
+export * from "./loadFile";
+export * from "./getAllFilesInFolder";
+export * from "./runFileFn";

package/esm/packages/utils/loadFile.d.ts

@@ -0,0 +1,21 @@
+export type PreProcessingFileCallbackFN = <T extends Record<string, any>>(filePath: string, result: T) => any;
+export type ProcessingFileCallbackFN = <T extends Record<string, any>>(fileName: string, filePath: string, isDir: boolean, tempData: T) => T | undefined;
+export type LoadFileCallbackFN = (filePath: string) => any;
+export interface LoadFileCallbackOptions {
+    loadFileCallback?: LoadFileCallbackFN;
+    processingFileCallback?: ProcessingFileCallbackFN;
+    preProcessingFileCallback?: PreProcessingFileCallbackFN;
+}
+/**
+ *
+ * @param baseDir
+ * @param key
+ * @param callbackOpt
+ */
+declare function loadFileFn<T extends Record<string, unknown>>(baseDir: string, key: string, callbackOpt?: LoadFileCallbackOptions): T;
+export { loadFileFn };
+declare const _default: {
+    loadFileFn: typeof loadFileFn;
+};
+export default _default;
+//# sourceMappingURL=loadFile.d.ts.map

package/esm/packages/utils/loadFile.js

@@ -0,0 +1,63 @@
+import { getAllFilesInFolder } from "./getAllFilesInFolder";
+import { resolve, splicing } from "./path";
+import { sep } from "path";
+/**
+ *
+ * @param baseDir
+ * @param key
+ * @param callbackOpt
+ */
+function loadFileFn(baseDir, key, callbackOpt) {
+    const { loadFileCallback, processingFileCallback, preProcessingFileCallback, } = callbackOpt ?? {};
+    if (!key ||
+        !(loadFileCallback || processingFileCallback || preProcessingFileCallback)) {
+        throw Error(!key ? "key is request" : "callbackOpt is request");
+    }
+    const { _processingFileCallback, _preProcessingFileCallback } = {
+        _processingFileCallback: processingFileCallback
+            ? processingFileCallback
+            : (fileName, filePath, isDir, tempData) => {
+                if (!isDir) {
+                    // 最后一级
+                    const fileContent = loadFileCallback(filePath);
+                    if (fileContent)
+                        tempData[fileName] = fileContent;
+                    return undefined;
+                }
+                else {
+                    if (tempData[fileName]) {
+                        tempData[fileName] = {};
+                    }
+                    return tempData[fileName];
+                }
+            },
+        _preProcessingFileCallback: preProcessingFileCallback
+            ? preProcessingFileCallback
+            : (name, result) => {
+                const searchString = splicing(key, { position: "after" });
+                const file = name;
+                name = name.substring(name.lastIndexOf(searchString) + searchString.length, name.lastIndexOf("."));
+                //  -_ 转为驼峰
+                name = name.replace(/[_-].{1}/gi, (key) => key[1].toUpperCase());
+                let tempData = result;
+                const names = name.split(sep);
+                for (let index = 0; index < names.length; index++) {
+                    const tName = names[index];
+                    const tempResult = _processingFileCallback(tName, file, index !== names.length - 1, tempData);
+                    if (tempResult) {
+                        tempData = tempResult;
+                    }
+                }
+                return result;
+            },
+    };
+    const fileList = getAllFilesInFolder(baseDir, key);
+    let result = {};
+    fileList.forEach((file) => {
+        // 提取文件名称
+        result = _preProcessingFileCallback(resolve(file), result);
+    });
+    return result;
+}
+export { loadFileFn };
+export default { loadFileFn };

package/esm/packages/utils/path.d.ts

@@ -0,0 +1,25 @@
+export interface SplicingOptions {
+    /**
+     * @default '/''
+     */
+    symbol?: string;
+    /**
+     * @default before
+     */
+    position?: "after" | "before";
+}
+/**
+ *  splicing('path') : /path
+ */
+export declare function splicing(str: string, opt?: SplicingOptions): string;
+/**
+ *
+ * @param paths
+ * @description input [a,b,c] -> out a/b/c
+ *
+ * window: input [a,b,c] -> out a\b\c
+ *
+ * 拼接路径
+ */
+export declare function resolve(...paths: string[]): string;
+//# sourceMappingURL=path.d.ts.map

package/esm/packages/utils/path.js

@@ -0,0 +1,27 @@
+import * as path from "path";
+import { sep } from "path";
+/**
+ *  splicing('path') : /path
+ */
+export function splicing(str, opt) {
+    const { symbol, position } = opt ?? {
+        symbol: sep,
+        position: "before",
+    };
+    // before <- symbol + str
+    // after -> str + symbol
+    return [str, symbol][position === "before" ? "reduceRight" : "reduce"]((o, c) => o + c, "");
+}
+/**
+ *
+ * @param paths
+ * @description input [a,b,c] -> out a/b/c
+ *
+ * window: input [a,b,c] -> out a\b\c
+ *
+ * 拼接路径
+ */
+export function resolve(...paths) {
+    const [basePath, ...otherPath] = paths;
+    return path.resolve(basePath, otherPath.length ? "." + splicing(otherPath.join(sep)) : "");
+}

package/esm/packages/utils/runFileFn.js

@@ -0,0 +1 @@
+export const runFileFn = (fn) => typeof fn === "function" ? fn : fn.default;

package/esm/typings/type.d.ts

@@ -0,0 +1,5 @@
+export type MOmit<T, K extends keyof T> = Omit<T, K>;
+export type UnionToTuple<T> = [
+    T
+] extends [never] ? [] : ((t: T) => T) extends ((t: infer U) => infer U) ? [...UnionToTuple<Exclude<T, U>>, U] : never;
+//# sourceMappingURL=type.d.ts.map

package/esm/typings/type.js

@@ -0,0 +1 @@
+export {};

package/fe/frontend/main.js

@@ -0,0 +1,6 @@
+import { createRoot } from "react-dom/client";
+export const initApp = (rootComponent) => {
+    const root = createRoot(document.getElementById("#root"));
+    // 挂在 根节点
+    root.render(rootComponent);
+};

package/fe/packages/ui/react/assets/table/no-result.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="120" height="120" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+  <rect x="3" y="3" width="18" height="18" rx="2" ry="2"/>
+  <line x1="3" y1="9" x2="21" y2="9"/>
+  <line x1="9" y1="21" x2="9" y2="9"/>
+</svg>

package/{packages → fe/packages}/ui/react/components/Button/Button.d.ts

@@ -2,12 +2,36 @@ import type { ButtonHTMLAttributes, ReactNode } from 'react';
 export type ButtonVariant = 'default' | 'primary' | 'text' | 'link';
 export type ButtonSize = 'sm' | 'md' | 'lg';
 export interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * 按钮变体
+     * @default 'default'
+     */
     variant?: ButtonVariant;
+    /**
+     * 按钮尺寸
+     * @default 'md'
+     */
     size?: ButtonSize;
+    /**
+     * 是否显示加载状态
+     */
     loading?: boolean;
+    /**
+     * 左侧图标
+     */
     leftIcon?: ReactNode;
+    /**
+     * 右侧图标
+     */
     rightIcon?: ReactNode;
+    /**
+     * 是否去除下划线（仅对 variant="link" 有效）
+     * @default false
+     */
     noUnderline?: boolean;
+    /**
+     * 作为子元素，用于更灵活的布局
+     */
     children?: ReactNode;
 }
 declare const Button: import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLButtonElement>>;