dsh-cool-theme 0.4.0 → 0.6.0

package/lib/types/client/presets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../../src/client/presets.ts"],"names":[],"mappings":"AAuCA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmC0B,CAAA;AAE9C,+FAA+F;AAC/F,MAAM,MAAM,QAAQ,GAAG,MAAM,OAAO,OAAO,GAAG,QAAQ,CAAA;AAEtD,eAAO,MAAM,aAAa,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAK7D,CAAA"}
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../../src/client/presets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAc,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAqCpE,gEAAgE;AAChE,MAAM,MAAM,SAAS,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,SAAS,CAAA;CAAE,CAAA;AAE5E;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,eAAe,EAAE,SAAS,CAmCtD,CAAA;AAED,+FAA+F;AAC/F,MAAM,MAAM,QAAQ,GAAG,MAAM,OAAO,OAAO,GAAG,QAAQ,CAAA;AAEtD;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,QAAQ,CAAwC,CAAA;AAE1F,eAAO,MAAM,aAAa,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAQ7D,CAAA"}

package/lib/types/client/theme-files.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Browser half of the theme-file transport.
+ *
+ * The Host owns the files; this module is the only place that knows the wire
+ * shape, so the rest of the client keeps working with plain `SavedTheme`
+ * records. Every call is same-origin against the Host's own prefix route.
+ */
+import type { ThemeDocument } from '../contract.js';
+import { type CustomTheme, type SavedTheme } from './custom.js';
+/** Repair one stored document against the preset its seeds derive from. */
+export declare function documentToSaved(doc: ThemeDocument, fallbackFor: (base: string) => CustomTheme): SavedTheme;
+/** The document payload for one entry; timestamps stay the Host's business. */
+export declare function savedToDocument(entry: SavedTheme): Record<string, unknown>;
+/**
+ * The Host answered as something other than this API — its route half is not
+ * mounted (the usual cause is a DSH process started before this plugin's host
+ * half existed). Distinguished from a write failure because only this one tells
+ * the user to restart, and the browser copy is still intact meanwhile.
+ */
+export declare class ThemeApiUnavailableError extends Error {
+}
+/** Every stored theme, in the Host's creation-time order (oldest first). */
+export declare function fetchThemes(fallbackFor: (base: string) => CustomTheme): Promise<SavedTheme[]>;
+/** Insert or replace the given entries; resolves with what the Host stored. */
+export declare function pushThemes(entries: SavedTheme[], fallbackFor: (base: string) => CustomTheme): Promise<SavedTheme[]>;
+/** Remove one theme's directory. */
+export declare function removeTheme(id: string): Promise<void>;
+/**
+ * Download one theme as an archive. The response is the archive itself rather
+ * than JSON, so this is the one call that does not go through {@link callApi}.
+ */
+export declare function exportTheme(id: string, name: string): Promise<void>;
+/**
+ * Upload one archive. The Host validates it, names the theme and stores it, so
+ * a success means the roster already has the theme — the answer carries what to
+ * report, not what the client still has to write.
+ */
+export declare function importTheme(file: File): Promise<{
+    id: string;
+    name: string;
+}>;
+/**
+ * The themes a browser saved before files became the store, minus those the
+ * Host already has.
+ *
+ * Ids are the join key: a theme another browser already migrated must not be
+ * written twice, while one this roster lacks would otherwise disappear from the
+ * UI. Callers adopt the result, then stop reading the browser copy.
+ */
+export declare function legacyThemesToAdopt(legacy: SavedTheme[], hostThemes: SavedTheme[]): SavedTheme[];
+//# sourceMappingURL=theme-files.d.ts.map

