@jtakeit/kit 0.0.0-stage → 0.2.0

package/lib/meta.mjs

@@ -0,0 +1,150 @@
+/**
+ * `_meta.json` — what the edge needs to know that the HTML cannot say — and
+ * the specimen pages, whose addresses two things have to agree on.
+ *
+ * Cloudflare Pages read `_redirects` and `_headers` out of the build. The
+ * platform serves sites from its own Worker instead, and this file is what
+ * replaced them: one small object beside the pages, written by the build.
+ *
+ * ── drafts, and why the list has to exist ───────────────────────────────────
+ *
+ * An entry nobody has finished is **built** — that is how its author looks at
+ * it before it is out — and it is in no listing, no feed and no sitemap. What
+ * stops a stranger reading it is the edge, and the edge is serving static
+ * objects: it has no way to tell a draft from a page except to be told. This
+ * is being told.
+ *
+ * ── the specimens, which have no file at all ────────────────────────────────
+ *
+ * The build also draws one page per arrangement, so that the panel can lift
+ * this site's own markup for a block a post has just been given. They are
+ * generated from the declaration rather than written, so looking for their
+ * documents finds nothing — and a draft nobody can find is a draft the edge
+ * hands to anybody. Listed here, derived the same way the site derives them.
+ *
+ * ── immutable, which directory is the build's own ───────────────────────────
+ *
+ * The files whose name carries a hash of their contents are cached by the
+ * edge for a year and never revalidated, and under the preview's slug a
+ * script's reference to one is put under the slug. Where they live is the
+ * generator's to say: `/_astro/` for Astro, `/_next/static/` for a Next
+ * export, `/_app/immutable/` for SvelteKit, `/assets/` for Vite. A build that
+ * says nothing is taken to be Astro's. Never a directory with an unhashed
+ * file in it — it would be stuck in browsers for a year.
+ */
+import { readdir, readFile, writeFile } from 'node:fs/promises';
+import { join, relative, sep } from 'node:path';
+
+/** The id of one specimen, which is also its address under the collection. */
+export function specimenId(type, view) {
+  return view === undefined || view === '' ? `_fl-${type}` : `_fl-${type}-${view}`;
+}
+
+/**
+ * Every specimen this site builds, as addresses.
+ *
+ * One per arrangement of every type a post may hold — and one per language,
+ * because a preview of a Russian post must lift its markup from a Russian
+ * page: anything else puts the wrong words and an address that does not
+ * exist around the block.
+ *
+ * @param {{ prefix: string; body?: string[] }[]} collections
+ * @param {{ type: string; views?: { key: string }[] }[]} blocks
+ * @param {string[]} [locales] the site's languages besides its own
+ * @returns {string[]}
+ */
+export function specimenAddresses(collections, blocks, locales = []) {
+  const out = [];
+  for (const collection of collections) {
+    for (const kind of collection.body ?? []) {
+      const type = blocks.find((one) => one.type === kind);
+      if (type === undefined) continue;
+      for (const view of type.views ?? [undefined]) {
+        const id = specimenId(kind, view?.key);
+        for (const locale of ['', ...locales]) {
+          const at = locale === '' ? collection.prefix : `/${locale}${collection.prefix}`;
+          out.push(`${at}/${id}/`);
+        }
+      }
+    }
+  }
+  return out.sort();
+}
+
+/**
+ * Every entry whose document says it is not on the site yet, as addresses.
+ *
+ * A document, not frontmatter: an entry is a page of blocks in a `.json`
+ * file. Only an entry carries `visible` at all; a page has none and is not a
+ * draft. `=== false` and not falsy: absent means listed.
+ *
+ * @param {string} [root] where the content is, `jtk/content` under the working directory
+ * @returns {Promise<string[]>}
+ */
+export async function hiddenEntries(root = join(process.cwd(), 'jtk', 'content')) {
+  const out = [];
+  const walk = async (at) => {
+    let entries;
+    try {
+      entries = await readdir(at, { withFileTypes: true });
+    } catch {
+      return; // a site with no content directory is a site with no drafts
+    }
+    for (const entry of entries) {
+      const full = join(at, entry.name);
+      if (entry.isDirectory()) {
+        // The pictures the build downloaded beside an entry.
+        if (entry.name !== 'media') await walk(full);
+        continue;
+      }
+      if (!entry.name.endsWith('.json')) continue;
+      let document;
+      try {
+        document = JSON.parse(await readFile(full, 'utf8'));
+      } catch {
+        continue; // unreadable JSON is the build's error to report, not this one
+      }
+      if (document?.visible === false) {
+        const name = relative(root, full).split(sep).join('/').replace(/\.json$/, '');
+        out.push(`/${name}/`);
+      }
+    }
+  };
+  await walk(root);
+  return out.sort();
+}
+
+/**
+ * The whole file, assembled: the drafts from the content, the specimens from
+ * the declaration, the hashed directory from the generator.
+ *
+ * @param {object} what
+ * @param {string} [what.root]                 the content root, `jtk/content` by default
+ * @param {{ prefix: string; body?: string[] }[]} [what.collections]
+ * @param {{ type: string; views?: { key: string }[] }[]} [what.blocks]
+ * @param {string[]} [what.locales]
+ * @param {string[]} [what.immutable]          e.g. `['/_astro/']`
+ * @param {{ from: string; to: string; status?: number }[]} [what.redirects]
+ * @returns {Promise<{ redirects: object[]; drafts: string[]; immutable?: string[] }>}
+ */
+export async function buildMeta({ root, collections = [], blocks = [], locales = [], immutable, redirects = [] } = {}) {
+  const drafts = [...(await hiddenEntries(root)), ...specimenAddresses(collections, blocks, locales)].sort();
+  const meta = { redirects, drafts };
+  if (Array.isArray(immutable) && immutable.length > 0) meta.immutable = immutable;
+  return meta;
+}
+
+/**
+ * Writes `_meta.json` into a build directory — whatever happens, empty lists
+ * and all, because a missing file and an empty one mean different things to
+ * whoever is debugging.
+ *
+ * @param {string} dir   the build directory, `dist/`
+ * @param {Parameters<typeof buildMeta>[0]} what
+ * @returns {Promise<{ redirects: object[]; drafts: string[]; immutable?: string[] }>}
+ */
+export async function writeMeta(dir, what = {}) {
+  const meta = await buildMeta(what);
+  await writeFile(join(dir, '_meta.json'), JSON.stringify(meta, null, 2) + '\n');
+  return meta;
+}

