first

uni_modules/kux-dayjs/changelog.md

@@ -0,0 +1,2 @@
+## 1.0.0（2023-12-14）
+初始发布

uni_modules/kux-dayjs/common/calendar.uts

@@ -0,0 +1,297 @@
+/**
+	* 农历1900-2100的润大小信息表
+	* @Array Of Property
+	* @return Hex
+	*/
+/* 源数据说明：
+ *   lunarYear数据来自香港天文台提供的源数据反向推导得出，其中201项数据分别对应1900-2100年。
+ *   示例： 2021年 -- 0x06aa0
+ *   ╭-------┰-------┰-------┰-------┰--------╮
+ *   ┆ 0000  ┆ 0110  ┆ 1010  ┆ 1010  ┆ 0000   ┆
+ *   ┠-------╊-------╊-------╊-------╊--------┨
+ *   ┆ 20-17 ┆ 16-12 ┆ 12-9  ┆  8-5  ┆  4-1   ┆
+ *   ╰-------┸-------┸-------┸-------┸--------╯
+ *   1-4: 表示当年有无闰年，有的话，为闰月的月份，没有的话，为0。 2021年无闰月
+ *   5-16：为除了闰月外的正常月份是大月还是小月，1为30天，0为29天。从1月到12月对应的是第16位到第5位，2021年各月天数[29,30,30,29,30,29,30,29,30,29,30,29]
+ *   17-20： 表示闰月是大月还是小月，仅当存在闰月的情况下有意义。(0/1,即闰大/小月)
+ */
+
+
+const lunarYears = [
+	0x04bd8,
+	// 1901-2000
+	0x04ae0, 0x0a570, 0x054d5, 0x0d260, 0x0d950, 0x16554, 0x056a0, 0x09ad0, 0x055d2, 0x04ae0,
+	0x0a5b6, 0x0a4d0, 0x0d250, 0x1d255, 0x0b540, 0x0d6a0, 0x0ada2, 0x095b0, 0x14977, 0x04970,
+	0x0a4b0, 0x0b4b5, 0x06a50, 0x06d40, 0x1ab54, 0x02b60, 0x09570, 0x052f2, 0x04970, 0x06566,
+	0x0d4a0, 0x0ea50, 0x16a95, 0x05ad0, 0x02b60, 0x186e3, 0x092e0, 0x1c8d7, 0x0c950, 0x0d4a0,
+	0x1d8a6, 0x0b550, 0x056a0, 0x1a5b4, 0x025d0, 0x092d0, 0x0d2b2, 0x0a950, 0x0b557, 0x06ca0,
+	0x0b550, 0x15355, 0x04da0, 0x0a5b0, 0x14573, 0x052b0, 0x0a9a8, 0x0e950, 0x06aa0, 0x0aea6,
+	0x0ab50, 0x04b60, 0x0aae4, 0x0a570, 0x05260, 0x0f263, 0x0d950, 0x05b57, 0x056a0, 0x096d0,
+	0x04dd5, 0x04ad0, 0x0a4d0, 0x0d4d4, 0x0d250, 0x0d558, 0x0b540, 0x0b6a0, 0x195a6, 0x095b0,
+	0x049b0, 0x0a974, 0x0a4b0, 0x0b27a, 0x06a50, 0x06d40, 0x0af46, 0x0ab60, 0x09570, 0x04af5,
+	0x04970, 0x064b0, 0x074a3, 0x0ea50, 0x06b58, 0x05ac0, 0x0ab60, 0x096d5, 0x092e0, 0x0c960,
+	// 2001-2100
+	0x0d954, 0x0d4a0, 0x0da50, 0x07552, 0x056a0, 0x0abb7, 0x025d0, 0x092d0, 0x0cab5, 0x0a950,
+	0x0b4a0, 0x0baa4, 0x0ad50, 0x055d9, 0x04ba0, 0x0a5b0, 0x15176, 0x052b0, 0x0a930, 0x07954,
+	0x06aa0, 0x0ad50, 0x05b52, 0x04b60, 0x0a6e6, 0x0a4e0, 0x0d260, 0x0ea65, 0x0d530, 0x05aa0,
+	0x076a3, 0x096d0, 0x04afb, 0x04ad0, 0x0a4d0, 0x1d0b6, 0x0d250, 0x0d520, 0x0dd45, 0x0b5a0,
+	0x056d0, 0x055b2, 0x049b0, 0x0a577, 0x0a4b0, 0x0aa50, 0x1b255, 0x06d20, 0x0ada0, 0x14b63,
+	0x09370, 0x049f8, 0x04970, 0x064b0, 0x168a6, 0x0ea50, 0x06b20, 0x1a6c4, 0x0aae0, 0x092e0,
+	0x0d2e3, 0x0c960, 0x0d557, 0x0d4a0, 0x0da50, 0x05d55, 0x056a0, 0x0a6d0, 0x055d4, 0x052d0,
+	0x0a9b8, 0x0a950, 0x0b4a0, 0x0b6a6, 0x0ad50, 0x055a0, 0x0aba4, 0x0a5b0, 0x052b0, 0x0b273,
+	0x06930, 0x07337, 0x06aa0, 0x0ad50, 0x14b55, 0x04b60, 0x0a570, 0x054e4, 0x0d160, 0x0e968,
+	0x0d520, 0x0daa0, 0x16aa6, 0x056d0, 0x04ae0, 0x0a9d4, 0x0a2d0, 0x0d150, 0x0f252, 0x0d520
+]
+
+// ['月','正','一','二','三','四','五','六','七','八','九','十','冬','腊'];
+const N_STR_3 = ["\u6708", "\u6b63", "\u4e8c", "\u4e09", "\u56db", "\u4e94", "\u516d", "\u4e03", "\u516b", "\u4e5d", "\u5341", "\u51ac", "\u814a"]
+// ['日','一','二','三','四','五','六','七','八','九','十']
+const N_STR_1 = ["\u65e5", "\u4e00", "\u4e8c", "\u4e09", "\u56db", "\u4e94", "\u516d", "\u4e03", "\u516b", "\u4e5d", "\u5341"]
+
+// ['初','十','廿','卅','闰']
+const N_STR_2 = ["\u521d", "\u5341", "\u5eff", "\u5345", "\u95f0"]
+
+
+export type InfoType = {
+	lunarY : number;
+	lunarM : number;
+	lunarD : number;
+	isLeap : boolean;
+}
+
+export type LunarInfoType = {
+	lYear : number;
+	lMonth : number;
+	lDay : number;
+	IMonthCn : string;
+	IDayCn : string;
+	cYear : number;
+	cMonth : number;
+	cDay : number;
+	gzYear ?: string;
+	gzMonth ?: string;
+	gzDay ?: string;
+	isToday : boolean;
+	isLeap : boolean;
+	nWeek ?: number;
+	ncWeek ?: string;
+	isTerm ?: boolean;
+	Term ?: string;
+	astro ?: string
+}
+
+
+export class Lunar {
+	private lunarYearDaysMap = new Map<number, number>()
+	private lunarMonthDaysMap = new Map<number, number[]>()
+	constructor() { }
+	/**
+		* 传入农历数字月份返回汉语通俗表示法
+		* @param lunar month
+		* @return Cn string
+		* @eg:let cnMonth = calendar.toChinaMonth(12) ;//cnMonth='腊月'
+		*/
+	toChinaMonth(m : number, leap : boolean = false) : string { // 月 => \u6708
+		return leap ? (N_STR_3[4] + N_STR_3[m] + N_STR_3[0]) : (N_STR_3[m] + N_STR_3[0]);
+	}
+
+	/**
+		* 传入农历日期数字返回汉字表示法
+		* @param lunar day
+		* @return Cn string
+		* @eg:let cnDay = calendar.toChinaDay(21) ;//cnMonth='廿一'
+		*/
+	toChinaDay(d : number) : string { // 日 => \u65e5
+		let s : string
+		switch (d) {
+			case 10:
+				s = '\u521d\u5341';
+				break
+			case 20:
+				s = '\u4e8c\u5341';
+				break
+			case 30:
+				s = '\u4e09\u5341';
+				break
+			default:
+				s = N_STR_2[Math.floor(d / 10)]
+				s += N_STR_1[d % 10]
+		}
+		return (s)
+	}
+
+
+	/**
+		* 返回农历y年闰月是哪个月；若y年没有闰月 则返回0
+		* @param lunar Year
+		* @return Number (0-12)
+		* @eg:let leapMonth = calendar.leapMonth(1987) ;//leapMonth=6
+		*/
+	leapMonth(year : number) : number {
+		return lunarYears[year - 1900] & 0xF;
+	}
+
+	/**
+		* 返回农历y年闰月的天数 若该年没有闰月则返回0
+		* @param lunar Year
+		* @return Number (0、29、30)
+		* @eg:let leapMonthDay = calendar.leapDays(1987) ;//leapMonthDay=29
+		*/
+	leapDays(year : number) : number {
+		if (this.leapMonth(year) > 0) {
+			return (lunarYears[year - 1900] & 0x10000) != 0 ? 30 : 29;
+		}
+		return 0;
+	}
+
+	// 某年份农历各月天数
+	lunarMonthDays(year : number) : number[] {
+
+		 let monthDays = this.lunarMonthDaysMap.get(year)
+			if (monthDays != null) {
+					return monthDays
+			}
+
+			monthDays = [];
+
+			let lunarYear = lunarYears[year - 1900];
+
+			for (let i = 15; i >= 4; i--) {
+					let monthDay = (lunarYear >> i & 0x1) != 0 ? 30 : 29;
+					monthDays.push(monthDay);
+			}
+
+			// 添加闰月
+			let leapM = this.leapMonth(year);
+
+			if (leapM > 0) monthDays.splice(leapM, 0, this.leapDays(year));
+			this.lunarMonthDaysMap.set(year, monthDays)
+
+			return monthDays;
+	}
+
+
+	// 某年农历天数
+	lunarYearDays(year : number) : number {
+		if (this.lunarYearDaysMap.has(year)) {
+			return this.lunarYearDaysMap.get(year)!
+		}
+		let num = 0;
+		this.lunarMonthDays(year).forEach(item => {
+			num += item;
+		});
+		this.lunarYearDaysMap.set(year, num)
+		return num;
+
+	}
+
+
+	/**
+		* 传入阳历年月日获得详细的公历、农历object信息 <=>JSON
+		* @param y  solar year
+		* @param m  solar month
+		* @param d  solar day
+		* @return JSON object
+		* @eg:console.log(calendar.solar2lunar(1987,11,01));
+		*/
+	solar2lunar(y : number, m : number, d : number) : LunarInfoType { // 参数区间1900.1.31~2100.12.31
+		let moonDay = this.solar_date(y, m, d);
+		let lYear = moonDay.lunarY
+		let lMonth = moonDay.lunarM
+		let lDay = moonDay.lunarD
+		let isLeap = moonDay.isLeap
+
+		// 计算农历日期
+		const IMonthCn = this.toChinaMonth(lMonth, isLeap)
+
+		let IDayCn = lDay == 1 ? IMonthCn : this.toChinaDay(lDay)
+
+		// 是否今天
+		let isTodayObj = new Date()
+		let isToday = false
+		if (isTodayObj.getFullYear() == y && isTodayObj.getMonth() + 1 == m && isTodayObj.getDate() == d) {
+			isToday = true
+		}
+
+		let info : LunarInfoType = {
+			'lYear': lYear,
+			'lMonth': lMonth,
+			'lDay': lDay,
+			'IMonthCn': IMonthCn,
+			'IDayCn': IDayCn,
+			'cYear': y,
+			'cMonth': m,
+			'cDay': d,
+			'isToday': isToday,
+			'isLeap': isLeap,
+		}
+		return info
+	}
+
+	solar_date(y : number, m : number, d : number) : InfoType { // 参数区间1900.1.31~2100.12.31
+
+		let date = new Date(y, m - 1, d);
+
+		// 参照日期 1901-02-19 正月初一
+		let offset = (Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()) - Date.UTC(1901, 1, 19)) / 86400000;
+		let temp = 0
+		let i : number;
+		for (i = 1901; i < 2101 && offset > 0; i++) {
+			temp = this.lunarYearDays(i);
+			offset -= temp;
+		}
+		if (offset < 0) {
+			offset += temp;
+			i--;
+		}
+
+		// 农历年、月、日
+		let isLeap : boolean = false
+		let j : number = 0;
+		let monthDays = this.lunarMonthDays(i);
+		let leapM = this.leapMonth(i);
+
+		if (offset > 0) {
+			for (j = 0; j < monthDays.length && offset > 0; j++) {
+				temp = monthDays[j];
+				offset -= temp;
+			}
+			if (offset == 0) {
+				j++;
+			}
+			if (offset < 0) {
+				offset += temp;
+			}
+		} else {
+			// 补偿公历1901年2月的农历信息
+			if (offset == -23) {
+				let info : InfoType = {
+					lunarY: i,
+					lunarM: 12,
+					lunarD: 8,
+					isLeap: false
+				}
+				info = info
+			}
+		}
+
+		// 矫正闰年月
+		if (leapM > 0) {
+			if (j == leapM + 1) {
+				isLeap = true
+			}
+			if (j >= leapM + 1) {
+				j--
+			}
+		}
+		const info : InfoType = {
+			lunarY: i,
+			lunarM: j,
+			lunarD: ++offset,
+			isLeap: isLeap
+		}
+
+
+		return info
+	}
+}