package/lib/types/client/theme-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-files.d.ts","sourceRoot":"","sources":["../../../src/client/theme-files.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAUH,OAAO,KAAK,EAAc,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAC/D,OAAO,EAAmB,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AAEhF,2EAA2E;AAC3E,wBAAgB,eAAe,CAC7B,GAAG,EAAE,aAAa,EAClB,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,WAAW,GACzC,UAAU,CAQZ;AAED,+EAA+E;AAC/E,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAS1E;AAMD;;;;;GAKG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;CAAG;AA4DtD,4EAA4E;AAC5E,wBAAsB,WAAW,CAC/B,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,WAAW,GACzC,OAAO,CAAC,UAAU,EAAE,CAAC,CAEvB;AAED,+EAA+E;AAC/E,wBAAsB,UAAU,CAC9B,OAAO,EAAE,UAAU,EAAE,EACrB,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,WAAW,GACzC,OAAO,CAAC,UAAU,EAAE,CAAC,CAMvB;AAED,oCAAoC;AACpC,wBAAsB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE3D;AAWD;;;GAGG;AACH,wBAAsB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAUzE;AAuCD;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAWnF;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,UAAU,EAAE,EACpB,UAAU,EAAE,UAAU,EAAE,GACvB,UAAU,EAAE,CAGd"}

package/lib/types/client/theme.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../../src/client/theme.tsx"],"names":[],"mappings":"AAyCA,wBAAgB,aAAa,CAAC,GAAG,EAAE,GAAG,QAsQrC"}
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../../src/client/theme.tsx"],"names":[],"mappings":"AA8MA,wBAAgB,aAAa,CAAC,GAAG,EAAE,GAAG,QAmhBrC"}

package/lib/types/client/tokens.d.ts

@@ -1,8 +1,21 @@
-import { type PresetId } from './presets.js';
+import { type PresetId, type PresetDef } from './presets.js';
 export declare function buildBaseCss(): string;