package/lib/money.mjs

@@ -0,0 +1,30 @@
+/**
+ * A price as the page says it: «2 300 ₴», not «2 300,00 UAH».
+ *
+ * Minor units in, as the platform stores them. The narrow sign, because a
+ * language's own data may write a currency as its code; no kopecks on a whole
+ * price, because «,00» on a price list reads like a spreadsheet. And no sign
+ * at all where the site has not said what its prices are in — one made up
+ * here is a lie on every price: a hotel's hryvnias read as francs (2 October
+ * 2026). The currency is the site's, from the brief, written into
+ * jtk/site.json by the platform; it is for showing a price, nothing more.
+ *
+ * @param {number} minor
+ * @param {string | undefined} currency
+ * @param {string} locale
+ * @returns {string}
+ */
+export function money(minor, currency, locale) {
+  const value = minor / 100;
+  const digits = Number.isInteger(value) ? 0 : 2;
+  if (!currency) {
+    return new Intl.NumberFormat(locale, { minimumFractionDigits: digits, maximumFractionDigits: 2 }).format(value);
+  }
+  return new Intl.NumberFormat(locale, {
+    style: 'currency',
+    currency: currency.toUpperCase(),
+    currencyDisplay: 'narrowSymbol',
+    minimumFractionDigits: digits,
+    maximumFractionDigits: 2,
+  }).format(value);
+}

package/package.json

