Reduced size to 770 bytes

* Better types
* Better docs
* Some more code golf

Author: Atulin

CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+<a name="1.1.0"></a>
+## [1.1.0](https://github.com/atulin/tinytime/compare/v1.0.1...v1.1.0) (2017-06-08)
+
+### Features
+
+* Dropped size under 800 bytes again
+* Added better types and docs
+* More calculations are now done in a branchless way
+* Parser tokens are now typed and inlined as numbers instead of being strings
+
 <a name="1.0.0"></a>
 ## [1.0.0](https://github.com/atulin/tinytime/compare/v0.2.6...v1.0.0) (2017-06-08)
 

README.md

@@ -1,7 +1,7 @@
 
 # Tinytime ⏰
 
-> A straightforward date and time formatter in <840b.
+> A straightforward date and time formatter in 770 bytes.
 
 [![Publish to NPM and JSR](https://github.com/Atulin/tinytime/actions/workflows/publish.yml/badge.svg)](https://github.com/Atulin/tinytime/actions/workflows/publish.yml)
 [![NPM Version](https://img.shields.io/npm/v/%40angius%2Ftinytime)](https://www.npmjs.com/package/@angius/tinytime)
@@ -11,7 +11,7 @@
 ## This fork
 
 * Proper type definitions
-* More correct code at the cost of 38 more bytes gzipped
+* More correct code
 * ESM-only
 
 ## API

jsr.json

@@ -1,7 +1,7 @@
 {
 	"$schema": "https://jsr.io/schema/config-file.v1.json",
 	"name": "@angius/tinytime",
-	"version": "1.0.3",
+	"version": "1.1.0",
 	"license": "MIT",
 	"exports": "./src/tinytime.ts"
 }

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@angius/tinytime",
-	"version": "1.0.3",
+	"version": "1.1.0",
 	"exports": ["./dist/tinytime.js", "./dist/tinytime.min.js"],
 	"types": "./dist/tinytime.d.ts",
 	"license": "MIT",

src/compiler.ts

@@ -1,20 +1,5 @@
 import type { Token } from "./parser";
-import {
-	Day,
-	DayOfTheMonth,
-	DayOfTheWeek,
-	FullMonth,
-	FullYear,
-	Hour,
-	Hour24,
-	Minutes,
-	NumberMonth,
-	PartialMonth,
-	PartialYear,
-	PostOrAnteMeridiem,
-	Seconds,
-	UserText,
-} from "./subs";
+import { Tokens } from "./subs";
 import type { TinyTimeOptions } from "./tinytime";
 
 const months = [
@@ -54,14 +39,9 @@ function padWithZeros(int: number): string {
  * Adds suffix to day, so 16 becomes 16th.
  */
 function suffix(int: number): string {
-	const suf =
-		int % 10 === 1 && int !== 11
-			? "st"
-			: int % 10 === 2 && int !== 12
-				? "nd"
-				: int % 10 === 3 && int !== 13
-					? "rd"
-					: "th";
+	const s = ["th", "st", "nd", "rd"];
+	const v = int % 100;
+	const suf = s[(v - 20) % 10] || s[v] || s[0];
 	return `${int}${suf}`;
 }
 
@@ -91,75 +71,55 @@ export default function compiler(
 	while (index < tokens.length) {
 		const token = tokens[index];
 
-		if (!token) {
-			break;
-		}
-
-		switch (token[0]) {
-			case UserText:
+		const tokenHandlers = {
+			[Tokens.UserText]: () => {
 				compiled += token[1];
-				break;
-
-			case Day:
+			},
+			[Tokens.Day]: () => {
 				compiled += suffix(day);
-				break;
-
-			case PartialMonth:
+			},
+			[Tokens.PartialMonth]: () => {
 				compiled += months[month]?.slice(0, 3);
-				break;
-
-			case FullMonth:
+			},
+			[Tokens.FullMonth]: () => {
 				compiled += months[month];
-				break;
-
-			case NumberMonth:
-				{
-					const next = month + 1;
-					compiled += options.padMonth
-						? padWithZeros(next)
-						: `${next}`;
-				}
-				break;
-
-			case FullYear:
+			},
+			[Tokens.NumberMonth]: () => {
+				const next = month + 1;
+				compiled += options.padMonth ? padWithZeros(next) : `${next}`;
+			},
+			[Tokens.FullYear]: () => {
 				compiled += year;
-				break;
-
-			case PartialYear:
+			},
+			[Tokens.PartialYear]: () => {
 				compiled += `${year % 100}`;
-				break;
-
-			case DayOfTheWeek:
+			},
+			[Tokens.DayOfTheWeek]: () => {
 				compiled += days[date.getDay()];
-				break;
-
-			case DayOfTheMonth:
+			},
+			[Tokens.DayOfTheMonth]: () => {
 				compiled += options.padDays ? padWithZeros(day) : day;
-				break;
-
-			case Hour:
-				{
-					const hour = hours % 12 || 12;
-					compiled += options.padHours ? padWithZeros(hour) : hour;
-				}
-				break;
-
-			case Hour24:
+			},
+			[Tokens.Hour]: () => {
+				const hour = hours % 12 || 12;
+				compiled += options.padHours ? padWithZeros(hour) : hour;
+			},
+			[Tokens.Hour24]: () => {
 				compiled += options.padHours ? padWithZeros(hours) : hours;
-				break;
-
-			case Minutes:
+			},
+			[Tokens.Minutes]: () => {
 				compiled += padWithZeros(minutes);
-				break;
-
-			case Seconds:
+			},
+			[Tokens.Seconds]: () => {
 				compiled += padWithZeros(seconds);
-				break;
-
-			case PostOrAnteMeridiem:
+			},
+			[Tokens.PostOrAnteMeridiem]: () => {
 				compiled += hours >= 12 ? "PM" : "AM";
-				break;
-		}
+			},
+		};
+
+		tokenHandlers[token[0]]();
+
 		index++;
 	}
 	return compiled;

src/parser.ts

@@ -1,6 +1,6 @@
-import { SubToTypeIdentifierMap, UserText } from "./subs";
+import { SubToTypeIdentifierMap, Tokens } from "./subs";
 
-export type Token = [type: string, value?: string];
+export type Token = [type: Tokens, value?: string];
 
 /**
  * Rather than using a bunch of potentially confusing regular
@@ -33,9 +33,9 @@ export default function parser(template: string): Token[] {
 	 * before and after the substitution. With this template our tokens would look something like:
 	 *
 	 * [
-	 *  { type: UserText, value: "The day is "},
-	 *  { type : DaySub },
-	 *  { type: UserText, value: "." }
+	 *  [ type: UserText, value: "The day is " ],
+	 *  [ type : DaySub ],
+	 *  [ type: UserText, value: "." ]
 	 * ]
 	 *
 	 */
@@ -49,15 +49,18 @@ export default function parser(template: string): Token[] {
 		if (char === "{") {
 			// Push any `UserText` we've accumulated and reset the `text` variable.
 			if (text) {
-				tokens.push([UserText, text]);
+				tokens.push([Tokens.UserText, text]);
 			}
 			text = "";
+
 			let sub = "";
+
 			char = template[position++];
 			while (char !== "}") {
 				sub += char;
 				char = template[position++];
 			}
+
 			const identifier = SubToTypeIdentifierMap[sub];
 			if (!identifier) {
 				throw new Error(`Unknown substitution: ${sub}`);
@@ -74,7 +77,7 @@ export default function parser(template: string): Token[] {
 	 * the template ends with some `UserText`.
 	 */
 	if (text) {
-		tokens.push([UserText, text]);
+		tokens.push([Tokens.UserText, text]);
 	}
 	return tokens;
 }

src/subs.ts

@@ -1,38 +1,41 @@
 /**
  * We want to represent each subs. type as minimally as possible,
- * so instead of using strings we just use characters, which lets us
- * represent 27 individual subs. using a single character each.
+ * so instead of using strings we just use numbers, which lets us
+ * represent 27 individual subs. using a single number each.
  */
 
-export const UserText = "a";
-export const FullMonth = "b";
-export const PartialMonth = "c";
-export const FullYear = "d";
-export const PartialYear = "e";
-export const DayOfTheWeek = "f";
-export const Hour = "g";
-export const Minutes = "h";
-export const Seconds = "i";
-export const PostOrAnteMeridiem = "j";
-export const Day = "k";
-export const DayOfTheMonth = "l";
-export const NumberMonth = "n";
-export const Hour24 = "m";
+// biome-ignore lint/suspicious/noConstEnum: <explanation>
+export const enum Tokens {
+	UserText = 0,
+	FullMonth = 1,
+	PartialMonth = 2,
+	FullYear = 3,
+	PartialYear = 4,
+	DayOfTheWeek = 5,
+	Hour = 6,
+	Minutes = 7,
+	Seconds = 8,
+	PostOrAnteMeridiem = 9,
+	Day = 10,
+	DayOfTheMonth = 11,
+	NumberMonth = 12,
+	Hour24 = 13,
+}
 
 export const SubToTypeIdentifierMap: {
-	[abbreviation: string]: string;
+	[abbreviation: string]: Tokens;
 } = {
-	MMMM: FullMonth,
-	MM: PartialMonth,
-	Mo: NumberMonth,
-	YYYY: FullYear,
-	YY: PartialYear,
-	dddd: DayOfTheWeek,
-	DD: DayOfTheMonth,
-	Do: Day,
-	h: Hour,
-	H: Hour24,
-	mm: Minutes,
-	ss: Seconds,
-	a: PostOrAnteMeridiem,
-};
+	MMMM: Tokens.FullMonth,
+	MM: Tokens.PartialMonth,
+	Mo: Tokens.NumberMonth,
+	YYYY: Tokens.FullYear,
+	YY: Tokens.PartialYear,
+	dddd: Tokens.DayOfTheWeek,
+	DD: Tokens.DayOfTheMonth,
+	Do: Tokens.Day,
+	h: Tokens.Hour,
+	H: Tokens.Hour24,
+	mm: Tokens.Minutes,
+	ss: Tokens.Seconds,
+	a: Tokens.PostOrAnteMeridiem,
+} as const;

src/tinytime.ts

@@ -2,6 +2,12 @@ import compiler from "./compiler";
 import parser from "./parser";
 
 export type TinyTime = {
+	/**
+	 * Renders the template with the provided date.
+	 *
+	 * @param {Date} date - The date to render the template with.
+	 * @returns {string} - The rendered string with the date substitutions.
+	 */
 	render: (date: Date) => string;
 };
 
@@ -11,13 +17,37 @@ export type TinyTimeOptions = {
 	padMonth?: boolean;
 };
 
+/**
+ * Creates a template object from a template string.
+ *
+ * The following substitutions are supported:
+ * | Token | Description |
+ * | --- | --- |
+ * | `MMMM` | Full Month (September) |
+ * | `MM` | Partial Month (Sep) |
+ * | `Mo` | Numeric Month (9) |
+ * | `YYYY` | Full Year (1992) |
+ * | `YY` | Partial Year (92) |
+ * | `dddd` | Day of the Week (Monday) |
+ * | `DD` | Day of the Month (24) |
+ * | `Do` | Day (24th) |
+ * | `h` | Hours - 12h format |
+ * | `H` | Hours - 24h format |
+ * | `mm` | Minutes (zero padded) |
+ * | `ss` | Seconds (zero padded) |
+ * | `a` | AM/PM |
+ *
+ * @param {string} template a template string
+ * @param {TinyTimeOptions} options an object with options
+ * @returns {TinyTime} a TinyTime object with a render method
+ */
 export const tinytime = (
 	template: string,
 	options: TinyTimeOptions = {},
 ): TinyTime => {
 	const templateAST = parser(template);
 	return {
-		render(date: Date) {
+		render(date: Date): string {
 			return compiler(templateAST, date, options);
 		},
 	};

tests/tinytime.test.ts

@@ -74,5 +74,8 @@ describe("tinytime", () => {
 				"Sunday",
 			);
 		});
+		it("errors on incorrect template", () => {
+			expect(() => tinytime("{??}:{mm}:{xx}").render(date)).toThrow();
+		});
 	});
 });