-export declare function buildOverrides(id: PresetId): Record<string, {
+/**
+ * Accepts either a preset id or an already-built `PresetDef` (what a custom
+ * theme produces). Both go through the identical merge, so a custom theme is
+ * not a special case anywhere downstream.
+ */
+export declare function resolvePreset(src: PresetId | PresetDef): {
+    light: {
+        [x: string]: string;
+    };
+    dark: {
+        [x: string]: string;
+    };
+} | null;
+export declare function buildOverrides(src: PresetId | PresetDef): Record<string, {
     light: string;
     dark: string;
 }>;
-export declare function buildFullCssFallback(id: PresetId): string;
+export declare function buildFullCssFallback(src: PresetId | PresetDef): string;
 //# sourceMappingURL=tokens.d.ts.map

package/lib/types/client/tokens.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../../src/client/tokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAA;AAIrD,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAcD,wBAAgB,cAAc,CAAC,EAAE,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAI5F;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,QAAQ,GAAG,MAAM,CAQzD"}
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../../src/client/tokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAItF,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,QAAQ,GAAG,SAAS;;;;;;;SAatD;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAIzG;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,QAAQ,GAAG,SAAS,GAAG,MAAM,CAItE"}

package/lib/types/contract.d.ts

@@ -3,4 +3,82 @@
  */
 export declare const THEME_STORAGE_KEY = "cool-theme-preset";
 export declare const THEME_STORAGE_KEY_LEGACY = "cooltea-theme-preset";
+export declare const CUSTOM_PRESET_ID = "custom";
+export declare const CUSTOM_THEME_STORAGE_KEY = "cool-theme-custom";
+export declare const CUSTOM_LIST_STORAGE_KEY = "cool-theme-custom-list";
+export declare const CUSTOM_ACTIVE_STORAGE_KEY = "cool-theme-custom-active";
+export declare const CUSTOM_MIGRATED_STORAGE_KEY = "cool-theme-custom-migrated";
+/**
+ * Documents are one directory each — `<root>/<id>/theme.json` — so a theme can
+ * later carry media beside its seeds without changing this contract.
+ */
+export declare const THEME_FILE_VERSION = 1;
+/** Media kind carried with a theme; the seed payload itself is `theme`. */
+export type ThemeAssetKind = 'image' | 'video';
+/** One media file stored under the theme's `assets/` directory. */
+export type ThemeAsset = {
+    /** File name inside `assets/`; unique within the theme. */
+    name: string;
+    kind: ThemeAssetKind;
+    /** Content type the Host serves it back with. */
+    mime: string;
+    bytes: number;
+};
+/**
+ * One theme as it is stored and exchanged. `theme` stays opaque here: the
+ * Client owns the seed shape and repairs it against a preset on read, while the
+ * Host only ever moves the document in and out of a file.
+ */
+export type ThemeDocument = {
+    v: number;
+    id: string;
+    name: string;
+    /** Id of the preset the seeds derive from. */
+    base: string;
+    theme: unknown;
+    assets: ThemeAsset[];
+    createdAt: string;
+    updatedAt: string;
+};
+/**
+ * The Host's theme-file API, all below one prefix route. Kept here so the two
+ * halves cannot drift on a path.
+ */
+export declare const THEME_API_PREFIX = "/cool-theme/api";
+export declare const THEME_API_PATH_THEMES = "/cool-theme/api/themes";
+/**
+ * Share archive: one theme directory zipped. The document keeps the name it has
+ * on disk, so an archive is a copy of the directory rather than a new format,
+ * and media added later travels with it under {@link THEME_ARCHIVE_ASSETS_DIR}.
+ */
+export declare const THEME_ARCHIVE_DOCUMENT = "theme.json";
+export declare const THEME_ARCHIVE_ASSETS_DIR = "assets";
+/** Content type of an exported archive, and the extension a name gets. */
+export declare const THEME_ARCHIVE_MIME = "application/zip";
+export declare const THEME_ARCHIVE_EXTENSION = ".zip";
+/**
+ * Import bounds. A theme is a small JSON document, so anything past these caps
+ * is refused before it is parsed rather than after it has been held in memory.
+ */
+export declare const THEME_ARCHIVE_MAX_BYTES: number;
+export declare const THEME_ARCHIVE_MAX_ENTRIES = 256;
+/** Cap on one uncompressed entry, so a zip bomb cannot expand without bound. */
+export declare const THEME_ARCHIVE_MAX_ENTRY_BYTES: number;
+/** Route segments below {@link THEME_API_PATH_THEMES}: `/<id>/export`, `/import`. */
+export declare const THEME_API_SEGMENT_EXPORT = "export";
+export declare const THEME_API_PATH_IMPORT = "/cool-theme/api/themes/import";
+/**
+ * Name the Host suggests for a downloaded archive. The archive keeps the
+ * theme's name so a user can tell two exports apart, with the characters a
+ * filesystem refuses folded to spaces; the id is the fallback for a name that
+ * folds away to nothing.
+ */
+export declare function archiveFileName(name: string, id: string): string;
+/**
+ * `base`, else `${base} 2`, `${base} 3`, … An imported theme keeps the name it
+ * was shared under — that name is the point of the share — so a clash is
+ * resolved by numbering rather than by renaming the incoming theme. The Host
+ * owns this because it owns the roster the names have to be free in.
+ */
+export declare function freeThemeName(base: string, taken: readonly string[]): string;
 //# sourceMappingURL=contract.d.ts.map

package/lib/types/contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../src/contract.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,eAAO,MAAM,iBAAiB,sBAAsB,CAAA;AACpD,eAAO,MAAM,wBAAwB,yBAAyB,CAAA"}
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../src/contract.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,eAAO,MAAM,iBAAiB,sBAAsB,CAAA;AACpD,eAAO,MAAM,wBAAwB,yBAAyB,CAAA;AAG9D,eAAO,MAAM,gBAAgB,WAAW,CAAA;AAKxC,eAAO,MAAM,wBAAwB,sBAAsB,CAAA;AAG3D,eAAO,MAAM,uBAAuB,2BAA2B,CAAA;AAI/D,eAAO,MAAM,yBAAyB,6BAA6B,CAAA;AAInE,eAAO,MAAM,2BAA2B,+BAA+B,CAAA;AAMvE;;;GAGG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAEnC,2EAA2E;AAC3E,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,OAAO,CAAA;AAE9C,mEAAmE;AACnE,MAAM,MAAM,UAAU,GAAG;IACvB,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,cAAc,CAAA;IACpB,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,EAAE,MAAM,CAAA;IACT,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,UAAU,EAAE,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,oBAAoB,CAAA;AACjD,eAAO,MAAM,qBAAqB,2BAA+B,CAAA;AAEjE;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,eAAe,CAAA;AAClD,eAAO,MAAM,wBAAwB,WAAW,CAAA;AAEhD,0EAA0E;AAC1E,eAAO,MAAM,kBAAkB,oBAAoB,CAAA;AACnD,eAAO,MAAM,uBAAuB,SAAS,CAAA;AAE7C;;;GAGG;AACH,eAAO,MAAM,uBAAuB,QAAkB,CAAA;AACtD,eAAO,MAAM,yBAAyB,MAAM,CAAA;AAC5C,gFAAgF;AAChF,eAAO,MAAM,6BAA6B,QAAkB,CAAA;AAE5D,qFAAqF;AACrF,eAAO,MAAM,wBAAwB,WAAW,CAAA;AAChD,eAAO,MAAM,qBAAqB,kCAAoC,CAAA;AAEtE;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAQhE;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAQ5E"}

package/lib/types/host/index.d.ts

@@ -1,9 +1,12 @@
 /**
  * Host entry for dsh-cool-theme.
- * No host routes needed — theme is purely client-side (localStorage + overrideTokens).
- * Keep a minimal apply so the cordis patch has a mount point.
+ *
+ * Owns the theme files: the browser half cannot touch the filesystem, so every
+ * roster change travels over one same-origin prefix route below
+ * {@link THEME_API_PREFIX}. The route is the whole host surface — no service is
+ * provided, and nothing here interprets the theme payload beyond moving it.
  */
 export declare const name = "dsh-cool-theme";
 export declare const inject: string[];
-export declare function apply(_ctx: any): void;
+export declare function apply(ctx: any): void;
 //# sourceMappingURL=index.d.ts.map

package/lib/types/host/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/host/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,IAAI,mBAAmB,CAAA;AAEpC,eAAO,MAAM,MAAM,EAAE,MAAM,EAAO,CAAA;AAElC,wBAAgB,KAAK,CAAC,IAAI,EAAE,GAAG,QAAI"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/host/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAkBH,eAAO,MAAM,IAAI,mBAAmB,CAAA;AAEpC,eAAO,MAAM,MAAM,UAAgB,CAAA;AAwKnC,wBAAgB,KAAK,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CA0DpC"}