@@ -1,6 +1,83 @@
 {
   "name": "@jtakeit/kit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "The framework-free half of a site on jtakeit: the booking form as an element and as markup, for Astro through @jtakeit/astro and for any other generator directly",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "jtkit": "bin/jtkit.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./index.mjs"
+    },
+    "./booking": {
+      "types": "./types/booking.d.ts",
+      "default": "./lib/booking/render.mjs"
+    },
+    "./booking/words": {
+      "types": "./types/words.d.ts",
+      "default": "./lib/booking/words.mjs"
+    },
+    "./lead": {
+      "types": "./types/lead.d.ts",
+      "default": "./lib/lead/render.mjs"
+    },
+    "./money": {
+      "types": "./types/money.d.ts",
+      "default": "./lib/money.mjs"
+    },
+    "./meta": {
+      "types": "./types/meta.d.ts",
+      "default": "./lib/meta.mjs"
+    },
+    "./kits": {
+      "types": "./types/kits.d.ts",
+      "default": "./lib/kits.mjs"
+    },
+    "./catalogue": "./lib/catalogue.mjs",
+    "./codes": "./lib/codes.mjs",
+    "./elements/booking": {
+      "types": "./types/elements-booking.d.ts",
+      "default": "./elements/booking.js"
+    },
+    "./elements/lead": {
+      "types": "./types/elements-lead.d.ts",
+      "default": "./elements/lead.js"
+    },
+    "./elements/alive": {
+      "types": "./types/alive.d.ts",
+      "default": "./elements/alive.js"
+    },
+    "./booking.css": "./booking.css",
+    "./lead.css": "./lead.css"
+  },
+  "files": [
+    "index.mjs",
+    "bin",
+    "lib",
+    "elements",
+    "types",
+    "booking.css",
+    "lead.css",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jtakeit/jtakeit-kit.git",
+    "directory": "kit"
+  },
+  "keywords": [
+    "jtakeit",
+    "booking",
+    "custom-element",
+    "static-site"
+  ],
+  "scripts": {
+    "test": "node --test"
+  }
+}

package/types/alive.d.ts

@@ -0,0 +1,2 @@
+/** Runs `start` on every match at load, and again on markup the panel places (`fl:placed`). */
+export function onAlive(selector: string, start: (node: Element) => void): void;

package/types/booking.d.ts

@@ -0,0 +1,32 @@
+export interface Named {
+  slug: string;
+  title: string;
+  takes?: number;
+  costs?: number;
+  /** A price by the hour of the week instead of `costs`: rows of a day, a span and a price. The list says «from …»; the price is the slot's. */
+  rates?: { day: string; from: number; until: number; costs: number }[];
+  /** `'person'` for a price times the party — a class per place, shoes; the list says so and the running total multiplies. */
+  per?: 'booking' | 'person';
+  group?: string;
+}
+
+export interface BookingFormProps {
+  services: Named[];
+  resources?: Named[];
+  locale: string;
+  daysAhead?: number;
+  combine?: boolean;
+  currency?: string;
+  scale?: string;
+  kind?: string;
+  /** Where `/api/` is from this page; under the preview the site is served at `/p/<slug>/`. */
+  api?: string;
+  /** The element around the form, `jtk-booking`; `''` for none. */
+  tag?: string;
+  now?: Date;
+}
+
+/** What the form sends to /api/book, as `data-sends` says it. */
+export const SENDS: readonly string[];
+/** The booking form as HTML, wrapped in `<jtk-booking>`. */
+export function renderBookingForm(props: BookingFormProps): string;

package/types/elements-booking.d.ts

@@ -0,0 +1,9 @@
+export function daysBetween(from: string, until: string): number;
+export function plusDays(iso: string, n: number): string;
+export function lasting(minutes: number, words: Record<string, string>): string;
+export function wireBooking(form: HTMLFormElement): void;
+export function wireAll(root?: ParentNode): void;
+export class JtkBooking extends HTMLElement {
+  connectedCallback(): void;
+}
+export function defineBooking(name?: string): void;

package/types/elements-lead.d.ts

@@ -0,0 +1,6 @@
+export function wireLead(form: HTMLFormElement): void;
+export function wireAll(root?: ParentNode): void;
+export class JtkLead extends HTMLElement {
+  connectedCallback(): void;
+}
+export function defineLead(name?: string): void;

package/types/index.d.ts

@@ -0,0 +1,6 @@
+export { renderBookingForm, SENDS } from './booking';
+export type { BookingFormProps, Named } from './booking';
+export { renderLeadForm, inputType } from './lead';
+export type { Ask, LeadCopy, LeadPaths, LeadFormProps } from './lead';
+export { wordsFor, LOCALES } from './words';
+export { money } from './money';

