@xfe-repo/web-components 1.0.0

package/README.md

@@ -0,0 +1,3 @@
+# `@xfe-repo/web-components`
+
+web组件库

package/dist/index.css

@@ -0,0 +1,4 @@
+/* src/Loading/index.module.less */
+.index_module_loading {
+  display: block;
+}

package/dist/index.d.mts

@@ -0,0 +1,10 @@
+import { PureComponent } from 'react';
+
+type Props = {
+    loading: boolean;
+};
+declare class Loading extends PureComponent<Props> {
+    render(): JSX.Element | null;
+}
+
+export { Loading };

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { PureComponent } from 'react';
+
+type Props = {
+    loading: boolean;
+};
+declare class Loading extends PureComponent<Props> {
+    render(): JSX.Element | null;
+}
+
+export { Loading };

package/dist/index.js

@@ -0,0 +1,180 @@
+"use strict";
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = function(target, all) {
+    for(var name in all)__defProp(target, name, {
+        get: all[name],
+        enumerable: true
+    });
+};
+var __copyProps = function(to, from, except, desc) {
+    if (from && typeof from === "object" || typeof from === "function") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            var _loop = function() {
+                var key = _step.value;
+                if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: function() {
+                        return from[key];
+                    },
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            };
+            for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return to;
+};
+var __toCommonJS = function(mod) {
+    return __copyProps(__defProp({}, "__esModule", {
+        value: true
+    }), mod);
+};
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+    Loading: function() {
+        return Loading_default;
+    }
+});
+module.exports = __toCommonJS(src_exports);
+// src/Loading/index.tsx
+var import_react = require("react");
+// src/Loading/index.module.less
+var index_module_default = {
+    loading: "index_module_loading"
+};
+// src/Loading/index.tsx
+var import_antd = require("antd");
+var import_jsx_runtime = require("react/jsx-runtime");
+var Loading = /*#__PURE__*/ function(_import_react_PureComponent) {
+    _inherits(Loading, _import_react_PureComponent);
+    var _super = _create_super(Loading);
+    function Loading() {
+        _class_call_check(this, Loading);
+        return _super.apply(this, arguments);
+    }
+    _create_class(Loading, [
+        {
+            key: "render",
+            value: function render() {
+                var loading = this.props.loading;
+                if (!loading) return null;
+                return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+                    className: index_module_default.loading,
+                    children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_antd.Spin, {
+                        spinning: loading,
+                        delay: 200,
+                        className: index_module_default.loading_icon
+                    })
+                });
+            }
+        }
+    ]);
+    return Loading;
+}(import_react.PureComponent);
+var Loading_default = Loading;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+    Loading: Loading
+});

package/dist/index.mjs

@@ -0,0 +1,23 @@
+// src/Loading/index.tsx
+import { PureComponent } from "react";
+
+// src/Loading/index.module.less
+var index_module_default = {
+  loading: "index_module_loading"
+};
+
+// src/Loading/index.tsx
+import { Spin } from "antd";
+import { jsx } from "react/jsx-runtime";
+var Loading = class extends PureComponent {
+  render() {
+    const { loading } = this.props;
+    if (!loading)
+      return null;
+    return /* @__PURE__ */ jsx("div", { className: index_module_default.loading, children: /* @__PURE__ */ jsx(Spin, { spinning: loading, delay: 200, className: index_module_default.loading_icon }) });
+  }
+};
+var Loading_default = Loading;
+export {
+  Loading_default as Loading
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@xfe-repo/web-components",
+  "version": "1.0.0",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@swc/core": "^1.3.100",
+    "@types/react": "^18.2.0",
+    "esbuild-plugin-less": "^1.3.1",
+    "eslint": "^8.53.0",
+    "react": "^18.2.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.2.2",
+    "@xfe-repo/eslint-config": "0.0.0",
+    "@xfe-repo/typescript-config": "0.0.0"
+  },
+  "dependencies": {
+    "antd": "^5.12.1"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint \"src/**/*.ts*\"",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  }
+}