package/lib/types/host/theme-files.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Theme files owned by the Host.
+ *
+ * One directory per theme below `$DSH_HOME/cool-theme/themes/<id>/`, holding the
+ * document at `theme.json` and — once themes carry media — the originals under
+ * `assets/`. Keeping a theme a self-contained directory is what makes the later
+ * export a copy of that directory rather than a reassembly of scattered rows.
+ */
+import type { ThemeAsset, ThemeDocument } from '../contract.js';
+export declare function isThemeId(value: unknown): value is string;
+/**
+ * The harness home, resolved the way the rest of DSH resolves it: an explicit
+ * `DSH_HOME`, else `~/.dsh`.
+ */
+export declare function harnessHome(): string;
+/** Root of every stored theme. */
+export declare function themesRoot(): string;
+/** One theme's own directory. Callers must have validated `id`. */
+export declare function themeDir(id: string): string;
+/** Every stored theme, oldest by creation time first; unreadable directories are skipped. */
+export declare function listThemes(): Promise<ThemeDocument[]>;
+/**
+ * Insert or replace one document. `createdAt` is the caller's when the theme is
+ * new and the stored value when it already exists, so a later rename or edit
+ * cannot rewrite when the theme was made.
+ */
+export declare function putTheme(input: {
+    id: string;
+    name: string;
+    base: string;
+    theme: unknown;
+    assets: ThemeAsset[];
+}): Promise<ThemeDocument>;
+/** Remove one theme directory. A missing directory is already the goal. */
+export declare function deleteTheme(id: string): Promise<void>;
+/**
+ * A fresh theme id. The same shape the client mints (`ct_` + time + noise), so
+ * an id never says which half created it, and `isThemeId` is the only rule both
+ * halves apply.
+ */
+export declare function newThemeId(): string;
+/** Absolute path of a theme's media directory; used once themes carry media. */
+export declare function assetsDir(id: string): string;
+//# sourceMappingURL=theme-files.d.ts.map