package/types/kits.d.ts

@@ -0,0 +1,24 @@
+export interface Kit {
+  kind: string;
+  about?: string;
+  ask?: string[];
+  version?: string;
+  catalogue: {
+    blocks: Record<string, unknown>[];
+    collections: Record<string, unknown>[];
+    modules: Record<string, Record<string, string>>;
+  };
+  settings: Record<string, unknown>;
+  entries: { collection: string; slug: string; fields: Record<string, unknown> }[];
+}
+
+export const API: string;
+export function readKit(file: string): Kit;
+export function fetchKit(kind: string, api?: string): Promise<Kit>;
+export function loadKit(asked: string, api?: string): Promise<Kit>;
+export function checkKit(kit: unknown, from: string): Kit;
+export function kitLanguage(locale: string | undefined): 'uk' | 'en' | 'de';
+export function kitSettings(kit: Kit): Record<string, unknown>;
+export function kitEntries(kit: Kit, locale: string): [string, Record<string, unknown>][];
+export function mergeKitIntoCatalogue(catalogue: Record<string, unknown>, kit: Kit): Record<string, unknown>;
+export function layKitFiles(target: string, kit: Kit, options?: { locale?: string; catalogue?: boolean }): string[];

package/types/lead.d.ts

@@ -0,0 +1,49 @@
+export interface Ask {
+  key: string;
+  label: string;
+  kind: string;
+  required?: boolean;
+  max?: number;
+  min?: number;
+  options?: { value: string; label: string }[];
+}
+
+export interface LeadCopy {
+  title?: string;
+  lead?: string;
+  name?: string;
+  contact?: string;
+  message?: string;
+  requiredNote?: string;
+  submit?: string;
+  sending?: string;
+  success?: string;
+  error?: string;
+  invalidName?: string;
+  invalidContact?: string;
+  [other: string]: string | undefined;
+}
+
+export interface LeadPaths {
+  title?: string;
+  lead?: string;
+  name_label?: string;
+  contact_label?: string;
+  message_label?: string;
+  required_note?: string;
+  cta_label?: string;
+}
+
+export interface LeadFormProps {
+  /** Where `/api/lead` is from this page. */
+  action: string;
+  copy: LeadCopy;
+  asks?: Ask[];
+  paths?: LeadPaths;
+  /** The element around the form, `jtk-lead`; `''` for none. */
+  tag?: string;
+}
+
+export function inputType(kind: string): 'number' | 'tel' | 'email' | 'url' | 'date' | 'time' | 'text';
+/** The enquiry form as HTML, wrapped in `<jtk-lead>`. */
+export function renderLeadForm(props: LeadFormProps): string;

package/types/meta.d.ts

@@ -0,0 +1,26 @@
+export interface Meta {
+  redirects: { from: string; to: string; status?: number }[];
+  drafts: string[];
+  immutable?: string[];
+}
+
+export interface MetaInput {
+  /** The content root, `jtk/content` under the working directory by default. */
+  root?: string;
+  collections?: { prefix: string; body?: string[] }[];
+  blocks?: { type: string; views?: { key: string }[] }[];
+  locales?: string[];
+  /** The directories whose file names carry a content hash, e.g. `['/_astro/']`. */
+  immutable?: string[];
+  redirects?: { from: string; to: string; status?: number }[];
+}
+
+export function specimenId(type: string, view?: string): string;
+export function specimenAddresses(
+  collections: { prefix: string; body?: string[] }[],
+  blocks: { type: string; views?: { key: string }[] }[],
+  locales?: string[],
+): string[];
+export function hiddenEntries(root?: string): Promise<string[]>;
+export function buildMeta(what?: MetaInput): Promise<Meta>;
+export function writeMeta(dir: string, what?: MetaInput): Promise<Meta>;

package/types/money.d.ts

@@ -0,0 +1,2 @@
+/** A price as the page says it: «2 300 ₴». Minor units in. */
+export function money(minor: number, currency: string | undefined, locale: string): string;

package/types/words.d.ts

@@ -0,0 +1,3 @@
+export const LOCALES: readonly string[];
+/** The booking form's words for a language and a scale, as a fresh object. */
+export function wordsFor(locale: string, scale?: string): Record<string, string>;