uni_modules/kux-dayjs/common/constant.uts

@@ -0,0 +1,18 @@
+export const WEEKDAYS = Array('Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat');
+
+export const MONTHS = Array(
+	'Jan',
+	'Feb',
+	'Mar',
+	'Apr',
+	'May',
+	'Jun',
+	'Jul',
+	'Aug',
+	'Sep',
+	'Oct',
+	'Nov',
+	'Dec'
+);
+
+export const MONTH_DAYS = Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);

uni_modules/kux-dayjs/common/date.uts

@@ -0,0 +1,88 @@
+import { Lunar, LunarInfoType } from './calendar';
+
+export type DateType = {
+	fullDate: string;
+	year: number;
+	month: number;
+	date: number;
+	hour: number;
+	minute: number;
+	second: number;
+	millisecond: number;
+	day: number;
+	isToday: boolean;
+	lunar: string;
+};
+
+export class DateUtil {
+	private lunar: Lunar;
+	constructor () {
+		this.lunar = new Lunar();
+	};
+	
+	/**
+	 * 计算阴历日期显示
+	 */
+	getlunar (year : number, month : number, date : number) : LunarInfoType {
+		return this.lunar.solar2lunar(year, month, date)
+	}
+	
+	/**
+	 * 获取任意时间
+	 */
+	getDate (date: string): DateType {
+		let dd: Date = new Date();
+		let hour = 0;
+		let minute = 0;
+		let second = 0;
+		let milllisceond = 0;
+		
+		if (date !== '') {
+			const datePart = date.split(" ");
+			const dateData = datePart[0].split("-");
+			const year = parseInt(dateData[0]);
+			const month = parseInt(dateData[1]);
+			const day = parseInt(dateData[2]);
+			
+			if (datePart.length > 1) {
+				const timeData = datePart[1].split(":");
+				hour = parseInt(timeData[0]);
+				minute = parseInt(timeData[1]);
+				const secondPart = timeData[2].split(".");
+				second = parseInt(secondPart[0]);
+				if (secondPart.length > 1) {
+					milllisceond = parseInt(secondPart[1]);
+				}
+			}
+		
+			dd = new Date(year, month - 1, day, hour, minute, second, milllisceond);
+		}
+		
+		const y = dd.getFullYear();
+		const m = dd.getMonth() + 1;
+		const d = dd.getDate();
+		const h = dd.getHours();
+		const M = dd.getMinutes();
+		const s = dd.getSeconds();
+		const ms = dd.getMilliseconds();
+		
+		let nowDate = y + '-' + m + '-' + d;
+		const lunarData = this.getlunar(y, m, d);
+		
+		const data: DateType = {
+			fullDate: nowDate,
+			year: y,
+			month: m,
+			date: d,
+			hour: h,
+			minute: M,
+			second: s,
+			millisecond: ms,
+			day: dd.getDay() + 1,
+			lunar: lunarData.IDayCn,
+			isToday: this.getlunar(y, m, d).isToday
+		};
+		
+		return data;
+	}; 
+};