package/lib/types/host/theme-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-files.d.ts","sourceRoot":"","sources":["../../../src/host/theme-files.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAc/D,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAEzD;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAGpC;AAED,kCAAkC;AAClC,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAED,mEAAmE;AACnE,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAE3C;AAgED,6FAA6F;AAC7F,wBAAsB,UAAU,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC,CAkB3D;AAED;;;;GAIG;AACH,wBAAsB,QAAQ,CAAC,KAAK,EAAE;IACpC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,UAAU,EAAE,CAAA;CACrB,GAAG,OAAO,CAAC,aAAa,CAAC,CAezB;AAED,2EAA2E;AAC3E,wBAAsB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE3D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAED,gFAAgF;AAChF,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAE5C"}

package/lib/types/host/theme-share.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Theme sharing: packing one stored theme into an archive and reading one back.
+ *
+ * An archive is the theme directory itself — the same `theme.json` and `assets/`
+ * a theme occupies on disk — so sharing never invents a second format. The Host
+ * owns both halves because the browser can neither read the theme's files nor
+ * decompress an archive on its behalf.
+ *
+ * Reading is deliberately strict: an archive either validates as one of ours or
+ * is refused with a reason. Nothing half-valid is ever handed to the client to
+ * repair, because a foreign or damaged file must not be able to seed the roster.
+ */
+import type { ThemeAsset, ThemeDocument } from '../contract.js';
+/** The document as it is packed; the timestamps are the Host's own bookkeeping. */
+type PackedDocument = Pick<ThemeDocument, 'id' | 'name' | 'base' | 'theme' | 'assets'>;
+/** A share refused for a reason worth showing the user. */
+export declare class ArchiveError extends Error {
+}
+/**
+ * Pack one theme directory. A theme with no media still gets an archive holding
+ * its document alone, so sharing a plain theme needs no second code path.
+ */
+export declare function packTheme(id: string): Promise<{
+    fileName: string;
+    bytes: Buffer;
+    document: PackedDocument;
+}>;
+/** An archive's document, validated; anything else throws {@link ArchiveError}. */
+export type UnpackedTheme = {
+    /** Created document, ready for the client to give a fresh id and name. */
+    document: PackedDocument;
+    /** Media carried beside the document, already bounds-checked. */
+    assets: {
+        name: string;
+        bytes: Buffer;
+        kind: ThemeAsset['kind'];
+        mime: string;
+    }[];
+};
+/**
+ * Read an archive back into a theme. Only the document and its media are
+ * accepted; every path is required to be exactly one of those two shapes, so a
+ * directory entry or a nested path is refused rather than normalised.
+ */
+export declare function unpackTheme(archive: Buffer): UnpackedTheme;
+export {};
+//# sourceMappingURL=theme-share.d.ts.map

package/lib/types/host/theme-share.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-share.d.ts","sourceRoot":"","sources":["../../../src/host/theme-share.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAWH,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAI/D,mFAAmF;AACnF,KAAK,cAAc,GAAG,IAAI,CAAC,aAAa,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC,CAAA;AAmBtF,2DAA2D;AAC3D,qBAAa,YAAa,SAAQ,KAAK;CAAG;AAE1C;;;GAGG;AACH,wBAAsB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IACnD,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,cAAc,CAAA;CACzB,CAAC,CAyCD;AAOD,mFAAmF;AACnF,MAAM,MAAM,aAAa,GAAG;IAC1B,0EAA0E;IAC1E,QAAQ,EAAE,cAAc,CAAA;IACxB,iEAAiE;IACjE,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAClF,CAAA;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CA+E1D"}

