@gadmin2n/schematics 0.0.55

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/hooks/useListPageState.ts

@@ -0,0 +1,303 @@
+import { useMemo, useCallback } from "react";
+import { useLocation } from "react-router-dom";
+import {
+  CrudFilters,
+  HttpError,
+  parseTableParams,
+  unionFilters,
+  useExport,
+  useTranslate,
+  useUpdate,
+  useApiUrl,
+  BaseRecord,
+} from "@refinedev/core";
+import { useTable, useImport } from "@refinedev/antd";
+import dayjs from "dayjs";
+import { useBatchOperations } from "./useBatchOperations";
+import { ListPageConfig, UseListPageStateResult } from "./types";
+import {
+  ModelType,
+  FieldDataType,
+  produceModel,
+  getColumns,
+  tableSearchBar,
+} from "@gadmin2/react-common";
+
+export interface UseListPageStateConfig {
+  resourceName: string;
+  /** Raw model from generated code */
+  rawModel: ModelType;
+  /** Model customizations */
+  modelOverrides?: Record<string, Partial<FieldDataType>>;
+  tableConfig: ListPageConfig["tableConfig"];
+  prismaSelect?: any;
+  modelsMap: ListPageConfig["modelsMap"];
+  modelsEnum: ListPageConfig["modelsEnum"];
+  /** API URL, will use useApiUrl() if not provided */
+  apiUrl?: string;
+  /** Function to get request headers for batch operations */
+  requestHeaders?: () => Record<string, string>;
+  /** Hook to get relation select props */
+  useRelation?: (modelsMap: ListPageConfig["modelsMap"]) => Record<string, any>;
+  /** Search fields configuration */
+  searchFields?: {
+    keyword?: string;
+    dateRange?: string[];
+  };
+}
+
+/**
+ * Comprehensive hook that provides all state and handlers for a list page
+ */
+export function useListPageState<T extends BaseRecord = any>({
+  resourceName,
+  rawModel,
+  modelOverrides = {},
+  tableConfig,
+  prismaSelect,
+  modelsMap,
+  modelsEnum,
+  apiUrl: customApiUrl,
+  requestHeaders,
+  useRelation,
+  searchFields = { keyword: "q", dateRange: ["createdAt"] },
+}: UseListPageStateConfig): UseListPageStateResult {
+  const t = useTranslate();
+  const defaultApiUrl = useApiUrl();
+  const apiUrl = customApiUrl || defaultApiUrl;
+  const { search } = useLocation();
+
+  // Parse initial filters and sorters from URL
+  const { parsedSorter, parsedFilters } = parseTableParams(search);
+
+  // Create model with customizations
+  const [columns, model] = useMemo(() => {
+    const model: ModelType = produceModel(rawModel, modelOverrides);
+    const modelName =
+      resourceName.charAt(0).toUpperCase() + resourceName.slice(1);
+
+    const columns = getColumns(modelName, tableConfig.fields, {
+      ...modelsMap,
+      [modelName]: { model, meta: modelsMap[modelName]?.meta },
+    });
+
+    return [columns, model] as const;
+  }, [rawModel, modelOverrides, tableConfig.fields, modelsMap, resourceName]);
+
+  // Get search bar configuration
+  const { placeholder: searchPlaceholder, getSearchFilters } = useMemo(
+    () => tableSearchBar(tableConfig.toolbar.searchBar, rawModel),
+    [tableConfig.toolbar.searchBar, rawModel]
+  );
+
+  // Table hook
+  const {
+    tableProps,
+    sorters: sorter,
+    filters,
+    setCurrent,
+    setFilters,
+    searchFormProps,
+    tableQueryResult,
+  } = useTable<T, HttpError, T & { q: string }>({
+    meta: {
+      transformQFn: getSearchFilters,
+      select: prismaSelect,
+    },
+    filters: {
+      initial: parsedFilters,
+      defaultBehavior: "merge",
+    },
+    sorters: {
+      initial: parsedSorter,
+    },
+  });
+
+  // Initialize search form values
+  const keywordField = searchFields.keyword || "q";
+  const dateRangeField = searchFields.dateRange?.[0] || "createdAt";
+
+  searchFormProps.initialValues = useMemo(
+    () => ({
+      [keywordField]: parsedFilters.find((f: any) => f.field === keywordField)
+        ?.value,
+      [dateRangeField]: parsedFilters.find(
+        (f: any) => f.field === dateRangeField && f.operator === "gte"
+      )
+        ? [
+            dayjs(
+              parsedFilters.find(
+                (f: any) => f.field === dateRangeField && f.operator === "gte"
+              )?.value
+            ),
+            dayjs(
+              parsedFilters.find(
+                (f: any) => f.field === dateRangeField && f.operator === "lte"
+              )?.value
+            ),
+          ]
+        : [undefined, undefined],
+    }),
+    [parsedFilters, keywordField, dateRangeField]
+  );
+
+  // Search form submit handler
+  searchFormProps.onFinish = useCallback(
+    (values: any) => {
+      const fs: CrudFilters = [];
+      const keyword = (values[keywordField] || "").trim();
+      const dateRange = values[dateRangeField];
+
+      if (dateRange && dateRange[0]) {
+        fs.push(
+          {
+            field: dateRangeField,
+            operator: "gte",
+            value: dateRange[0]?.toISOString?.(),
+          },
+          {
+            field: dateRangeField,
+            operator: "lte",
+            value: dateRange[1]?.toISOString?.(),
+          }
+        );
+      }
+
+      if (keyword) {
+        fs.push({
+          field: keywordField,
+          operator: "eq",
+          value: keyword,
+        });
+      }
+
+      setCurrent(1);
+      setFilters((prevFilters) =>
+        unionFilters(
+          [],
+          fs,
+          prevFilters.filter(
+            (item: any) => ![keywordField, dateRangeField].includes(item.field)
+          )
+        )
+      );
+    },
+    [keywordField, dateRangeField, setCurrent, setFilters]
+  );
+
+  // Batch operations
+  const batchOps = useBatchOperations({
+    resourceName,
+    apiUrl,
+    requestHeaders,
+    onSuccess: () => tableQueryResult.refetch(),
+    t,
+  });
+
+  // Export hooks
+  const { triggerExport: triggerExportAll, isLoading: exportLoading } =
+    useExport<T>({
+      maxItemCount: 200,
+      pageSize: 100,
+    });
+
+  const {
+    triggerExport: triggerExportSelected,
+    isLoading: exportSelectedLoading,
+  } = useExport<T>({
+    pageSize: 100,
+    meta: {
+      where: { id: { in: batchOps.selectedRowKeys.map(Number) } },
+    },
+  });
+
+  // Import hook
+  const importProps = useImport<T>({
+    mapData: (item: any) => ({ ...item }),
+    batchSize: 1,
+  });
+
+  // Row update
+  const { mutate: updateRow, isLoading: isUpdateRowLoading } = useUpdate();
+  const updateRowData = useCallback(
+    (id: number, values: any) => {
+      updateRow({
+        resource: resourceName,
+        id,
+        values,
+      });
+    },
+    [updateRow, resourceName]
+  );
+
+  // Get relation select props
+  const relationResult = useRelation?.(modelsMap) || {};
+  const relationSelectProps = useMemo(() => relationResult, [relationResult]);
+
+  // Build context
+  const context = useMemo(
+    () => ({
+      resourceName,
+      t,
+      model,
+      modelsMap,
+      modelsEnum,
+      tableConfig,
+      apiUrl,
+      relationSelectProps,
+      searchPlaceholder,
+    }),
+    [
+      resourceName,
+      t,
+      model,
+      modelsMap,
+      modelsEnum,
+      tableConfig,
+      apiUrl,
+      relationSelectProps,
+      searchPlaceholder,
+    ]
+  );
+
+  return {
+    // Table related
+    tableProps,
+    columns,
+    model,
+    sorter,
+    filters,
+
+    // Search related
+    searchFormProps,
+
+    // Selection related
+    selectedRowKeys: batchOps.selectedRowKeys,
+    setSelectedRowKeys: batchOps.setSelectedRowKeys,
+    rowSelection: batchOps.rowSelection,
+    hasSelected: batchOps.hasSelected,
+
+    // Batch operations
+    updateSelectedItems: batchOps.updateSelectedItems,
+    deleteSelectedItems: batchOps.deleteSelectedItems,
+    updateManyIsLoading: batchOps.updateManyIsLoading,
+    deleteManyIsLoading: batchOps.deleteManyIsLoading,
+
+    // Export/Import
+    triggerExportAll,
+    triggerExportSelected,
+    exportLoading,
+    exportSelectedLoading,
+    importProps,
+
+    // Row operations
+    updateRowData,
+    isUpdateRowLoading,
+
+    // Context
+    context,
+
+    // Refetch
+    refetch: tableQueryResult.refetch,
+  };
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/hooks/useRowSelection.ts

@@ -0,0 +1,38 @@
+import { useState, useCallback } from "react";
+
+export interface UseRowSelectionResult {
+  selectedRowKeys: React.Key[];
+  setSelectedRowKeys: React.Dispatch<React.SetStateAction<React.Key[]>>;
+  rowSelection: {
+    selectedRowKeys: React.Key[];
+    onChange: (keys: React.Key[]) => void;
+  };
+  hasSelected: boolean;
+  clearSelection: () => void;
+}
+
+/**
+ * Hook for managing table row selection state
+ */
+export function useRowSelection(): UseRowSelectionResult {
+  const [selectedRowKeys, setSelectedRowKeys] = useState<React.Key[]>([]);
+
+  const onSelectChange = useCallback((keys: React.Key[]) => {
+    setSelectedRowKeys(keys);
+  }, []);
+
+  const clearSelection = useCallback(() => {
+    setSelectedRowKeys([]);
+  }, []);
+
+  return {
+    selectedRowKeys,
+    setSelectedRowKeys,
+    rowSelection: {
+      selectedRowKeys,
+      onChange: onSelectChange,
+    },
+    hasSelected: selectedRowKeys.length > 0,
+    clearSelection,
+  };
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/i18n.ts

@@ -0,0 +1,19 @@
+import i18n from "i18next";
+import { initReactI18next } from "react-i18next";
+import Backend from "i18next-xhr-backend";
+import detector from "i18next-browser-languagedetector";
+
+i18n
+  .use(Backend)
+  .use(detector)
+  .use(initReactI18next)
+  .init({
+    supportedLngs: ["en", "zh_CN"],
+    backend: {
+      loadPath: "/locales/{{lng}}/{{ns}}.json",
+    },
+    defaultNS: "common",
+    fallbackLng: ["en", "zh_CN"],
+  });
+
+export default i18n;

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/index.tsx

@@ -0,0 +1,28 @@
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+
+import reportWebVitals from './reportWebVitals';
+import App from './App';
+import './i18n';
+
+import { checkLogin, login } from './helpers/login';
+
+if (!checkLogin()) {
+  login();
+} else {
+  const container = document.getElementById('root') as HTMLElement;
+  const root = createRoot(container);
+
+  root.render(
+    <React.StrictMode>
+      <React.Suspense fallback='loading'>
+        <App />
+      </React.Suspense>
+    </React.StrictMode>
+  );
+}
+
+// If you want to start measuring performance in your app, pass a function
+// to log results (for example: reportWebVitals(console.log))
+// or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
+reportWebVitals();

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/meta.json

@@ -0,0 +1,4 @@
+{
+  "name": "iegg-spider-config",
+  "plugins": []
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/react-app-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="react-scripts" />

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/reportWebVitals.ts

@@ -0,0 +1,15 @@
+import { ReportHandler } from "web-vitals";
+
+const reportWebVitals = (onPerfEntry?: ReportHandler) => {
+  if (onPerfEntry && onPerfEntry instanceof Function) {
+    import("web-vitals").then(({ getCLS, getFID, getFCP, getLCP, getTTFB }) => {
+      getCLS(onPerfEntry);
+      getFID(onPerfEntry);
+      getFCP(onPerfEntry);
+      getLCP(onPerfEntry);
+      getTTFB(onPerfEntry);
+    });
+  }
+};
+
+export default reportWebVitals;

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/setupTests.ts

@@ -0,0 +1,5 @@
+// jest-dom adds custom jest matchers for asserting on DOM nodes.
+// allows you to do things like:
+// expect(element).toHaveTextContent(/react/i)
+// learn more: https://github.com/testing-library/jest-dom
+import "@testing-library/jest-dom";

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/styles/antd.less

@@ -0,0 +1,79 @@
+@import "~antd/lib/style/themes/default.less";
+@import "~antd/dist/antd.less";
+
+// There are some major variables below,
+// all less variables could be found in
+// https://github.com/ant-design/ant-design/blob/master/components/style/themes/default.less
+
+@import url("https://fonts.googleapis.com/css2?family=Montserrat:wght@100;200;300;400;500;600;700;800;900&display=swap");
+
+// font
+@font-family: "Montserrat", -apple-system, BlinkMacSystemFont, "Segoe UI",
+  Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji",
+  "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+
+// base variables
+@border-radius-base: 6px;
+
+// colors
+@primary-color: #67be23;
+@error-color: #fa541c;
+@text-color: #626262;
+
+// sider
+@layout-sider-background: #2a132e;
+@menu-bg: transparent;
+@menu-item-color: #fff;
+@menu-highlight-color: #fff;
+@menu-inline-submenu-bg: transparent;
+@menu-item-active-bg: transparent;
+@menu-item-active-border-width: 0px;
+@layout-trigger-background: rgba(0, 0, 0, 0.5);
+
+//form
+@label-color: @text-color;
+
+.ant-menu-inline,
+.ant-menu-vertical,
+.ant-menu-vertical-left {
+  border-right: 0px;
+}
+
+.ant-form-item-label > label {
+  font-weight: bold;
+}
+
+.ant-page-header {
+  border-radius: @border-radius-base;
+}
+.ant-menu-submenu-popup > .ant-menu {
+  background-color: #2a132e;
+}
+.ant-menu-tree-arrow {
+  position: absolute;
+  top: 50%;
+  right: 16px;
+  width: 10px;
+  color: #fff;
+  transform: translateY(-50%);
+  transition: transform 0.3s cubic-bezier(0.645, 0.045, 0.355, 1);
+}
+.ant-menu-tree-arrow::before,
+.ant-menu-tree-arrow::after {
+  position: absolute;
+  width: 6px;
+  height: 1.5px;
+  background-color: currentcolor;
+  border-radius: 2px;
+  transition: background 0.3s cubic-bezier(0.645, 0.045, 0.355, 1),
+    transform 0.3s cubic-bezier(0.645, 0.045, 0.355, 1),
+    top 0.3s cubic-bezier(0.645, 0.045, 0.355, 1),
+    color 0.3s cubic-bezier(0.645, 0.045, 0.355, 1);
+  content: "";
+}
+.ant-menu-tree-arrow::before {
+  transform: rotate(45deg) translateY(-2.5px);
+}
+.ant-menu-tree-arrow::after {
+  transform: rotate(-45deg) translateY(2.5px);
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/web/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "strictPropertyInitialization": false,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "baseUrl": "src",
+    "paths": {
+      "*": ["./*"]
+    }
+  },
+  "include": ["src"]
+}

package/dist/lib/application/schema.json

@@ -0,0 +1,99 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "SchematicsGadminApplication",
+  "title": "Gadmin Application Options Schema",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name of the application.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the new project?"
+    },
+    "template": {
+      "type": "string",
+      "description": "The template choose (gadmin2-game-angle-demo or customize).",
+      "$default": {
+        "$source": "argv",
+        "index": 1
+      },
+      "x-prompt": "Which template would you like to use?"
+    },
+    "transfer-protocol": {
+      "type": "string",
+      "description": "The type of transfer protocol (Restful or GraphQL).",
+      "$default": {
+        "$source": "argv",
+        "index": 2
+      },
+      "x-prompt": "What transfer protocol would you like to use for the backend?"
+    },
+    "server-framework": {
+      "type": "string",
+      "description": "The server framework (nest or iris).",
+      "$default": {
+        "$source": "argv",
+        "index": 3
+      },
+      "x-prompt": "What server framework would you like to use for the backend?"
+    },
+    "with-web":{
+      "type": "boolean",
+      "description": "Need to generate frontend web pages for manager data.",
+      "$default": {
+        "$source": "argv",
+        "index": 4
+      },
+      "x-prompt": "Do you want to generate frontend web pages for manager data?"
+    },
+    "ui-framework":{
+      "type": "string",
+      "description": "The ui framework (tea or antd).",
+      "$default": {
+        "$source": "argv",
+        "index": 5
+      },
+      "x-prompt": "What type would you like to use for the ui?"
+    },
+    "author": {
+      "type": "string",
+      "description": "Gadmin application author.",
+      "default": ""
+    },
+    "description": {
+      "type": "string",
+      "description": "Gadmin application description.",
+      "default": ""
+    },
+    "directory": {
+      "type": "string",
+      "description": "Gadmin application destination directory."
+    },
+    "strict": {
+      "type": "boolean",
+      "description": "With TypeScript strict mode.",
+      "default": false
+    },
+    "version": {
+      "type": "string",
+      "description": "Gadmin application version.",
+      "default": "0.0.1"
+    },
+    "packageManager": {
+      "type": "string",
+      "description": "Gadmin application package manager."
+    },
+    "dependencies": {
+      "type": "string",
+      "description": "Gadmin application dependencies."
+    },
+    "devDependencies": {
+      "type": "string",
+      "description": "Gadmin application development dependencies."
+    }
+  },
+  "required": ["name"]
+}

