skillet-shared 0.1.0 → 0.2.0

package/README.md

@@ -11,4 +11,5 @@ Both apps run it through Vite, so imports keep their `.ts` form and need no buil
 
 - `pnpm test` and `pnpm typecheck` run the package's own suite
 - In an app, `pnpm link ../skillet-shared` tests an edit before it is tagged
-- Release: bump `version`, tag it, `npm publish`, then bump the range in each app
+- Release: `pnpm version patch` (or `minor`). It tests, tags and pushes, and CI publishes to npm through trusted publishing
+- Then bump the range in each app

package/dist/history.d.ts

@@ -0,0 +1,15 @@
+export declare const HISTORY_MAX = 24;
+export interface History<T> {
+    readonly past: readonly T[];
+    readonly future: readonly T[];
+}
+export declare const EMPTY_HISTORY: History<never>;
+export declare function record<T>(h: History<T>, prev: T, same: (a: T, b: T) => boolean): History<T>;
+export declare function stepBack<T>(h: History<T>, current: T): {
+    history: History<T>;
+    value: T;
+} | null;
+export declare function stepForward<T>(h: History<T>, current: T): {
+    history: History<T>;
+    value: T;
+} | null;

package/dist/history.js

@@ -0,0 +1,48 @@
+// A bounded undo/redo walk over whole-board snapshots.
+//
+// One step back would be enough if every destructive move were deliberate. It
+// stops being enough the moment finding a sound becomes a search: mutate,
+// mutate, random, mutate, and the board worth keeping is three steps behind the
+// one you can hear, with no way back to it. So the walk is retraceable in both
+// directions — which is also what makes a wild jitter safe to try, since the
+// cost of a bad roll is one keystroke rather than the board you had.
+//
+// Pure and generic on purpose: the interesting behaviour is the dedupe, the cap
+// and when the redo tail dies, and all three are worth pinning down in a test.
+// Deep enough to cover a run of rolls, small enough that a snapshot per entry
+// stays free — a couple of hundred numbers each.
+export const HISTORY_MAX = 24;
+export const EMPTY_HISTORY = { past: [], future: [] };
+// Record the state being replaced. `same` decides what counts as no movement:
+// more than one path snapshots the same board on the way to a single change, and
+// a stack of identical entries turns undo into a key you press four times to
+// hear anything.
+export function record(h, prev, same) {
+    const top = h.past.at(-1);
+    if (top !== undefined && same(top, prev)) {
+        // Still a new branch: the redo tail belonged to a walk this write leaves.
+        return h.future.length === 0 ? h : { past: h.past, future: [] };
+    }
+    return { past: [...h.past, prev].slice(-HISTORY_MAX), future: [] };
+}
+// Step back. `current` is the live state, which becomes the head of the redo
+// tail — the caller owns it, so it is passed in rather than kept here and left
+// to drift.
+export function stepBack(h, current) {
+    const value = h.past.at(-1);
+    if (value === undefined)
+        return null;
+    return {
+        history: { past: h.past.slice(0, -1), future: [current, ...h.future] },
+        value,
+    };
+}
+export function stepForward(h, current) {
+    const [value, ...rest] = h.future;
+    if (value === undefined)
+        return null;
+    return {
+        history: { past: [...h.past, current].slice(-HISTORY_MAX), future: rest },
+        value,
+    };
+}