package/lib/types/host/zip.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The little of ZIP that sharing a theme needs.
+ *
+ * A theme is one small JSON document plus whatever media sits beside it, so the
+ * archive format is worth exactly this much: a writer that emits stored/deflated
+ * entries with a central directory, and a reader that walks that directory back.
+ * Node owns the compression (`zlib.deflateRawSync` / `inflateRawSync`); the two
+ * checksums and the record layout are all that has to be written here, which
+ * keeps the plugin dependency-free.
+ *
+ * Deliberately unsupported, because nothing this plugin writes ever produces
+ * them: zip64, encrypted entries, multi-disk archives, and data descriptors.
+ */
+export type ZipEntry = {
+    /** Path inside the archive, always with forward slashes. */
+    name: string;
+    data: Buffer;
+};
+/** How a read should select and bound the entries it inflates. */
+export type ReadZipOptions = {
+    filter?: (name: string) => boolean;
+    /** Largest uncompressed entry to accept; a bigger one is a refusal, not a skip. */
+    maxEntryBytes?: number;
+};
+/** CRC-32 of one entry, as the archive records it. */
+export declare function crc32(data: Buffer): number;
+/**
+ * Pack entries into one archive. Directory entries are not emitted: every
+ * consumer this format targets infers them from the entry paths.
+ */
+export declare function createZip(entries: ZipEntry[]): Buffer;
+/**
+ * Entry bytes from one archive, with `filter` deciding which entries are worth
+ * inflating. Throws on anything this writer would not have produced, so a file
+ * that is not one of our archives fails as "unreadable" rather than as a
+ * half-parsed theme.
+ */
+export declare function readZip(input: Buffer, options?: ReadZipOptions): ZipEntry[];
+//# sourceMappingURL=zip.d.ts.map

package/lib/types/host/zip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip.d.ts","sourceRoot":"","sources":["../../../src/host/zip.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAsBH,MAAM,MAAM,QAAQ,GAAG;IACrB,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,kEAAkE;AAClE,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;IAClC,mFAAmF;IACnF,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAcD,sDAAsD;AACtD,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM1C;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,MAAM,CAwErD;AAUD;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,cAAmB,GAAG,QAAQ,EAAE,CA0D/E"}

package/lib/types/presets-ids.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The preset ids, in one place both halves can read.
+ *
+ * `presets.ts` carries the colour maps and is client-only; the Host needs the
+ * same id vocabulary to tell an archive that derives from a preset we ship from
+ * one that does not, so the names live here and that file checks itself against
+ * them.
+ */
+export declare const PRESET_IDS: readonly ["aura", "ayu", "catppuccin", "catppuccin-frappe", "catppuccin-macchiato", "cobalt2", "cursor", "dracula", "dsh", "everforest", "flexoki", "github", "gruvbox", "kanagawa", "lucent-orng", "material", "matrix", "mercury", "monokai", "nightowl", "nord", "onedark", "opencode", "orng", "osaka-jade", "palenight", "rosepine", "solarized", "synthwave84", "system", "tokyonight", "vercel", "vesper", "zenburn"];
+/** One shipped preset id. `native` is a storage alias, not a preset. */
+export type BuiltinPresetId = (typeof PRESET_IDS)[number];
+/**
+ * Whether a theme may name `base` and still be resolved here. `native` is the
+ * legacy alias for `dsh`, so a theme that carries it stays usable.
+ */
+export declare function isKnownBase(value: string): boolean;
+//# sourceMappingURL=presets-ids.d.ts.map

package/lib/types/presets-ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presets-ids.d.ts","sourceRoot":"","sources":["../../src/presets-ids.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,eAAO,MAAM,UAAU,8ZAmCb,CAAA;AAEV,wEAAwE;AACxE,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAA;AAEzD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAElD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-cool-theme",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "A plugin for changing themes for DSH, with a number of popular default themes built in.",
   "type": "module",
   "license": "MIT",