package/dist/lib/class/class.factory.d.ts

@@ -0,0 +1,3 @@
+import { Rule } from '@angular-devkit/schematics';
+import { ClassOptions } from './class.schema';
+export declare function main(options: ClassOptions): Rule;

package/dist/lib/class/class.factory.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = void 0;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
+const formatting_1 = require("../../utils/formatting");
+const name_parser_1 = require("../../utils/name.parser");
+const source_root_helpers_1 = require("../../utils/source-root.helpers");
+const defaults_1 = require("../defaults");
+function main(options) {
+    options = transform(options);
+    return (0, schematics_1.chain)([(0, source_root_helpers_1.mergeSourceRoot)(options), (0, schematics_1.mergeWith)(generate(options))]);
+}
+exports.main = main;
+function transform(options) {
+    const target = Object.assign({}, options);
+    if (!target.name) {
+        throw new schematics_1.SchematicsException('Option (name) is required.');
+    }
+    const location = new name_parser_1.NameParser().parse(target);
+    target.name = (0, formatting_1.normalizeToKebabOrSnakeCase)(location.name);
+    if (target.name.includes('.')) {
+        target.className = core_1.strings.classify(target.name).replace('.', '');
+    }
+    else {
+        target.className = target.name;
+    }
+    target.language =
+        target.language !== undefined ? target.language : defaults_1.DEFAULT_LANGUAGE;
+    target.path = (0, formatting_1.normalizeToKebabOrSnakeCase)(location.path);
+    target.path = target.flat
+        ? target.path
+        : (0, core_1.join)(target.path, target.name);
+    return target;
+}
+function generate(options) {
+    return (context) => (0, schematics_1.apply)((0, schematics_1.url)((0, core_1.join)('./files', options.language)), [
+        options.spec ? (0, schematics_1.noop)() : (0, schematics_1.filter)((path) => !path.endsWith('.spec.ts')),
+        (0, schematics_1.template)(Object.assign(Object.assign({}, core_1.strings), options)),
+        (0, schematics_1.move)(options.path),
+    ])(context);
+}

package/dist/lib/class/files/js/__name__.js

@@ -0,0 +1 @@
+export class <%= classify(className) %> {}

package/dist/lib/class/files/js/__name__.spec.js

@@ -0,0 +1,7 @@
+import { <%= classify(className) %> } from './<%= name %>';
+
+describe('<%= classify(className) %>', () => {
+  it('should be defined', () => {
+    expect(new <%= classify(className) %>()).toBeDefined();
+  });
+});