uni_modules/kux-dayjs/package.json

@@ -0,0 +1,87 @@
+{
+  "id": "kux-dayjs",
+  "displayName": "kux-dayjs",
+  "version": "1.0.0",
+  "description": "一个极简的 `uts` 库，API 设计完全参考 `dayjs` 的设计、所以上手该库基本零成本了，方便开发者们验证、操作和显示日期和时间。",
+  "keywords": [
+    "时间",
+    "日期",
+    "格式化",
+    "day",
+    "date"
+],
+  "repository": "https://gitcode.net/kviewui/kviewui-x",
+  "engines": {
+    "HBuilderX": "^3.6.8"
+  },
+  "dcloudext": {
+    "type": "uts",
+    "sale": {
+      "regular": {
+        "price": "0.00"
+      },
+      "sourcecode": {
+        "price": "0.00"
+      }
+    },
+    "contact": {
+      "qq": "1709233528"
+    },
+    "declaration": {
+      "ads": "无",
+      "data": "插件不采集任何数据",
+      "permissions": "无"
+    },
+    "npmurl": ""
+  },
+  "uni_modules": {
+    "dependencies": [],
+    "encrypt": [],
+    "platforms": {
+      "cloud": {
+        "tcb": "y",
+        "aliyun": "y"
+      },
+      "client": {
+        "Vue": {
+          "vue2": "n",
+          "vue3": "y"
+        },
+        "App": {
+          "app-android": {
+            "minVersion": "19"
+        },
+          "app-ios": "n"
+        },
+        "H5-mobile": {
+          "Safari": "n",
+          "Android Browser": "n",
+          "微信浏览器(Android)": "n",
+          "QQ浏览器(Android)": "n"
+        },
+        "H5-pc": {
+          "Chrome": "n",
+          "IE": "n",
+          "Edge": "n",
+          "Firefox": "n",
+          "Safari": "n"
+        },
+        "小程序": {
+          "微信": "n",
+          "阿里": "n",
+          "百度": "n",
+          "字节跳动": "n",
+          "QQ": "n",
+          "钉钉": "n",
+          "快手": "n",
+          "飞书": "n",
+          "京东": "n"
+        },
+        "快应用": {
+          "华为": "n",
+          "联盟": "n"
+        }
+      }
+    }
+  }
+}

uni_modules/kux-dayjs/readme.md

