@cc-component/cc-ex-component 1.0.0

package/.cc-ex-component.md

@@ -0,0 +1,12 @@
+# 系统组件添加常用扩展方法
+
+## 前置条件
+[游戏引擎](https://www.cocos.com/en/creator-download)
+[开发框架](https://github.com/a1076559139/cocos-creator-frame-3d)
+
+## 使用案例
+```TS
+import {} from 'db://pkg/@gamex/cc-ex-component';
+
+...
+```

package/assets/BaseEx.ts

@@ -0,0 +1,636 @@
+import { sp } from "cc";
+import { Component } from "cc";
+import { director } from "cc";
+import { UITransform } from "cc";
+import { Tween, Node } from 'cc';
+import { TweenManager } from "./ExTween";
+import { Slider } from "cc";
+import { ProgressBar, tween, Sprite, view, v3, Button, Label, Animation } from "cc";
+import { Color } from "cc";
+
+declare global {
+    interface String {
+        toMap<K, V>(): Map<K, V>;
+        /**转数组 */
+        toArray<T>(): T[];
+        /**对象 */
+        toObj<T>(): T;
+        /**是JSON */
+        isJSON(): boolean;
+        toBool(): boolean;
+        toNumber(): number;
+        /**添加颜色-富文本 */
+        addColor(colorHex: string): string
+        /**添加颜色 -富文本*/
+        addSize(font: number): string
+    }
+    interface Any {
+        toMap<K, V>(): Map<K, V>;
+        /**对象转map */
+        toMapObj<K, V>(): Map<K, V>;
+    }
+    interface Number {
+        toDay(): { days: number, hours: number, minutes: number, seconds: number };
+    }
+
+    interface Map<K, V> {
+        toObject(): Object;
+    }
+
+    interface Array<T> {
+        first(): T;
+        last(): T;
+        /**
+         * 将一维数组按指定大小分组成二维数组
+         * @param arr 原始一维数组
+         * @param chunkSize 每组的元素数量
+         * @returns 分组后的二维数组
+         */
+        chunkArray(chunkSize: number): T[][];
+
+    }
+}
+interface Window {
+    /**抖音添加到桌面按钮 */
+    tt_button: boolean;
+    /**抖音订阅 */
+    tt_button_ding_yue: boolean;
+    /**抖音订阅视频流 */
+    tt_button_ding_yue_feed: boolean;
+
+    /**微信订阅 */
+    wx_button_ding_yue: boolean;
+
+}
+
+
+
+// 扩展 Node 接口，声明自定义属性
+declare module 'cc' {
+    interface window {
+
+    }
+    interface Asset {
+        /**资源路径 */
+        asset_path: string;
+    }
+
+    interface Node {
+        asset_path: string;
+        /**暂停所有spine动画 */
+        pauseSpines(): void;
+        resumeSpines(): void;
+        //暂停所有schedule
+        pauseSchedule(): void;
+        resumeSchedule(): void;
+
+        /**暂停所有的spine 和 tween 和schedule
+         * key 是指定twenn的分组key,不传参则 不暂停tween，使用TweenGame 收集tween 
+         */
+        pauseAll(key?: string, speed?: number): void;
+        resumeAll(key?: string, speed?: number): void;
+        /**置灰节点 */
+        interactableColor(enable: boolean, is_anim?: boolean);
+        /**原始颜色--私有 */
+        original_color: Color;
+        /**原始颜色进度--私有 */
+        original_pro: number;
+    }
+
+    interface UITransform {
+        /**在盒子内或者盒子外
+         * box2- 目标盒子
+         * inBox-true:盒子内---false:盒子外
+         */
+        inBox(box2: UITransform, inBox: boolean): boolean;
+        getBoxRect(box: UITransform): { minX: number, maxX: number, minY: number, maxY: number };
+    }
+
+    interface Tween<T> {
+        pause(speed?: number): void;
+        resume(speed?: number): void;
+    }
+
+    interface Slider {
+        addActionSlider(callBack: (slider: Slider) => void): void;
+    }
+
+
+    interface ProgressBar {
+        pro(progress: number, max: number, anim_time?: number);
+    }
+    interface Animation {
+        stopSample();
+    }
+    interface Sprite {
+        fitHeight(): void;
+        /**颜色 */
+        fromHEX(hex: string);
+    }
+    interface Node {
+        enable(enable: boolean, time?: number): void;
+    }
+    interface Label {
+        /**动画播放 */
+        play(param: {
+            startValue: number,
+            endValue: number,
+            duration: number,
+            formatter?: (value: number) => string,
+            onComplete?: () => void
+        })
+        _currentTween;
+        /**颜色 */
+        fromHEX(hex: string);
+    }
+    namespace sp {
+        interface Skeleton {
+            /**颜色 */
+            fromHEX(hex: string);
+        }
+    }
+}
+/**
+ * 扩展 UITransform 接口，添加 isBoxInsideAnotherBox 方法
+ */
+UITransform.prototype.inBox = function (this: UITransform, box2: UITransform, inBox: boolean): boolean {
+    // 获取 box 和 box2 的边界框
+    const rect1 = this.getBoxRect(this)
+    const rect2 = this.getBoxRect(box2)
+    // 检查 box 的四个边是否都在 box2 的边界框内
+    let isInside = false;
+    if (inBox) {
+        isInside =
+            rect1.minX <= rect2.minX && // box 左边界在 box2 左边界右侧
+            rect1.maxX >= rect2.maxX && // box 右边界在 box2 右边界左侧
+            rect1.minY <= rect2.minY && // box 下边界在 box2 下边界上侧
+            rect1.maxY >= rect2.maxY;   // box 上边界在 box2 上边界下侧
+    } else {
+        isInside =
+            rect1.minX > rect2.maxX ||
+            rect1.maxX < rect2.minX || // box 右边界在 box2 右边界左侧
+            rect1.minY > rect2.maxY || // box 下边界在 box2 下边界上侧
+            rect1.maxY < rect2.minY;   // box 上边界在 box2 上边界下侧
+    }
+    return isInside;
+};
+
+UITransform.prototype.getBoxRect = function (box: UITransform) {
+    const min_x = box.node.worldPosition.x - box.width * 0.5
+    const max_x = box.node.worldPosition.x + box.width * 0.5
+    const minY = box.node.worldPosition.y - box.height * 0.5
+    const maxY = box.node.worldPosition.y + box.height * 0.5
+    return { minX: min_x, maxX: max_x, minY: minY, maxY: maxY }
+};
+
+
+
+
+// 备份原始tick方法
+Object.defineProperties(Tween.prototype, {
+    _paused: {
+        value: false,
+        writable: true,
+        configurable: true,
+    },
+    pause: {
+        value: function (this, speed?: number) {
+            if (this._finalAction && typeof this._finalAction['_speed'] !== 'undefined') {
+                this._finalAction['_speed'] = speed ? speed : 0;
+                this._paused = true;
+            }
+            return this;
+        },
+        writable: true,
+        configurable: true,
+    },
+    resume: {
+        value: function (this, speed?: number) {
+            if (this._finalAction && typeof this._finalAction['_speed'] !== 'undefined') {
+                this._finalAction['_speed'] = speed ? speed : 1;;
+                this._paused = false;
+            }
+            return this;
+        },
+        writable: true,
+        configurable: true,
+    },
+    isPaused: {
+        value: function () {
+            return this._paused === true;
+        },
+        writable: false,
+        configurable: true,
+    },
+});
+
+Object.defineProperties(Node.prototype, {
+    pauseAll: {
+        value: function (this: Node, key?: string, speed?: number) {
+            //@ts-ignore
+            const node_list = this.getChildrens();
+            node_list.forEach((node: Node) => {
+                node.components.forEach((component: any) => {
+                    if (component instanceof sp.Skeleton) {
+                        component["old_timeScale"] = component.timeScale;
+                        component.timeScale = speed ? speed : 0;
+                    }
+                    else {
+                        if (speed) {
+                            component["old_timeScale_sched"] = speed;
+                            director.getScheduler().setTimeScale(speed)
+                        } else {
+                            director.getScheduler().pauseTarget(component);
+                        }
+                    }
+                });
+            });
+            //暂停所有的tween
+            if (key) {
+                TweenManager.pause(key, speed)
+            }
+            return this;
+        },
+        writable: true,
+    },
+    resumeAll: {
+        value: function (this: Node, key?: string, speed?: number) {
+            //@ts-ignore
+            const node_list = this.getChildrens();
+            node_list.forEach((node: Node) => {
+                node.components.forEach((component: any) => {
+                    if (component instanceof sp.Skeleton) {
+                        const old_timeScale = component["old_timeScale"];
+                        component.timeScale = old_timeScale !== undefined || old_timeScale !== null ? old_timeScale : speed;
+                        component["old_timeScale"] = null;
+                    } else {
+                        if (speed) {
+                            director.getScheduler().setTimeScale(speed)
+                        } else {
+                            if (component["old_timeScale_sched"]) {
+                                director.getScheduler().setTimeScale(1)
+                                component["old_timeScale_sched"] = null;
+                            };
+                            director.getScheduler().resumeTarget(component);
+                        }
+                    }
+                });
+            });
+            //暂停所有的tween
+            if (key) {
+                TweenManager.resume(key, speed)
+            }
+            return this;
+        },
+        writable: true,
+    },
+    pauseSpines: {
+        value: function (this: Node) {
+            this.getComponentsInChildren(sp.Skeleton).forEach(skel => {
+                skel["old_timeScale"] = skel.timeScale;
+                skel.timeScale = 0;
+            });
+            return this;
+        },
+        writable: true,
+    },
+    resumeSpines: {
+        value: function (this: Node) {
+            this.getComponentsInChildren(sp.Skeleton).forEach(skel => {
+                const old_timeScale = skel["old_timeScale"];
+                skel.timeScale = old_timeScale !== undefined || old_timeScale !== null ? old_timeScale : 1;
+                skel["old_timeScale"] = null
+            });
+            return this;
+        },
+        writable: true,
+    },
+    pauseSchedule: {
+        value: function (this: Node) {
+            //@ts-ignore
+            const node_list = this.getChildrens();
+            node_list.forEach((node: Node) => {
+                node.components.forEach((component: any) => {
+                    director.getScheduler().pauseTarget(component);
+                });
+            });
+            return this;
+        },
+        writable: true,
+    },
+    resumeSchedule: {
+        value: function (this: Node) {
+            //@ts-ignore
+            const node_list = this.getChildrens();
+            node_list.forEach((node: Node) => {
+                director.getScheduler().resumeTargets(node.components as any[]);
+            });
+            return this;
+        },
+        writable: true,
+    },
+    // 私有遍历工具方法
+    getChildrens: {
+        value: function (this: Node): Node[] {
+            const result: Node[] = [];
+            function collect(node: Node) {
+                result.push(node);
+                node.children.forEach(collect);
+            }
+            collect(this);
+            return result;
+        },
+        writable: true,
+    },
+});
+
+
+Object.defineProperties(Slider.prototype, {
+    addActionSlider: {
+        value: function (this: Slider, callBack: (slider: Slider) => void) {
+            this.node.on('slide', callBack, this);
+            return this;
+        },
+        writable: true,
+        configurable: true,
+    }
+});
+
+
+//.
+
+
+// 实现字符串扩展方法
+String.prototype.toMap = function <K, V>(): Map<K, V> {
+    try {
+        // 解析JSON字符串
+        if (!this.isJSON()) {
+            return new Map<K, V>();
+        }
+        const parsedData = JSON.parse(this.toString());
+        const resultMap = new Map<K, V>();
+
+        // 处理数组格式 [{ "103": 4 }, { "104": 5 }]
+        if (Array.isArray(parsedData)) {
+            parsedData.forEach(obj => {
+                if (typeof obj === 'object' && obj !== null) {
+                    Object.entries(obj).forEach(([key, value]) => {
+                        resultMap.set(key as unknown as K, value as unknown as V);
+                    });
+                }
+            });
+        }
+        // 处理对象格式 { "103": 4, "104": 5 }
+        else if (typeof parsedData === 'object' && parsedData !== null) {
+            Object.entries(parsedData).forEach(([key, value]) => {
+                resultMap.set(key as unknown as K, value as unknown as V);
+            });
+        }
+
+        return resultMap;
+    } catch (error) {
+        console.error("JSON解析错误:", error);
+        return new Map<K, V>();
+    }
+};
+
+// 实现字符串扩展方法 toArray
+String.prototype.toArray = function <T>(): T[] {
+    try {
+        // 解析JSON字符串
+        const parsedData = JSON.parse(this.toString());
+        return parsedData;
+    } catch (error) {
+        console.error("JSON解析错误:", error);
+        return [];
+    }
+};
+
+// 实现字符串扩展方法 toObj
+String.prototype.toObj = function <T>(): T {
+    try {
+        // 解析JSON字符串
+        const parsedData = JSON.parse(this.toString());
+        return parsedData;
+    } catch (error) {
+        console.error("JSON解析错误:", error);
+        return {} as T;
+    }
+};
+// 实现字符串扩展方法 isJSON
+String.prototype.isJSON = function (): boolean {
+    const str = this.toString()
+    // 检查是否为字符串类型
+    if (typeof str !== 'string') {
+        return false;
+    }
+
+    // 检查是否为空字符串
+    if (str.trim().length === 0) {
+        return false;
+    }
+
+    try {
+        const parsed = JSON.parse(str);
+        // 确保解析结果是对象或数组（JSON的顶级必须是对象或数组）
+        return (typeof parsed === 'object' && parsed !== null) || Array.isArray(parsed);
+    } catch (e) {
+        return false;
+    }
+};
+
+// 实现字符串扩展方法 toBool
+String.prototype.toBool = function (): boolean {
+    return this.toString().toLowerCase() === 'true';
+};
+
+
+
+// 扩展 Number 原型，添加毫秒转天时分秒的方法
+Number.prototype.toDay = function (): { days: number, hours: number, minutes: number, seconds: number } {
+    let milliseconds = this as number;
+
+    const days = Math.floor(milliseconds / 86400000); // 计算天数
+    milliseconds %= 86400000; // 剩余毫秒
+
+    const hours = Math.floor(milliseconds / 3600000); // 计算小时数
+    milliseconds %= 3600000; // 剩余毫秒
+
+    const minutes = Math.floor(milliseconds / 60000); // 计算分钟数
+    milliseconds %= 60000; // 剩余毫秒
+
+    const seconds = Math.floor(milliseconds / 1000); // 计算秒数
+
+    return { days, hours, minutes, seconds };
+};
+
+ProgressBar.prototype.pro = function (this: ProgressBar, progress: number, max: number, anim_time?: number): void {
+    const com_max_pro = this.totalLength//getComponent(UITransform).width
+    const max_progress = com_max_pro;
+    const s = max_progress / max;
+    const pro = progress * s / max_progress;
+
+    if (anim_time) {
+        tween(this).to(anim_time, {
+            progress: pro
+        }).start();
+
+    } else {
+        this.progress = pro;
+
+    }
+};
+
+Animation.prototype.stopSample = function (this: Animation): void {
+    this.stop();
+    // 停止动画并重置到第一帧
+    const animState = this.getState(this.defaultClip.name);
+    if (animState) {
+        animState.time = 0;
+        animState.sample(); // 强制采样第一帧
+    }
+};
+// 扩展 Sprite 原型，添加 fitHeight 方法
+Sprite.prototype.fitHeight = function (this: Sprite): void {
+    const screen = view.getVisibleSize(); // 获取屏幕可见区域的尺寸
+    const screenHeight = screen.height;
+
+    const uiTransform = this.node.getComponent(UITransform)!; // 获取节点的 UITransform 组件
+    if (!uiTransform) {
+        console.error("当前 Sprite 节点缺少 UITransform 组件");
+        return;
+    }
+
+    const originalSize = uiTransform.contentSize; // 获取图片原始尺寸
+
+    // 计算缩放比例
+    const scaleRatio = screenHeight / originalSize.height;
+
+    // 设置新的尺寸（保持宽高比）
+    uiTransform.setContentSize(originalSize.width * scaleRatio, screenHeight);
+
+    // 如果需要居中对齐，可以调整节点位置
+    this.node.setPosition(v3(0, 0, 0));
+};
+// 扩展 Sprite 原型，添加 fitHeight 方法
+Node.prototype.enable = function (this: Node, enable: boolean, time?: number): void {
+    if (this.isValid) {
+        const btn = this.getComponent(Button);
+        if (btn) {
+            if (time) {
+                btn.interactable = enable;
+                if (!enable) {
+                    setTimeout(() => {
+                        if (btn && btn.isValid)
+                            btn.interactable = true;
+                    }, time)
+                }
+            } else {
+                btn.interactable = enable;
+            }
+        }
+    }
+};
+
+Map.prototype.toObject = function (): Object {
+    const obj = {};
+    for (const [key, value] of this.entries()) {
+        obj[key] = value;
+    }
+    return obj;
+};
+
+Label.prototype.play = function (
+    this: Label,
+    param: {
+        startValue: number,
+        endValue: number,
+        duration: number,
+        formatter: (value: number) => string,
+        onComplete?: () => void
+    }
+): void {
+    const label = this;
+
+    // 如果已有动画，先停止
+    if (label._currentTween) {
+        label._currentTween.stop();
+    }
+    // 使用 tween 动画
+    const obj: { value: number } = { value: param.startValue }
+    label._currentTween = tween(obj)
+        .to(
+            param.duration,
+            { value: param.endValue },
+            {
+                onUpdate(target: { value: number }) {
+                    label.string = param.formatter(target.value);
+                },
+                easing: "quadOut",
+            }
+        )
+        .call(() => {
+            param.onComplete?.();
+            label._currentTween = null; // 清空引用
+        })
+        .start();
+};
+
+
+
+Object.defineProperty(Array.prototype, 'first', {
+    value: function () {
+        return this[0];
+    },
+    enumerable: false,
+    writable: false,
+    configurable: true
+});
+Object.defineProperty(Array.prototype, 'last', {
+    value: function () {
+        return this[this.length - 1];
+    },
+    enumerable: false,
+    writable: false,
+    configurable: true
+});
+Object.defineProperty(Array.prototype, 'chunkArray', {
+    value: function <T>(this: T[], chunkSize: number): T[][] {
+        const arr = this;
+        const result: T[][] = [];
+        for (let i = 0; i < arr.length; i += chunkSize) {
+            result.push(arr.slice(i, i + chunkSize));
+        }
+        return result;
+    },
+    enumerable: false,
+    writable: false,
+    configurable: true
+});
+
+
+// 实现字符串扩展方法
+String.prototype.toNumber = function <K, V>(): number {
+    return Number(this) ?? 0;
+};
+// 实现字符串扩展方法
+String.prototype.addColor = function (colorHex: string): string {
+    return `<color=${colorHex}>${this}</color>`
+};
+// 实现字符串扩展方法
+String.prototype.addSize = function (font: number): string {
+    return `<size=${font}>${this}</size>`
+};
+Label.prototype.fromHEX = function (this: Label, hex: string): void {
+    const label = this;
+    label.color = (new Color()).fromHEX(hex)
+};
+Sprite.prototype.fromHEX = function (this: Sprite, hex: string): void {
+    const label = this;
+    label.color = (new Color()).fromHEX(hex)
+};
+sp.Skeleton.prototype.fromHEX = function (this: sp.Skeleton, hex: string): void {
+    const label = this;
+    label.color = (new Color()).fromHEX(hex)
+};
+export { };

package/assets/BaseEx.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.23",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "2114b6dd-3bd1-43c6-8bbd-7de5eee953b2",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/ExTween.ts

@@ -0,0 +1,146 @@
+import { __private, ITweenOption } from 'cc';
+import { tween, Tween } from 'cc';
+import { _decorator, Node } from 'cc';
+import { GameConfig } from 'db://assets/start/Interface/GameConfig';
+const { ccclass } = _decorator;
+
+@ccclass('ExTween')
+export class ExTween extends Tween<any> {
+    key: string;
+    constructor(target: Node, key: string) {
+        super(target);
+        this.key = key;
+        TweenManager.addTween(key, this);
+    }
+    to(duration: number, props: __private._cocos_tween_tween__ConstructorType<any>, opts?: ITweenOption): Tween<any> {
+        super.to(duration, props, opts);
+        return this
+    }
+    by(duration: number, props: __private._cocos_tween_tween__ConstructorType<any>, opts?: ITweenOption): Tween<any> {
+        super.by(duration, props, opts);
+        return this
+    }
+    union(): Tween<any> {
+        return super.union()
+    }
+
+    call(callback: Function): Tween<any> {
+        const wrappedCallback = () => {
+            // 调用用户回调
+            callback();
+        };
+        super.call(wrappedCallback);
+        return this;
+    }
+    stop(): Tween<any> {
+        super.stop();
+        return this;
+    }
+    start(): Tween<any> {
+        this.call(() => {
+            //  console.log(`全部结束 ${this.key}`);
+            TweenManager.removeTween(this.key, this);
+        });
+        super.start();
+        this.pause(GameConfig.gameSpeed)//设置速度
+
+        return this
+    }
+
+}
+
+export class TweenManager {
+    // 字典，key对应一个数组，保存属于该key的所有ExTween实例
+    private static _tweensDict: Record<string, ExTween[]> = {};
+
+    /**
+     * 添加一个 tween 到对应 key 的数组中
+     * @param key 分组key，比如 node 名称或者自定义字符串
+     * @param tw Tween 实例
+     */
+    static addTween(key: string, tw: ExTween) {
+        if (!this._tweensDict[key]) {
+            this._tweensDict[key] = [];
+        }
+        this._tweensDict[key].push(tw);
+    }
+
+    /**
+     * 获取指定 key 下的所有 tween
+     * @param key 分组key
+     * @returns Tween数组，如果不存在则返回空数组
+     */
+    static getTweensByKey(key: string): ExTween[] {
+        return this._tweensDict[key] || [];
+    }
+
+    /**
+     * 从指定 key 的数组中移除某个 tween 实例
+     * @param key 分组key
+     * @param tw 要移除的 Tween 实例
+     */
+    static removeTween(key: string, tw: ExTween) {
+        const arr = this._tweensDict[key];
+        if (!arr) return;
+        const index = arr.indexOf(tw);
+        if (index !== -1) {
+            arr.splice(index, 1);
+            // 如果移除后该key对应的数组为空，则删除该key
+            if (arr.length === 0) {
+                delete this._tweensDict[key];
+            }
+        }
+    }
+
+    /**
+     * 停止并移除指定 key 下的所有 tween
+     * @param key 分组key
+     */
+    static stopAllByKey(key: string) {
+        const arr = this._tweensDict[key];
+        if (!arr) return;
+        // 停止所有 tween
+        arr.forEach(tw => tw.stop());
+        // 删除该key对应的数组
+        delete this._tweensDict[key];
+    }
+
+    /**
+     * 【新增】停止并移除指定 key 下的所有 tween（同 stopAllByKey）
+     * 逻辑上也可以叫移除所有，停掉后数组清空并删除key
+     * @param key 分组key
+     */
+    static removeAllByKey(key: string) {
+        const arr = this._tweensDict[key];
+        if (!arr) return;
+        // 逐个停止 tween
+        arr.forEach(tw => tw?.stop());
+        // 清空数组长度
+        arr.length = 0;
+        // 删除key对应的数组引用
+        delete this._tweensDict[key];
+    }
+
+    /**
+     * 停止并移除所有已管理的 tween（遍历字典所有key）
+     */
+    static stopAll() {
+        for (const key in this._tweensDict) {
+            this._tweensDict[key].forEach(tw => tw.stop());
+        }
+        this._tweensDict = {};
+    }
+
+    static pause(key: string, speed?: number) {
+        this._tweensDict[key]?.forEach(tw => tw?.pause(speed));
+    }
+    static resume(key: string, speed?: number) {
+        this._tweensDict[key]?.forEach(tw => tw?.resume(speed));
+    }
+}
+
+// 创建 tween 时传入 key，比如 node.name 或者你想的其他分类key
+export function TweenGame(node: any, key: string): ExTween {
+    const tw = new ExTween(node, key);
+    return tw
+}

package/assets/ExTween.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.23",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "24e7cfb8-9b50-466d-98d7-937a8be553c6",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "1.2.0",
+  "importer": "directory",
+  "imported": true,
+  "uuid": "eaf5bea5-6b92-4d35-92ff-dd5a4164e092",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/index.ts

@@ -0,0 +1,2 @@
+// 负责导出assets下的模块，如: export { default } from './assets/xxx.ts'
+export { } from './assets/BaseEx';

package/index.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.23",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "0649bb79-0fd1-45d2-ba6b-56ece4f941f0",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+    "name": "@cc-component/cc-ex-component",
+    "version": "1.0.0",
+    "engine": ">=3.8.0",
+    "description": "系统组件添加常用扩展方法",
+    "main": "index.ts",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://gitee.com/cocos2d-zp/cococs-creator-frame-3d"
+    },
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org"
+    },
+    "license": "MIT"
+}

package/package.json.meta

@@ -0,0 +1,11 @@
+{
+  "ver": "2.0.0",
+  "importer": "json",
+  "imported": true,
+  "uuid": "cdfc94f9-bb5a-4211-ab24-e5799614c31a",
+  "files": [
+    ".json"
+  ],
+  "subMetas": {},
+  "userData": {}
+}