package/dist/posts.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'astro/zod';
+export declare const postSchema: z.ZodObject<{
+    title: z.ZodString;
+    date: z.ZodCoercedDate<unknown>;
+    summary: z.ZodString;
+    image: z.ZodString;
+    imageAlt: z.ZodString;
+    look: z.ZodOptional<z.ZodString>;
+    draft: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type PostData = z.infer<typeof postSchema>;
+export declare const published: (post: {
+    data: PostData;
+}) => boolean;
+export declare const isoDay: (date: Date) => string;
+export declare function longDate(date: Date): string;
+export declare function newestFirst<T extends {
+    id: string;
+    data: PostData;
+}>(posts: T[]): T[];

package/dist/posts.js

@@ -0,0 +1,25 @@
+// The blog's posts are markdown files written by hand. `scripts/blogdraft.mjs`
+// drafts one from the commits since the last post.
+import { z } from 'astro/zod';
+export const postSchema = z.object({
+    title: z.string(),
+    date: z.coerce.date(),
+    summary: z.string(),
+    image: z.string(),
+    imageAlt: z.string(),
+    look: z.string().optional(),
+    draft: z.boolean().default(false),
+});
+export const published = (post) => !post.data.draft;
+export const isoDay = (date) => date.toISOString().slice(0, 10);
+export function longDate(date) {
+    return date.toLocaleDateString('en-US', {
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+        timeZone: 'UTC',
+    });
+}
+export function newestFirst(posts) {
+    return posts.toSorted((a, b) => b.data.date.getTime() - a.data.date.getTime() || a.id.localeCompare(b.id));
+}

package/dist/relative-time.d.ts

@@ -0,0 +1 @@
+export declare function sinceWords(at: number, now: number): string;

package/dist/relative-time.js

@@ -0,0 +1,30 @@
+// How long ago something happened, in the words the home page puts on a resume
+// card and under a saved voice. Coarse on purpose: the reader is picking which
+// of their own boards to open, so "3 days ago" is the whole answer and a date
+// is one more thing to read.
+const MINUTE = 60_000;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+const MONTH = 30 * DAY;
+const YEAR = 365 * DAY;
+const count = (ms, unit, name) => {
+    const n = Math.floor(ms / unit);
+    return `${n} ${name}${n === 1 ? '' : 's'} ago`;
+};
+// A clock that ran backwards — a machine whose time was wrong when the save
+// landed, or two machines disagreeing — reads as "just now" rather than as a
+// negative count.
+export function sinceWords(at, now) {
+    const ms = now - at;
+    if (!Number.isFinite(ms) || ms < MINUTE)
+        return 'just now';
+    if (ms < HOUR)
+        return count(ms, MINUTE, 'minute');
+    if (ms < DAY)
+        return count(ms, HOUR, 'hour');
+    if (ms < MONTH)
+        return count(ms, DAY, 'day');
+    if (ms < YEAR)
+        return count(ms, MONTH, 'month');
+    return count(ms, YEAR, 'year');
+}

package/package.json

@@ -1,24 +1,40 @@
 {
   "name": "skillet-shared",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Code shared by bender and videoskillet",
   "license": "MIT",
   "author": "Colin Diesh",
   "repository": "github:cmdcolin/skillet-shared",
   "type": "module",
   "exports": {
-    "./history": "./src/history.ts",
-    "./relative-time": "./src/relative-time.ts",
-    "./posts": "./src/posts.ts",
-    "./tokens.css": "./src/tokens.css"
+    "./history": {
+      "types": "./dist/history.d.ts",
+      "default": "./dist/history.js"
+    },
+    "./relative-time": {
+      "types": "./dist/relative-time.d.ts",
+      "default": "./dist/relative-time.js"
+    },
+    "./posts": {
+      "types": "./dist/posts.d.ts",
+      "default": "./dist/posts.js"
+    },
+    "./tokens.css": "./dist/tokens.css"
   },
-  "files": ["src", "!src/**/*.test.ts"],
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "access": "public"
   },
+  "packageManager": "pnpm@11.20.0",
   "scripts": {
     "test": "vitest run",
-    "typecheck": "tsc"
+    "typecheck": "tsc",
+    "build": "tsc -p tsconfig.build.json && cp src/tokens.css dist/",
+    "prepack": "pnpm build",
+    "preversion": "pnpm typecheck && pnpm test",
+    "postversion": "git push --follow-tags"
   },
   "peerDependencies": {
     "astro": "^7.4.2"

package/src/history.ts

@@ -1,68 +0,0 @@
-// A bounded undo/redo walk over whole-board snapshots.
-//
-// One step back would be enough if every destructive move were deliberate. It
-// stops being enough the moment finding a sound becomes a search: mutate,
-// mutate, random, mutate, and the board worth keeping is three steps behind the
-// one you can hear, with no way back to it. So the walk is retraceable in both
-// directions — which is also what makes a wild jitter safe to try, since the
-// cost of a bad roll is one keystroke rather than the board you had.
-//
-// Pure and generic on purpose: the interesting behaviour is the dedupe, the cap
-// and when the redo tail dies, and all three are worth pinning down in a test.
-
-// Deep enough to cover a run of rolls, small enough that a snapshot per entry
-// stays free — a couple of hundred numbers each.
-export const HISTORY_MAX = 24
-
-export interface History<T> {
-  // Oldest first, so the most recent step back is the last element.
-  readonly past: readonly T[]
-  // Nearest first: the state undo just left, ready to be stepped back into.
-  readonly future: readonly T[]
-}
-
-export const EMPTY_HISTORY: History<never> = { past: [], future: [] }
-
-// Record the state being replaced. `same` decides what counts as no movement:
-// more than one path snapshots the same board on the way to a single change, and
-// a stack of identical entries turns undo into a key you press four times to
-// hear anything.
-export function record<T>(
-  h: History<T>,
-  prev: T,
-  same: (a: T, b: T) => boolean,
-): History<T> {
-  const top = h.past.at(-1)
-  if (top !== undefined && same(top, prev)) {
-    // Still a new branch: the redo tail belonged to a walk this write leaves.
-    return h.future.length === 0 ? h : { past: h.past, future: [] }
-  }
-  return { past: [...h.past, prev].slice(-HISTORY_MAX), future: [] }
-}
-
-// Step back. `current` is the live state, which becomes the head of the redo
-// tail — the caller owns it, so it is passed in rather than kept here and left
-// to drift.
-export function stepBack<T>(
-  h: History<T>,
-  current: T,
-): { history: History<T>; value: T } | null {
-  const value = h.past.at(-1)
-  if (value === undefined) return null
-  return {
-    history: { past: h.past.slice(0, -1), future: [current, ...h.future] },
-    value,
-  }
-}
-
-export function stepForward<T>(
-  h: History<T>,
-  current: T,
-): { history: History<T>; value: T } | null {
-  const [value, ...rest] = h.future
-  if (value === undefined) return null
-  return {
-    history: { past: [...h.past, current].slice(-HISTORY_MAX), future: rest },
-    value,
-  }
-}

package/src/posts.ts

@@ -1,37 +0,0 @@
-// The blog's posts are markdown files written by hand. `scripts/blogdraft.mjs`
-// drafts one from the commits since the last post.
-import { z } from 'astro/zod'
-
-export const postSchema = z.object({
-  title: z.string(),
-  date: z.coerce.date(),
-  summary: z.string(),
-  image: z.string(),
-  imageAlt: z.string(),
-  look: z.string().optional(),
-  draft: z.boolean().default(false),
-})
-
-export type PostData = z.infer<typeof postSchema>
-
-export const published = (post: { data: PostData }) => !post.data.draft
-
-export const isoDay = (date: Date) => date.toISOString().slice(0, 10)
-
-export function longDate(date: Date) {
-  return date.toLocaleDateString('en-US', {
-    year: 'numeric',
-    month: 'long',
-    day: 'numeric',
-    timeZone: 'UTC',
-  })
-}
-
-export function newestFirst<T extends { id: string; data: PostData }>(
-  posts: T[],
-) {
-  return posts.toSorted(
-    (a, b) =>
-      b.data.date.getTime() - a.data.date.getTime() || a.id.localeCompare(b.id),
-  )
-}

package/src/relative-time.ts

@@ -1,27 +0,0 @@
-// How long ago something happened, in the words the home page puts on a resume
-// card and under a saved voice. Coarse on purpose: the reader is picking which
-// of their own boards to open, so "3 days ago" is the whole answer and a date
-// is one more thing to read.
-const MINUTE = 60_000
-const HOUR = 60 * MINUTE
-const DAY = 24 * HOUR
-const MONTH = 30 * DAY
-const YEAR = 365 * DAY
-
-const count = (ms: number, unit: number, name: string): string => {
-  const n = Math.floor(ms / unit)
-  return `${n} ${name}${n === 1 ? '' : 's'} ago`
-}
-
-// A clock that ran backwards — a machine whose time was wrong when the save
-// landed, or two machines disagreeing — reads as "just now" rather than as a
-// negative count.
-export function sinceWords(at: number, now: number): string {
-  const ms = now - at
-  if (!Number.isFinite(ms) || ms < MINUTE) return 'just now'
-  if (ms < HOUR) return count(ms, MINUTE, 'minute')
-  if (ms < DAY) return count(ms, HOUR, 'hour')
-  if (ms < MONTH) return count(ms, DAY, 'day')
-  if (ms < YEAR) return count(ms, MONTH, 'month')
-  return count(ms, YEAR, 'year')
-}