@@ -0,0 +1,685 @@
+# kux-dayjs
+`KuxDayjs` 是一个极简的 `uts` 库，API 设计完全参考 `dayjs` 的设计、所以上手该库基本零成本了，方便开发者们验证、操作和显示日期和时间。
+
+## 目录结构
+<ol>
+  <li><a href="#import">导入插件</a></li>
+  <li><a href="#parse">解析</a>
+    <ol>
+      <li><a href="#parse_shili">实例</a></li>
+      <li><a href="#parse_dangqianshijian">当前时间</a></li>
+	  <li><a href="#parse_clone">克隆复制</a></li>
+    </ol>
+  </li>
+  <li><a href="#getset">取值/赋值</a>
+  	<ol>
+		<li><a href="#getset_millisecond">毫秒</a></li>
+		<li><a href="#getset_second">秒</a></li>
+		<li><a href="#getset_minute">分钟</a></li>
+		<li><a href="#getset_hour">小时</a></li>
+		<li><a href="#getset_date">日期</a></li>
+		<li><a href="#getset_day">星期</a></li>
+		<li><a href="#getset_time">时间</a></li>
+		<li><a href="#getset_month">月</a></li>
+		<li><a href="#getset_year">年</a></li>
+	</ol>
+  </li>
+  <li><a href="#manipulate">操作</a>
+  	<ol>
+		<li><a href="#manipulate_add">增加</a></li>
+		<li><a href="#manipulate_subtract">减去</a></li>
+		<li><a href="#manipulate_today">今天</a></li>
+		<li><a href="#manipulate_startOf">时间的开始</a></li>
+		<li><a href="#manipulate_endOf">时间的结束</a></li>
+	</ol>
+  </li>
+  <li><a href="#display">显示</a>
+  	<ol>
+		<li><a href="#display_format">格式化</a></li>
+		<li><a href="#display_fromNow">相对当前时间（前）</a></li>
+		<li><a href="#display_from">相对指定时间（前）</a></li>
+		<li><a href="#display_toNow">相对当前时间（后）</a></li>
+		<li><a href="#display_to">相对指定时间（后）</a></li>
+		<li><a href="#display_calendar">日历时间</a></li>
+		<li><a href="#display_diff">差异（Diff）</a></li>
+		<li><a href="#display_valueOf">Unix时间戳（毫秒）</a></li>
+		<li><a href="#display_unix">Unix时间戳</a></li>
+		<li><a href="#display_daysInMonth">获取月天数</a></li>
+		<li><a href="#display_toDate">转Date</a></li>
+		<li><a href="#display_toArray">转数组</a></li>
+		<li><a href="#display_toJSON">转JSON</a></li>
+		<li><a href="#display_toObject">转对象</a></li>
+		<li><a href="#display_toRFCString">转字符串</a></li>
+	</ol>
+  </li>
+  <li><a href="#query">查询</a>
+  	<ol>
+		<li><a href="#display_isBefore">是否之前</a></li>
+		<li><a href="#display_isSame">是否相同</a></li>
+		<li><a href="#display_isAfter">是否之后</a></li>
+		<li><a href="#display_isSameOrBefore">是否相同或之前</a></li>
+		<li><a href="#display_isSameOrAfter">是否相同或之后</a></li>
+		<li><a href="#display_isBetween">是否两者之间</a></li>
+		<li><a href="#display_isDayjs">是否是KuxDayjs</a></li>
+		<li><a href="#display_isLeapYear">是否闰年</a></li>
+	</ol>
+  </li>
+</ol>
+
+### 导入插件
+<a id="import"></a>
+```ts
+import { dayjs } from '@/uni_modules/kux-dayjs';
+```
+
+### 解析
+<a id="parse"></a>
+
+#### 实例
+<a id="parse_shili"></a>
+代替修改本地Date.prototype，`KuxDayjs` 对 `Date` 对象进行了封装，只需要调用 `dayjs()` 即可
+
+`KuxDayjs` 对象是不可变的，也就是说，以某种方式改变 `KuxDayjs` 对象的所有API操作都将返回它的一个新实例。
+
+#### 当前时间
+<a id="parse_dangqianshijian"></a>
+直接调用 `dayjs()` 将返回一个包含当前日期和时间的 `KuxDayjs` 对象。
+```ts
+const now = dayjs();
+```
+>目前仅支持传入 `YYYY-MM-DD HH:mm:ss.S` 格式的日期时间字符串
+
+#### 克隆复制
+<a id="parse_clone"></a>
+所有的 `KuxDayjs` 对象都是不可变的。 但如果有必要，使用 `dayjs().clone()` 可以复制出一个当前对象。
+```ts
+const a = dayjs();
+const b = a.clone();
+// a 和 b 是两个独立的 KuxDayjs 对象
+```
+
+### 取值/赋值
+<a id="getset"></a>
+
+#### 毫秒
+<a id="getset_millisecond"></a>
+获取或设置毫秒。<br/>
+传入0到999的数字。 如果超出这个范围，它会进位到秒。
+```ts
+dayjs().millisecond()
+dayjs().millisecond(1)
+```
+
+#### 秒
+<a id="getset_second"></a>
+获取或设置秒。<br/>
+传入0到59的数字。 如果超出这个范围，它会进位到分钟。
+```ts
+dayjs().second()
+dayjs().second(1)
+```
+
+#### 分钟
+<a id="getset_minute"></a>
+获取或设置分钟。<br/>
+传入0到59的数字。 如果超出这个范围，它会进位到小时。
+```ts
+dayjs().minute()
+dayjs().minute(59)
+```
+
+#### 小时
+<a id="getset_hour"></a>
+获取或设置小时。<br/>
+传入0到23的数字。 如果超出这个范围，它会进位到天数。
+```ts
+dayjs().hour()
+dayjs().hour(12)
+```
+
+#### 日期
+<a id="getset_date"></a>
+获取或设置日期。<br/>
+传入1到31的数字。 如果超出这个范围，它会进位到月份。
+```ts
+dayjs().date()
+dayjs().date(1)
+```
+> ****注意****<br/>`dayjs().date()` 是该月的日期。`dayjs().day()` 是星期几。
+
+#### 星期
+<a id="getset_day"></a>
+获取或设置星期几。<br/>
+传入 number 从0(星期天)到6(星期六)。 如果超出这个范围，它会进位到其他周。
+```ts
+dayjs().day()
+dayjs().day(0)
+```
+> ****注意****<br/>`dayjs().date()` 是该月的日期。`dayjs().day()` 是星期几。
+
+#### 时间
+<a id="getset_time"></a>
+获取或设置时间。<br/>
+传入一个整数，表示从 1970-1-1 00:00:00 UTC 开始计时的毫秒数。 传入参数就是设置操作，否则为获取操作。
+```ts
+dayjs().time()
+dayjs().time(1)
+```
+
+#### 月
+<a id="getset_month"></a>
+获取或设置月份。<br/>
+传入0到11的 number。 如果超出这个范围，它会进位到年份。
+```ts
+dayjs().month()
+dayjs().month(0)
+```
+> ****注意****<br/>月份是从 0 开始计算的，即 1 月是 0。
+
+#### 年
+<a id="getset_year"></a>
+获取或设置年份。<br/>
+```ts
+dayjs().year()
+dayjs().year(2000)
+```
+
+### 操作
+<a id="manipulate"></a>
+您可能需要一些方法来操作 `KuxDayjs` 对象。<br/>
+`KuxDayjs` 支持像这样的链式调用。
+```ts
+dayjs('2019-01-25').add(1, 'day').subtract(1, 'year').year(2009);
+```
+
+#### 增加
+<a id="manipulate_add"></a>
+返回增加一定时间的复制的 `KuxDayjs` 对象。
+```ts
+dayjs().add(7, 'day')
+```
+支持配合单位操作。缩写要区分大小写。<br/>
+支持的单位列表如下：<br/>
++ week 周，缩写 `w`
++ month 月份，缩写 `M`
++ year 年，缩写 `y`
++ hour 小时，缩写 `h`
++ minute 分钟，缩写 `m`
++ second 秒，缩写 `s`
++ millisecond 毫秒，缩写 `ms`
+
+#### 减去
+<a id="manipulate_subtract"></a>
+返回减去一定时间的复制的 `KuxDayjs` 对象。
+```ts
+dayjs().subtract(7, 'day')
+```
+支持配合单位操作。缩写要区分大小写。<br/>
+支持的单位列表如下：<br/>
++ week 周，缩写 `w`
++ month 月份，缩写 `M`
++ year 年，缩写 `y`
++ hour 小时，缩写 `h`
++ minute 分钟，缩写 `m`
++ second 秒，缩写 `s`
++ millisecond 毫秒，缩写 `ms`
+
+#### 今天
+<a id="manipulate_today"></a>
+返回设置时间为今天的复制的 `KuxDayjs` 对象。
+```ts
+dayjs().today()
+```
+
+#### 时间的开始
+<a id="manipulate_startOf"></a>
+返回复制的 `KuxDayjs` 对象，并设置到一个时间的开始。
+```ts
+dayjs().startOf('year')
+```
+支持配合单位操作。缩写要区分大小写。<br/>
+支持的单位列表如下：<br/>
++ week 周，缩写 `w`
++ month 月份，缩写 `M`
++ year 年，缩写 `y`
++ hour 小时，缩写 `h`
++ minute 分钟，缩写 `m`
++ second 秒，缩写 `s`
++ millisecond 毫秒，缩写 `ms`
+
+>****注意****<br/>暂时不支持跨年操作。
+
+#### 时间的结束
+<a id="manipulate_endOf"></a>
+返回复制的 `KuxDayjs` 对象，并设置到一个时间的末尾。
+```ts
+dayjs().endOf('month')
+```
+支持配合单位操作。缩写要区分大小写。<br/>
+支持的单位列表如下：<br/>
++ week 周，缩写 `w`
++ month 月份，缩写 `M`
++ year 年，缩写 `y`
++ hour 小时，缩写 `h`
++ minute 分钟，缩写 `m`
++ second 秒，缩写 `s`
++ millisecond 毫秒，缩写 `ms`
+
+>****注意****<br/>暂时不支持跨年操作。
+
+### 显示
+<a id="display"></a>
+当解析和操作完成后，您需要一些方式来展示 `KuxDayjs` 对象。
+
+#### 格式化
+<a id="display_format"></a>
+根据传入的占位符返回格式化后的日期。
+```ts
+dayjs().format('YYYY-MM-DD HH:mm:ss')
+dayjs().format('YYYY-MM-DD a HH:mm:ss')
+dayjs().format('YYYY-MM-DD HH:mm:ss A')
+```
+支持的格式占位符列表：<br/>
+
+| 标识 | 示例 | 描述 |
+| --- | --- | --- |
+| YYYY | 2023 | 年份，四位数 |
+| MM | 12 | 月份 |
+| DD | 01 | 日，两位数 |
+| HH | 22 | 小时，两位数 |
+| mm | 59 | 分钟，两位数 |
+| ss | 01 | 秒，两位数 |
+| SSS | 999 | 毫秒，三位数 |
+| A | AM/PM | 上/下午，大写 |
+| a | am/pm | 上/下午，小写 |
+| AA | 上/下午 | 上/下午 |
+
+#### 相对当前时间（前）
+<a id="display_fromNow"></a>
+返回现在到当前实例的相对时间。
+```ts
+dayjs('2021-12-12').fromNow(); // 1年前
+```
+支持传入配置项自定义输出格式以及显示隐藏后缀，配置项定义如下：<br/>
+
+| 参数名 | 默认值 | 说明 |
+| --- | --- | --- |
+| isSuffix | `false` | 是否自动携带后缀，为 `true` 的时候会自动添加 `'前'` 后缀，如 1年前；手动指定 `relativeTime` 时该项不生效
+| relativeTime | `{s: '', m: '', mm: '', h: '', hh: '', d: '', dd: '', mon: '', mons: '', y: '', yy: ''}` | 自定义格式，变量说明见下方说明 |
+
+#### RelativeTime 说明
+| 范围 | 键量 | 使用变量 | 说明 | 示例 |
+| --- | --- | --- | --- | --- |
+| 0 to 44seconds | s | %s | 几秒前 | %s seconds ago |
+| 45 to 89 seconds | m | %m | 1分钟前 | %m minute ago |
+| 90 seconds to 44 minutes | mm | %mm | 几分钟前 | %mm minutes ago |
+| 45 to 89 minutes | h | %h | 1小时前 | %h hour ago |
+| 90 minutes to 21 hours | hh | %hh | 几小时前 | %hh hours ago |
+| 22 to 35 hours | d | d | %d | 1天前 | %d day ago |
+| 36 hours to 25 days | dd | %dd | 几天前 | %dd days ago |
+| 26 to 45 days | mon | %mon | 1个月前 | %mon month ago |
+| 46 days to 10 months | mons | %mons | 几个月前 | %mons months ago |
+| 11 months to 17 months | y | %y | 1年前 | %y year ago |
+| 18 months + | yy | %yy | 几年前 | %yy years ago |
+
+#### 相对指定时间（前）
+<a id="display_from"></a>
+返回 X 到当前实例的相对时间。
+```ts
+const datetime = dayjs('2021-12-12 15:43:58');
+const a = dayjs('2022-12-12');
+datetime.from(a); // 1年前
+```
+支持传入配置项自定义输出格式以及显示隐藏后缀，配置项定义如下：<br/>
+
+| 参数名 | 默认值 | 说明 |
+| --- | --- | --- |
+| isSuffix | `false` | 是否自动携带后缀，为 `true` 的时候会自动添加 `'前'` 后缀，如 1年前；手动指定 `relativeTime` 时该项不生效
+| relativeTime | `{s: '', m: '', mm: '', h: '', hh: '', d: '', dd: '', mon: '', mons: '', y: '', yy: ''}` | 自定义格式，变量说明见下方说明 |
+
+#### RelativeTime 说明
+| 范围 | 键量 | 使用变量 | 说明 | 示例 |
+| --- | --- | --- | --- | --- |
+| 0 to 44seconds | s | %s | 几秒前 | %s seconds ago |
+| 45 to 89 seconds | m | %m | 1分钟前 | %m minute ago |
+| 90 seconds to 44 minutes | mm | %mm | 几分钟前 | %mm minutes ago |
+| 45 to 89 minutes | h | %h | 1小时前 | %h hour ago |
+| 90 minutes to 21 hours | hh | %hh | 几小时前 | %hh hours ago |
+| 22 to 35 hours | d | d | %d | 1天前 | %d day ago |
+| 36 hours to 25 days | dd | %dd | 几天前 | %dd days ago |
+| 26 to 45 days | mon | %mon | 1个月前 | %mon month ago |
+| 46 days to 10 months | mons | %mons | 几个月前 | %mons months ago |
+| 11 months to 17 months | y | %y | 1年前 | %y year ago |
+| 18 months + | yy | %yy | 几年前 | %yy years ago |
+
+#### 相对当前时间（后）
+<a id="display_toNow"></a>
+返回当前实例到现在的相对时间。
+```ts
+dayjs('2021-12-12').toNow(); // 1年后
+```
+支持传入配置项自定义输出格式以及显示隐藏后缀，配置项定义如下：<br/>
+
+| 参数名 | 默认值 | 说明 |
+| --- | --- | --- |
+| isSuffix | `false` | 是否自动携带后缀，为 `true` 的时候会自动添加 `'后'` 后缀，如 1年前；手动指定 `relativeTime` 时该项不生效
+| relativeTime | `{s: '', m: '', mm: '', h: '', hh: '', d: '', dd: '', mon: '', mons: '', y: '', yy: ''}` | 自定义格式，变量说明见下方说明 |
+
+#### RelativeTime 说明
+| 范围 | 键量 | 使用变量 | 说明 | 示例 |
+| --- | --- | --- | --- | --- |
+| 0 to 44seconds | s | %s | 几秒后 | %s seconds after |
+| 45 to 89 seconds | m | %m | 1分钟后 | %m minute after |
+| 90 seconds to 44 minutes | mm | %mm | 几分钟后 | %mm minutes after |
+| 45 to 89 minutes | h | %h | 1小时后 | %h hour after |
+| 90 minutes to 21 hours | hh | %hh | 几小时后 | %hh hours after |
+| 22 to 35 hours | d | d | %d | 1天后 | %d day after |
+| 36 hours to 25 days | dd | %dd | 几天后 | %dd days after |
+| 26 to 45 days | mon | %mon | 1个月后 | %mon month after |
+| 46 days to 10 months | mons | %mons | 几个月后 | %mons months after |
+| 11 months to 17 months | y | %y | 1年后 | %y year after |
+| 18 months + | yy | %yy | 几年后 | %yy years after |
+
+#### 相对指定时间（后）
+<a id="display_to"></a>
+返回当前实例到现在的相对时间。
+```ts
+const datetime = dayjs('2021-12-12 15:43:58');
+const a = dayjs('2022-12-12');
+console.log(datetime.to(a)); // 输出 1年后
+```
+支持传入配置项自定义输出格式以及显示隐藏后缀，配置项定义如下：<br/>
+
+| 参数名 | 默认值 | 说明 |
+| --- | --- | --- |
+| isSuffix | `false` | 是否自动携带后缀，为 `true` 的时候会自动添加 `'后'` 后缀，如 1年前；手动指定 `relativeTime` 时该项不生效
+| relativeTime | `{s: '', m: '', mm: '', h: '', hh: '', d: '', dd: '', mon: '', mons: '', y: '', yy: ''}` | 自定义格式，变量说明见下方说明 |
+
+#### RelativeTime 说明
+| 范围 | 键量 | 使用变量 | 说明 | 示例 |
+| --- | --- | --- | --- | --- |
+| 0 to 44seconds | s | %s | 几秒后 | %s seconds after |
+| 45 to 89 seconds | m | %m | 1分钟后 | %m minute after |
+| 90 seconds to 44 minutes | mm | %mm | 几分钟后 | %mm minutes after |
+| 45 to 89 minutes | h | %h | 1小时后 | %h hour after |
+| 90 minutes to 21 hours | hh | %hh | 几小时后 | %hh hours after |
+| 22 to 35 hours | d | d | %d | 1天后 | %d day after |
+| 36 hours to 25 days | dd | %dd | 几天后 | %dd days after |
+| 26 to 45 days | mon | %mon | 1个月后 | %mon month after |
+| 46 days to 10 months | mons | %mons | 几个月后 | %mons months after |
+| 11 months to 17 months | y | %y | 1年后 | %y year after |
+| 18 months + | yy | %yy | 几年后 | %yy years after |
+
+#### 日历时间
+<a id="display_calendar"></a>
+传入指定年月获取指定年月的日历面板数据，指定年月省略时默认获取当年年月的数据。返回 `DateFormat[]`，`DateFormat` 见下方说明。
+```ts
+dayjs().calendar(); 
+```
+
+##### 传入参数
+<br/>
+
+| 参数名 | 类型 | 是否必填 | 默认值 | 说明 |
+| --- | --- | --- | --- | --- |
+| year | `number` | 否 | `0` | 指定年份，默认值为 0
+| month | `number` | 否 | `0` | 指定月份，默认值为 0
+
+##### DateFormat 说明
+<br/>
+
+| 参数名 | 类型 | 说明 |
+| --- | --- | --- |
+| year | `number` | 年份
+| month | `number` | 月份
+| render | `any` | 留存字段
+| lunar | `LunarType` | 农历信息，见下方说明
+| fullLunar | `InfoType` | 农历完整数据信息，见下方说明
+| diffDays | `number` | 距离今天的差值，正数表示多少天后，负数表示多少天前，`0` 表示今天时间
+| isToday | `boolean` | 农历中是否为今天
+| fullDate | `string` | 完整日期
+
+##### LunarType 说明
+<br/>
+
+
+| 参数名 | 类型 | 说明 |
+| --- | --- | --- |
+| month | `string` | 农历月份大写
+| date | `string` | 农历日期大写
+
+##### InfoType 说明
+<br/>
+
+| 参数名 | 类型 | 说明 |
+| --- | --- | --- |
+| lunarY | `number` | 农历年份数字
+| lunarM | `number` | 农历月份数字
+| lunarD | `number` | 农历日期数字
+| isLeap | `boolean` | 是否闰月
+
+#### 差异（Diff）
+<a id="display_diff"></a>
+返回指定单位下两个日期时间之间的差异。
+```ts
+const date1 = dayjs('2019-01-25');
+const date2 = dayjs('2018-06-05');
+date1.diff(date2) // 20214000000 默认单位是毫秒
+```
+要获取其他单位下的差异，则在第二个参数传入相应的单位。
+```ts
+const date1 = dayjs('2019-01-25');
+date1.diff('2018-06-05', 'month') // 7;
+```
+默认情况下会将结果进位成整数。 如果要得到一个浮点数，将 `true` 作为第三个参数传入。
+```ts
+const date1 = dayjs('2019-01-25');
+date1.diff('2018-06-05', 'month', true) // 7.645161290322581;
+```
+支持的单位列表：<br/>
++ week 周，缩写 `w`
++ day 天，缩写 `d`
++ month 月份，缩写 `M`
++ year 年，缩写 `y`
++ hour 小时，缩写 `h`
++ minute 分钟，缩写 `m`
++ second 秒，缩写 `s`
++ millisecond 毫秒，缩写 `ms`
+
+#### Unix时间戳（毫秒）
+<a id="display_valueOf"></a>
+返回当前实例的 UNIX 时间戳，13位数字，毫秒
+```ts
+dayjs('2019-01-25').valueOf() // 1548381600000
+```
+
+#### Unix时间戳
+<a id="display_unix"></a>
+返回当前实例的 UNIX 时间戳，10位数字，秒
+```ts
+dayjs('2019-01-25').valueOf() // 1548381600
+```
+此值不包含毫秒信息，会进位到秒。
+
+
+#### 获取月天数
+<a id="display_daysInMonth"></a>
+获取当前月份包含的天数。
+```ts
+const date = dayjs('2023-12-12'); // 31
+```
+
+#### 转Date
+<a id="display_toDate"></a>
+从 `KuxDayjs` 中获取原生的Date对象。
+```ts
+dayjs('2023-12-12').toDate();
+```
+
+#### 转数组
+<a id="display_toArray"></a>
+返回一个包含各个时间信息的 Array。
+```ts
+const datetime = dayjs('2023-12-13 10:16:18');// [2023,12,13,10,16,18,0]
+```
+
+#### 转JSON
+<a id="display_toJSON"></a>
+序列化为 `ISO 8601` 格式的字符串。
+```ts
+dayjs('2023-12-13 10:16:18').toJSON(); // 2023-12-13T10:16:18.000Z
+```
+
+#### 转对象
+<a id="display_toObject"></a>
+返回包含时间信息的 Object。
+```ts
+dayjs('2023-12-13 10:16:18').toObject(); // {"date":13,"hours":10,"milliseconds":0,"minutes":16,"months":12,"seconds":18,"years":2023}
+```
+
+#### 转字符串
+<a id="display_toRFCString"></a>
+返回包含时间信息的 `RFC 822` 或 `RFC 5322` 格式字符串。
+```ts
+dayjs('2023-12-13 10:16:18').toRFCString(); // Wed, 13 Dec 2023 10:16:18 GMT
+```
+
+### 查询
+<a id="query"></a>
+`KuxDayjs` 对象还有很多查询的方法。
+
+#### 是否之前
+<a id="query_isBefore"></a>
+表示 `KuxDayjs` 对象是否在另一个提供的日期时间之前。
+```ts
+dayjs('2023-12-13 10:16:18').isBefore('2024-12-12'); // true
+```
+如果想使用除了毫秒以外的单位进行比较，则将单位作为第二个参数传入。
+```ts
+dayjs('2023-12-13 10:16:18').isBefore('2024-12-12', 'year'); // true
+```
+支持的单位列表如下：<br/>
++ year - 年，缩写为 `y`
++ month - 月，缩写为 `M`
++ day - 日，缩写为 `d`
++ hour - 小时，缩写为 `h`
++ minute - 分钟，缩写为 `m`
++ second - 秒，缩写为 `s`
++ millisecond - 毫秒，缩写为 `ms`
+
+#### 是否相同
+<a id="query_isSame"></a>
+表示 `KuxDayjs` 对象是否和另一个提供的日期时间相同。
+```ts
+dayjs('2023-12-13 10:16:18').isBefore('2023-12-12'); // false
+```
+如果想使用除了毫秒以外的单位进行比较，则将单位作为第二个参数传入。
+```ts
+dayjs('2023-12-13 10:16:18').isBefore('2023-12-12', 'year'); // true
+```
+支持的单位列表如下：<br/>
++ year - 年，缩写为 `y`
++ month - 月，缩写为 `M`
++ day - 日，缩写为 `d`
++ hour - 小时，缩写为 `h`
++ minute - 分钟，缩写为 `m`
++ second - 秒，缩写为 `s`
++ millisecond - 毫秒，缩写为 `ms`
+
+#### 是否之后
+<a id="query_isAfter"></a>
+表示 `KuxDayjs` 对象是否在另一个提供的日期时间之后。
+```ts
+dayjs('2023-12-13 10:16:18').isAfter('2023-12-12'); // true
+```
+如果想使用除了毫秒以外的单位进行比较，则将单位作为第二个参数传入。
+```ts
+dayjs('2023-12-13 10:16:18').isAfter('2023-12-12', 'year'); // true
+```
+支持的单位列表如下：<br/>
++ year - 年，缩写为 `y`
++ month - 月，缩写为 `M`
++ day - 日，缩写为 `d`
++ hour - 小时，缩写为 `h`
++ minute - 分钟，缩写为 `m`
++ second - 秒，缩写为 `s`
++ millisecond - 毫秒，缩写为 `ms`
+
+#### 是否相同或之前
+<a id="query_isSameOrBefore"></a>
+表示 `KuxDayjs` 对象是和另一个提供的日期时间相同或在其之前。
+```ts
+dayjs('2023-12-13 10:16:18').isSameOrBefore('2023-12-12'); // false
+```
+如果想使用除了毫秒以外的单位进行比较，则将单位作为第二个参数传入。
+```ts
+dayjs('2023-12-13 10:16:18').isSameOrBefore('2023-12-12', 'year'); // true
+```
+支持的单位列表如下：<br/>
++ year - 年，缩写为 `y`
++ month - 月，缩写为 `M`
++ day - 日，缩写为 `d`
++ hour - 小时，缩写为 `h`
++ minute - 分钟，缩写为 `m`
++ second - 秒，缩写为 `s`
++ millisecond - 毫秒，缩写为 `ms`
+
+#### 是否相同或之后
+<a id="query_isSameOrAfter"></a>
+表示 `KuxDayjs` 对象是和另一个提供的日期时间相同或在其之前。
+```ts
+dayjs('2023-12-13 10:16:18').isSameOrAfter('2023-12-12'); // true
+```
+如果想使用除了毫秒以外的单位进行比较，则将单位作为第二个参数传入。
+```ts
+dayjs('2023-12-13 10:16:18').isSameOrAfter('2023-12-12', 'year'); // true
+```
+支持的单位列表如下：<br/>
++ year - 年，缩写为 `y`
++ month - 月，缩写为 `M`
++ day - 日，缩写为 `d`
++ hour - 小时，缩写为 `h`
++ minute - 分钟，缩写为 `m`
++ second - 秒，缩写为 `s`
++ millisecond - 毫秒，缩写为 `ms`
+
+#### 是否两者之间
+<a id="query_isBetween"></a>
+表示 `KuxDayjs` 对象是否在其他两个的日期时间之间。
+```ts
+dayjs('2023-12-13').isBetween('2023-12-13', '2023-12-14'); // 默认毫秒
+```
+如果想使用除了毫秒以外的单位进行比较，则将单位作为第三个参数传入。
+```ts
+dayjs('2023-12-13').isBetween('2023-12-13', '2023-12-14', 'year');
+```
+支持的单位列表如下：<br/>
++ year - 年，缩写为 `y`
++ month - 月，缩写为 `M`
++ day - 日，缩写为 `d`
++ hour - 小时，缩写为 `h`
++ minute - 分钟，缩写为 `m`
++ second - 秒，缩写为 `s`
++ millisecond - 毫秒，缩写为 `ms`
+
+如果想自定义包含关系进行比较，则将包含关系作为第四个参数传入。
+```ts
+dayjs('2023-12-13').isBetween('2023-12-13', '2023-12-14', 'day', '[');
+```
+包含关系列表如下：<br/>
++ `[` - 向前包含，等同于 `<=`
++ `]` - 向后包含，等同于 `>=`
++ `[]` - 前后都包含
+
+#### 是否是KuxDayjs
+这表示一个变量是否为 `KuxDayjs` 对象。
+```ts
+dayjs().isDayjs(dayjs()); // true
+dayjs().isDayjs(new Date()); // false
+```
+
+#### 是否闰年
+查询 `KuxDayjs` 对象的年份是否是闰年。
+```ts
+dayjs('2000-01-01').isLeapYear(); // true
+```

uni_modules/kux-dayjs/utssdk/app-android/config.json

@@ -0,0 +1,3 @@
+{
+  "minSdkVersion": "19"
+}

uni_modules/kux-dayjs/utssdk/app-android/index.uts

@@ -0,0 +1 @@
+export * from '../../common/index';

uni_modules/kux-dayjs/utssdk/interface.uts

@@ -0,0 +1,97 @@
+import { InfoType } from '../common/calendar';
+
+export type LunarType = {
+	month: string;
+	date: string;
+};
+
+export type DatetimeUnit = 
+| 'day'
+| 'd'
+| 'month'
+| 'M'
+| 'year'
+| 'y'
+| 'hour'
+| 'h'
+| 'minute'
+| 'm'
+| 'second'
+| 's'
+| 'millisecond'
+| 'ms'
+
+export type WeekUnit = 
+| 'week'
+| 'w'
+
+export type DiffUnit = 
+| 'week'
+| 'w'
+| 'day'
+| 'd'
+| 'month'
+| 'M'
+| 'year'
+| 'y'
+| 'hour'
+| 'h'
+| 'minute'
+| 'm'
+| 'second'
+| 's'
+| 'millisecond'
+| 'ms'
+;
+
+export type DateFormat = {
+	year: number;
+	month: number;
+	date: number;
+	render: any;
+	lunar: LunarType;
+	fullLunar: InfoType;
+	diffDays: number;
+	isToday: boolean;
+	fullDate: string;
+};
+
+export type RelativeTime = {
+	s?: string;
+	m?: string;
+	mm?: string;
+	h?: string;
+	hh?: string;
+	d?: string;
+	dd?: string;
+	mon?: string;
+	mons?: string;
+	y?: string;
+	yy?: string;
+};
+
+export type FromToOptions = {
+	isSuffix?: boolean;
+	relativeTime?: RelativeTime;
+};
+
+export type DatetimeOptions = {
+	years: number;
+	months: number;
+	date: number;
+	hours: number;
+	minutes: number;
+	seconds: number;
+	milliseconds: number;
+};
+
+export type DateDiff = {
+	date1: Date,
+	date2: Date
+};
+
+export type IsBetweenContains = 
+| '['
+| ']'
+| '[]'
+| ''