cjm-design-system 0.0.1__tar.gz

cjm_design_system-0.0.1/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: cjm-design-system
+Version: 0.0.1
+Summary: A design system as data (ruling a439c226): token schema v1 with its check and its headless resolution into one flat vocabulary, the CSS custom-properties projection for the web, the vendored seed systems (Classical, Netrunner) with their fonts, and the importer for a web-first system's CSS. No Qt: the Qt kit (cjm-substrate-qt-kit) consumes the same tokens. Born on-graph.
+Author-email: "Christian J. Mills" <9126128+cj-mills@users.noreply.github.com>
+License: Apache-2.0
+Project-URL: Repository, https://github.com/cj-mills/cjm-design-system
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# cjm-design-system
+
+<!-- generated from the context graph by `cjm-context-graph readme` — do not edit by hand; edit the graph (the urge to hand-edit = move it on-graph) -->
+
+A design system as data (ruling a439c226): token schema v1 with its check and its headless resolution into one flat vocabulary, the CSS custom-properties projection for the web, the vendored seed systems Classical and Netrunner with their OFL fonts, and the importer for a web-first system's CSS. Nothing here imports Qt, so a web build never needs PySide6; the Qt kit (cjm-substrate-qt-kit) consumes the same tokens and keeps only what Qt reads. Born out of the kit by design 0858bbd0, the theme half of the public-site redesign build 8079ae0f.
+
+## Modules
+
+- **`cjm_design_system.__init__`** — A design system as DATA (ruling a439c226): one canonical tokens file per
+- **`cjm_design_system.systems.__init__`** — The design systems this library ships as DATA (ruling a439c226): one
+- **`cjm_design_system.tokens`** — Token schema v1 — a design system as DATA, resolved headlessly (ruling
+- **`cjm_design_system.tools.__init__`** — Design-system tools (run as modules):
+- **`cjm_design_system.tools.build`** — Build the static web projections of a design system: the CSS
+- **`cjm_design_system.tools.css_to_tokens`** — Import a web-first design system's CSS into a schema-v1 tokens file.
+
+## API
+
+### `cjm_design_system.systems.__init__`
+
+- `available` _function_ — Every vendored system slug (a directory carrying a tokens.json).
+- `locate` _function_ — The directory of a system: a vendored slug, a directory holding a
+- `tokens_path` _function_
+
+### `cjm_design_system.tokens`
+
+- `SchemaError` _class_ — A tokens file that violates schema v1 — every problem listed, so one
+- `check` _function_ — Refuse a malformed system loudly: every missing / mistyped field named
+- `load` _function_ — Read a tokens file (JSON). `check` it before resolving anything.
+- `mix` _function_ — Flatten `fg` at opacity `t` over `bg` -> a solid hex (QPalette, painters,
+- `mode_for_scheme` _function_ — The mode the system maps an OS scheme ("light" / "dark") onto — None
+- `modes` _function_
+- `resolve` _function_ — tokens + mode -> the flat vocabulary every projection reads: the QSS
+- `rgba` _function_ — QSS rgba() with a 0-255 alpha (the form every Qt 6 version parses).
+- `slug` _function_ — The system's file-system / preference slug: lower-case, spaces -> dashes.
+- `to_css` _function_ — The CSS custom-properties layer for a system — the ruling's second
+- `to_hex` _function_
+
+### `cjm_design_system.tools.build`
+
+- `main` _function_
+
+### `cjm_design_system.tools.css_to_tokens`
+
+- `convert` _function_
+- `darker` _function_
+- `family` _function_
+- `main` _function_
+- `parse_root` _function_
+- `px` _function_
+- `ramp` _function_
+
+## Dependencies
+
+**Used by:** `cjm-context-graph-projection`, `cjm-substrate-qt-kit`

cjm_design_system-0.0.1/README.md

@@ -0,0 +1,54 @@
+# cjm-design-system
+
+<!-- generated from the context graph by `cjm-context-graph readme` — do not edit by hand; edit the graph (the urge to hand-edit = move it on-graph) -->
+
+A design system as data (ruling a439c226): token schema v1 with its check and its headless resolution into one flat vocabulary, the CSS custom-properties projection for the web, the vendored seed systems Classical and Netrunner with their OFL fonts, and the importer for a web-first system's CSS. Nothing here imports Qt, so a web build never needs PySide6; the Qt kit (cjm-substrate-qt-kit) consumes the same tokens and keeps only what Qt reads. Born out of the kit by design 0858bbd0, the theme half of the public-site redesign build 8079ae0f.
+
+## Modules
+
+- **`cjm_design_system.__init__`** — A design system as DATA (ruling a439c226): one canonical tokens file per
+- **`cjm_design_system.systems.__init__`** — The design systems this library ships as DATA (ruling a439c226): one
+- **`cjm_design_system.tokens`** — Token schema v1 — a design system as DATA, resolved headlessly (ruling
+- **`cjm_design_system.tools.__init__`** — Design-system tools (run as modules):
+- **`cjm_design_system.tools.build`** — Build the static web projections of a design system: the CSS
+- **`cjm_design_system.tools.css_to_tokens`** — Import a web-first design system's CSS into a schema-v1 tokens file.
+
+## API
+
+### `cjm_design_system.systems.__init__`
+
+- `available` _function_ — Every vendored system slug (a directory carrying a tokens.json).
+- `locate` _function_ — The directory of a system: a vendored slug, a directory holding a
+- `tokens_path` _function_
+
+### `cjm_design_system.tokens`
+
+- `SchemaError` _class_ — A tokens file that violates schema v1 — every problem listed, so one
+- `check` _function_ — Refuse a malformed system loudly: every missing / mistyped field named
+- `load` _function_ — Read a tokens file (JSON). `check` it before resolving anything.
+- `mix` _function_ — Flatten `fg` at opacity `t` over `bg` -> a solid hex (QPalette, painters,
+- `mode_for_scheme` _function_ — The mode the system maps an OS scheme ("light" / "dark") onto — None
+- `modes` _function_
+- `resolve` _function_ — tokens + mode -> the flat vocabulary every projection reads: the QSS
+- `rgba` _function_ — QSS rgba() with a 0-255 alpha (the form every Qt 6 version parses).
+- `slug` _function_ — The system's file-system / preference slug: lower-case, spaces -> dashes.
+- `to_css` _function_ — The CSS custom-properties layer for a system — the ruling's second
+- `to_hex` _function_
+
+### `cjm_design_system.tools.build`
+
+- `main` _function_
+
+### `cjm_design_system.tools.css_to_tokens`
+
+- `convert` _function_
+- `darker` _function_
+- `family` _function_
+- `main` _function_
+- `parse_root` _function_
+- `px` _function_
+- `ramp` _function_
+
+## Dependencies
+
+**Used by:** `cjm-context-graph-projection`, `cjm-substrate-qt-kit`

cjm_design_system-0.0.1/cjm_design_system/__init__.py

@@ -0,0 +1,15 @@
+"""A design system as DATA (ruling a439c226): one canonical tokens file per
+system, from which every consumer derives what it renders — the web (the CSS
+custom-properties layer for the Quarto sites, 8079ae0f) and the Qt kit
+(cjm-substrate-qt-kit: QPalette + QSS + fonts + icons) alike.
+
+This library holds the half no consumer class owns (design 0858bbd0): token
+schema v1 with its check and its headless resolution into one flat vocabulary
+(`tokens`), the vendored seed systems' data — each system's tokens.json and
+the font files it names (`systems`: Classical and Netrunner) — and the
+importer for a web-first system's CSS (`tools.css_to_tokens`). Nothing here
+imports Qt, so a web build never needs PySide6; what only Qt reads (QSS
+templates, painted widgets, the Theme runtime) stays in the kit.
+"""
+
+__version__ = "0.0.1"

cjm_design_system-0.0.1/cjm_design_system/systems/__init__.py

@@ -0,0 +1,42 @@
+"""The design systems this library ships as DATA (ruling a439c226): one
+directory per system under this package — `tokens.json` (schema v1) and
+`fonts/` (the OFL files its tokens name, with their licence). What only a
+consumer reads lives with that consumer: the Qt kit keeps each system's QSS
+templates and painted widgets under its own `systems/<slug>/` (design
+0858bbd0).
+
+    available()          -> ["classical", "netrunner"]
+    locate("netrunner")  -> the system's directory
+    locate("/path/to/mysystem/tokens.json") -> that file's directory
+
+Custom systems come AFTER the gallery (abb6360d); a path-valued system is
+how one is tried before it is vendored."""
+
+from pathlib import Path
+from typing import List, Union
+
+SYSTEMS_DIR = Path(__file__).parent
+
+
+def available() -> List[str]:
+    """Every vendored system slug (a directory carrying a tokens.json)."""
+    return sorted(p.parent.name for p in SYSTEMS_DIR.glob("*/tokens.json"))
+
+
+def locate(system: Union[str, Path]) -> Path:
+    """The directory of a system: a vendored slug, a directory holding a
+    tokens.json, or a tokens.json path. Raises KeyError naming the slugs
+    available when nothing matches."""
+    p = Path(system)
+    if p.suffix == ".json" and p.is_file():
+        return p.parent
+    if p.is_dir() and (p / "tokens.json").is_file():
+        return p
+    if (SYSTEMS_DIR / str(system) / "tokens.json").is_file():
+        return SYSTEMS_DIR / str(system)
+    raise KeyError(f"no design system {system!r} — vendored: {available()}; "
+                   "or pass a directory holding tokens.json")
+
+
+def tokens_path(system: Union[str, Path]) -> Path:
+    return locate(system) / "tokens.json"

cjm_design_system-0.0.1/cjm_design_system/systems/classical/fonts/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2011 The Lora Project Authors (https://github.com/cyrealtype/Lora-Cyrillic), with Reserved Font Name "Lora".
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

cjm_design_system-0.0.1/cjm_design_system/systems/classical/tokens.json

@@ -0,0 +1,41 @@
+{
+  "schema": 1,
+  "name": "Classical",
+  "fonts": {
+    "heading": {"family": "Cormorant Garamond", "weight": 600},
+    "body": {"family": "Lora", "size": 15},
+    "mono": {"family": "", "size": 13},
+    "ui": {"family": "Lora", "size": 14},
+    "files": ["CormorantGaramond*.ttf", "Lora*.ttf"]
+  },
+  "space": {"1": 4.6, "2": 9.2, "3": 13.8, "4": 18.4, "6": 27.6, "8": 36.8},
+  "radius": {"sm": 2, "md": 4, "lg": 7},
+  "type": {"h1": [42, 400], "h2": [32, 400], "h3": [25, 600], "h4": [20, 600], "h5": [16, 600], "title": [17, 600], "kicker": [10, 400], "caption": [11, 400]},
+  "ramps": {
+    "neutral": ["#f8f4f4", "#eae7e7", "#d7d3d3", "#bab6b6", "#9b9797", "#7d7979", "#605d5d", "#444141", "#2d2b2b"],
+    "accent": ["#fff3e4", "#ffe3bf", "#facb8d", "#e1ad66", "#c28d41", "#a06f24", "#7d5411", "#5a3b0a", "#3a270d"]
+  },
+  "scheme": {"light": "light", "dark": "dark"},
+  "reading": {"measure": 68, "line_height": 1.45},
+  "icons": {"set": "lucide", "stroke_width": 1.5},
+  "modes": {
+    "light": {
+      "bg": "#f3f2f2", "surface": "#eae9e9", "text": "#201f1d",
+      "accent": "#b68235", "accent_pressed": "@accent.600", "accent_text": "@accent.700",
+      "tag_bg": "@accent.100", "tag_fg": "@accent.800",
+      "tag_neutral_bg": "@neutral.100", "tag_neutral_fg": "@neutral.800",
+      "shadow": "@neutral.900", "shadow_strength": 1.0,
+      "danger": "#a4382a", "warn": "#8c5e14", "ok": "#3a7a3a",
+      "info": "#4a5f96", "meta": "#2a6f7c", "note": "#7a4a8a"
+    },
+    "dark": {
+      "bg": "#1d1b19", "surface": "#272523", "text": "#ede9e3",
+      "accent": "#c9964d", "accent_pressed": "@accent.400", "accent_text": "@accent.300",
+      "tag_bg": "@accent.900", "tag_fg": "@accent.200",
+      "tag_neutral_bg": "@neutral.900", "tag_neutral_fg": "@neutral.200",
+      "shadow": "#000000", "shadow_strength": 2.2,
+      "danger": "#dc8070", "warn": "#d0a552", "ok": "#7dbb7d",
+      "info": "#8fa6d6", "meta": "#67b2bf", "note": "#bb93c9"
+    }
+  }
+}

cjm_design_system-0.0.1/cjm_design_system/systems/netrunner/fonts/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2011 The Lora Project Authors (https://github.com/cyrealtype/Lora-Cyrillic), with Reserved Font Name "Lora".
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

cjm_design_system-0.0.1/cjm_design_system/systems/netrunner/tokens.json

@@ -0,0 +1,64 @@
+{
+  "schema": 1,
+  "name": "Netrunner",
+  "fonts": {
+    "heading": {"family": "Silkscreen", "weight": 700},
+    "body": {"family": "Courier Prime", "size": 13},
+    "mono": {"family": "Courier Prime", "size": 13},
+    "ui": {"family": "Courier Prime", "size": 13},
+    "files": ["Silkscreen*.ttf", "CourierPrime*.ttf"]
+  },
+  "space": {"1": 4, "2": 8, "3": 12, "4": 16, "6": 24, "8": 32},
+  "radius": {"sm": 0, "md": 0, "lg": 0},
+  "type": {"display": [30, 700], "section": [20, 400], "h1": [26, 700], "h2": [20, 700], "h3": [16, 400], "h4": [14, 400], "h5": [12, 400], "title": [13, 400], "kicker": [11, 400], "caption": [11, 400]},
+  "chamfer": 28,
+  "chrome": {"titlebar_ink": "fill_text"},
+  "ramps": {
+    "neutral": ["#e6e1e3", "#b9b1b4", "#8a8185", "#5e5559", "#3d3438", "#271f23", "#1a1216", "#120a0e", "#0a0407"],
+    "accent": ["#ffd6e1", "#ff9ab5", "#ff5a87", "#f02a5e", "#e0124c", "#b8003c", "#a00036", "#6a0024", "#3a0014"]
+  },
+  "reading": {"measure": 80, "line_height": 1.4},
+  "icons": {"set": "lucide", "stroke_width": 2.0},
+  "modes": {
+    "red": {
+      "bg": "#0a0407", "surface": "#140a0e", "text": "#e8124f", "accent": "#e8124f",
+      "fill": "#a00036", "fill_text": "#2a000e", "secondary": "#2ee6e6", "art": "#4a1018",
+      "accent_pressed": "#ff3b6f", "accent_text": "#2ee6e6",
+      "tag_bg": "#a00036", "tag_fg": "#2a000e", "tag_neutral_bg": "#27151b", "tag_neutral_fg": "#e8124f",
+      "shadow": "#000000", "shadow_strength": 2.0,
+      "danger": "#ff3b6f", "warn": "#f2d20c", "ok": "#36e07a", "info": "#2e9bff", "meta": "#2ee6e6", "note": "#ff7ae0"
+    },
+    "yellow": {
+      "bg": "#0a0904", "surface": "#13110a", "text": "#f2d20c", "accent": "#f2d20c",
+      "fill": "#9c8600", "fill_text": "#1c1700", "secondary": "#ff3b6f", "art": "#3f3608",
+      "accent_pressed": "#fff066", "accent_text": "#ff3b6f",
+      "tag_bg": "#9c8600", "tag_fg": "#1c1700", "tag_neutral_bg": "#26220f", "tag_neutral_fg": "#f2d20c",
+      "shadow": "#000000", "shadow_strength": 2.0,
+      "danger": "#ff3b6f", "warn": "#f2d20c", "ok": "#36e07a", "info": "#2e9bff", "meta": "#2ee6e6", "note": "#ff7ae0"
+    },
+    "green": {
+      "bg": "#040a06", "surface": "#09130c", "text": "#36e07a", "accent": "#36e07a",
+      "fill": "#0f7f40", "fill_text": "#00160a", "secondary": "#e6e62e", "art": "#0e3a1f",
+      "accent_pressed": "#7dffb0", "accent_text": "#e6e62e",
+      "tag_bg": "#0f7f40", "tag_fg": "#00160a", "tag_neutral_bg": "#10261a", "tag_neutral_fg": "#36e07a",
+      "shadow": "#000000", "shadow_strength": 2.0,
+      "danger": "#ff3b6f", "warn": "#f2d20c", "ok": "#36e07a", "info": "#2e9bff", "meta": "#2ee6e6", "note": "#ff7ae0"
+    },
+    "blue": {
+      "bg": "#04070b", "surface": "#0a1018", "text": "#2e9bff", "accent": "#2e9bff",
+      "fill": "#0a4c9c", "fill_text": "#000f22", "secondary": "#ff2e7a", "art": "#0d2a4a",
+      "accent_pressed": "#7cc2ff", "accent_text": "#ff2e7a",
+      "tag_bg": "#0a4c9c", "tag_fg": "#000f22", "tag_neutral_bg": "#0f1d2e", "tag_neutral_fg": "#2e9bff",
+      "shadow": "#000000", "shadow_strength": 2.0,
+      "danger": "#ff3b6f", "warn": "#f2d20c", "ok": "#36e07a", "info": "#2e9bff", "meta": "#2ee6e6", "note": "#ff7ae0"
+    },
+    "white": {
+      "bg": "#080808", "surface": "#111111", "text": "#e6e6e6", "accent": "#e6e6e6",
+      "fill": "#8a8a8a", "fill_text": "#0a0a0a", "secondary": "#2ee6e6", "art": "#2e2e2e",
+      "accent_pressed": "#ffffff", "accent_text": "#2ee6e6",
+      "tag_bg": "#8a8a8a", "tag_fg": "#0a0a0a", "tag_neutral_bg": "#222222", "tag_neutral_fg": "#e6e6e6",
+      "shadow": "#000000", "shadow_strength": 2.0,
+      "danger": "#ff3b6f", "warn": "#f2d20c", "ok": "#36e07a", "info": "#2e9bff", "meta": "#2ee6e6", "note": "#ff7ae0"
+    }
+  }
+}

cjm_design_system-0.0.1/cjm_design_system/tokens.py

@@ -0,0 +1,333 @@
+"""Token schema v1 — a design system as DATA, resolved headlessly (ruling
+a439c226: one canonical tokens file per system, shared by the web and Qt
+projections; DEC 0b1cfd81 fixed the shape).
+
+A tokens file holds: `name`, `schema` (= 1), `fonts` (heading / body, the
+optional mono and ui slots, the `files` globs registered at apply time),
+`space`, `radius`, `type` (role -> [px, weight]), `ramps` (100..900 steps for
+neutral and accent), `modes` (one semantic block per mode — a system's OWN
+modes: Classical light / dark, Netrunner red / yellow / green / blue / white —
+every block carrying the base semantics, the SIX STATE ROLES danger / warn /
+ok / info / meta / note, and any system-specific keys that pass straight
+through), the optional `scheme` map (OS light / dark -> a mode; absent = the
+system does not follow the OS), the optional `reading` block (measure,
+line_height — the reading-quality tokens), and the optional `icons`
+declaration (set + stroke_width; Lucide at 1.5 by default). `@ramp.step`
+references resolve against the ramps.
+
+Nothing here imports Qt — which is why the schema lives in its own library
+(design 0858bbd0): `check` and `resolve` run in tests, in the build CLIs and
+on the web side, and the Qt kit reads the same module. `resolve` emits ONE
+flat vocabulary — the QSS hole names ($bg $text $surface $accent $muted …)
+plus the state roles, the typography slots and the scale — and every web
+projection and kit widget reads that vocabulary (fork 1 of the design: no
+second vocabulary, no aliases)."""
+
+import json
+import re
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+SCHEMA_VERSION = 1
+STATE_ROLES: Tuple[str, ...] = ("danger", "warn", "ok", "info", "meta", "note")
+MODE_KEYS: Tuple[str, ...] = ("bg", "surface", "text", "accent", "accent_pressed", "accent_text",
+                              "tag_bg", "tag_fg", "tag_neutral_bg", "tag_neutral_fg", "shadow")
+TYPE_ROLES: Tuple[str, ...] = ("h1", "h2", "h3", "h4", "h5", "title", "kicker", "caption")
+RAMPS: Tuple[str, ...] = ("neutral", "accent")
+READING_DEFAULTS = {"measure": 68, "line_height": 1.45}
+ICONS_DEFAULTS = {"set": "lucide", "stroke_width": 1.5}
+
+_HEX = re.compile(r"^#[0-9a-fA-F]{6}$")
+_REF = re.compile(r"^@([a-z_]+)\.([1-9]00)$")
+
+
+class SchemaError(ValueError):
+    """A tokens file that violates schema v1 — every problem listed, so one
+    read of the message fixes the file (the loud refusal the ruling asks for)."""
+
+    def __init__(self, source: str, problems: List[str]):
+        self.source = source
+        self.problems = list(problems)
+        super().__init__("%s: %d schema problem(s):\n  - %s"
+                         % (source, len(problems), "\n  - ".join(problems)))
+
+
+# ---- color arithmetic (the CSS color-mix() equivalents) ---------------------
+
+def _rgb(h: str) -> Tuple[int, int, int]:
+    h = h.lstrip("#")
+    return int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)
+
+
+def to_hex(rgb: Iterable[float]) -> str:
+    return "#%02x%02x%02x" % tuple(max(0, min(255, round(c))) for c in rgb)
+
+
+def rgba(h: str, a: float) -> str:
+    """QSS rgba() with a 0-255 alpha (the form every Qt 6 version parses)."""
+    r, g, b = _rgb(h)
+    return f"rgba({r}, {g}, {b}, {round(max(0.0, min(1.0, a)) * 255)})"
+
+
+def mix(fg: str, bg: str, t: float) -> str:
+    """Flatten `fg` at opacity `t` over `bg` -> a solid hex (QPalette, painters,
+    rich-text HTML — anything that cannot take an rgba string)."""
+    f, b = _rgb(fg), _rgb(bg)
+    return to_hex(tuple(b[i] + (f[i] - b[i]) * t for i in range(3)))
+
+
+# ---- load / check -----------------------------------------------------------
+
+def load(path) -> Dict[str, Any]:
+    """Read a tokens file (JSON). `check` it before resolving anything."""
+    return json.loads(Path(path).read_text(encoding="utf-8"))
+
+
+def slug(tokens: Dict[str, Any]) -> str:
+    """The system's file-system / preference slug: lower-case, spaces -> dashes."""
+    return str(tokens.get("slug") or tokens.get("name", "system")).lower().replace(" ", "-")
+
+
+def modes(tokens: Dict[str, Any]) -> List[str]:
+    return list((tokens.get("modes") or {}).keys())
+
+
+def mode_for_scheme(tokens: Dict[str, Any], scheme: str) -> Optional[str]:
+    """The mode the system maps an OS scheme ("light" / "dark") onto — None
+    when the system declares no `scheme` map (it does not follow the OS)."""
+    m = tokens.get("scheme") or {}
+    mode = m.get(scheme)
+    return str(mode) if mode in (tokens.get("modes") or {}) else None
+
+
+def _ref(tokens: Dict[str, Any], v):
+    """Resolve '@accent.600' -> the ramp step (100..900); pass anything else."""
+    if isinstance(v, str) and v.startswith("@"):
+        ramp, step = v[1:].split(".")
+        return tokens["ramps"][ramp][int(step) // 100 - 1]
+    return v
+
+
+def check(tokens: Dict[str, Any], source: str = "<tokens>") -> None:
+    """Refuse a malformed system loudly: every missing / mistyped field named
+    in one SchemaError. A tokens file that passes here resolves for every
+    mode it declares."""
+    p: List[str] = []
+    if not isinstance(tokens, dict):
+        raise SchemaError(source, ["the tokens file must be a JSON object"])
+    if tokens.get("schema") != SCHEMA_VERSION:
+        p.append("schema: expected %d, got %r" % (SCHEMA_VERSION, tokens.get("schema")))
+    if not isinstance(tokens.get("name"), str) or not tokens.get("name"):
+        p.append("name: a non-empty string is required")
+    fonts = tokens.get("fonts")
+    if not isinstance(fonts, dict):
+        p.append("fonts: an object with heading and body slots is required")
+        fonts = {}
+    for slot in ("heading", "body"):
+        f = fonts.get(slot)
+        if not isinstance(f, dict) or not isinstance(f.get("family"), str):
+            p.append("fonts.%s.family: a string is required" % slot)
+    if isinstance(fonts.get("heading"), dict) and not isinstance(fonts["heading"].get("weight"), int):
+        p.append("fonts.heading.weight: an integer is required")
+    if isinstance(fonts.get("body"), dict) and not isinstance(fonts["body"].get("size"), (int, float)):
+        p.append("fonts.body.size: a pixel size is required")
+    for slot in ("mono", "ui"):
+        f = fonts.get(slot)
+        if f is not None and (not isinstance(f, dict) or not isinstance(f.get("family", ""), str)):
+            p.append("fonts.%s: an object with a family string when present" % slot)
+    if fonts.get("files") is not None and not (isinstance(fonts["files"], list)
+                                                and all(isinstance(x, str) for x in fonts["files"])):
+        p.append("fonts.files: a list of glob strings when present")
+    for scale in ("space", "radius"):
+        d = tokens.get(scale)
+        if not isinstance(d, dict) or not d or not all(isinstance(v, (int, float)) for v in d.values()):
+            p.append("%s: a non-empty object of pixel numbers is required" % scale)
+    typ = tokens.get("type")
+    if not isinstance(typ, dict):
+        p.append("type: an object of role -> [px, weight] is required")
+        typ = {}
+    for role in TYPE_ROLES:
+        if role not in typ:
+            p.append("type.%s: required" % role)
+    for role, val in typ.items():
+        if not (isinstance(val, list) and len(val) == 2
+                and all(isinstance(x, (int, float)) for x in val)):
+            p.append("type.%s: expected [px, weight]" % role)
+    ramps = tokens.get("ramps")
+    if not isinstance(ramps, dict):
+        p.append("ramps: an object with neutral and accent 9-step ramps is required")
+        ramps = {}
+    for name in RAMPS:
+        r = ramps.get(name)
+        if not (isinstance(r, list) and len(r) == 9 and all(isinstance(x, str) and _HEX.match(x) for x in r)):
+            p.append("ramps.%s: exactly nine #rrggbb steps (100..900) are required" % name)
+    mode_map = tokens.get("modes")
+    if not isinstance(mode_map, dict) or not mode_map:
+        p.append("modes: at least one mode block is required")
+        mode_map = {}
+    for mode, block in mode_map.items():
+        if not isinstance(block, dict):
+            p.append("modes.%s: expected an object" % mode)
+            continue
+        for key in MODE_KEYS + STATE_ROLES:
+            val = block.get(key)
+            if val is None:
+                p.append("modes.%s.%s: required%s" % (mode, key,
+                         " (a state role — every mode carries all six)" if key in STATE_ROLES else ""))
+            elif not isinstance(val, str) or not (_HEX.match(val) or _REF.match(val)):
+                p.append("modes.%s.%s: expected #rrggbb or @ramp.step, got %r" % (mode, key, val))
+            elif _REF.match(val):
+                ramp = _REF.match(val).group(1)
+                if ramp not in ramps or not isinstance(ramps.get(ramp), list) or len(ramps[ramp]) != 9:
+                    p.append("modes.%s.%s: %s references a ramp that does not exist" % (mode, key, val))
+        ss = block.get("shadow_strength", 1.0)
+        if not isinstance(ss, (int, float)):
+            p.append("modes.%s.shadow_strength: expected a number" % mode)
+    scheme = tokens.get("scheme")
+    if scheme is not None:
+        if not isinstance(scheme, dict) or set(scheme) - {"light", "dark"}:
+            p.append("scheme: an object with light and/or dark keys naming modes")
+        else:
+            for k, v in scheme.items():
+                if v not in mode_map:
+                    p.append("scheme.%s: %r is not a declared mode" % (k, v))
+    reading = tokens.get("reading")
+    if reading is not None:
+        if not isinstance(reading, dict):
+            p.append("reading: an object with measure / line_height")
+        else:
+            if "measure" in reading and not isinstance(reading["measure"], int):
+                p.append("reading.measure: an integer (characters)")
+            if "line_height" in reading and not isinstance(reading["line_height"], (int, float)):
+                p.append("reading.line_height: a number (ratio)")
+    icons = tokens.get("icons")
+    if icons is not None:
+        if not isinstance(icons, dict) or not isinstance(icons.get("set", "lucide"), str):
+            p.append("icons: an object with a set name (and an optional stroke_width)")
+        elif "stroke_width" in icons and not isinstance(icons["stroke_width"], (int, float)):
+            p.append("icons.stroke_width: a number")
+    chrome = tokens.get("chrome")
+    if chrome is not None:
+        if not isinstance(chrome, dict):
+            p.append("chrome: an object naming the shell chrome's ink (titlebar_ink: a mode key)")
+        else:
+            ink = chrome.get("titlebar_ink", "text")
+            if not isinstance(ink, str) or any(ink not in (block or {}) and ink not in ("text", "accent")
+                                               for block in mode_map.values() if isinstance(block, dict)):
+                p.append("chrome.titlebar_ink: must name a key every mode carries (e.g. fill_text)")
+    if p:
+        raise SchemaError(source, p)
+
+
+# ---- resolve ----------------------------------------------------------------
+
+def resolve(tokens: Dict[str, Any], mode: Optional[str] = None) -> Dict[str, str]:
+    """tokens + mode -> the flat vocabulary every projection reads: the QSS
+    holes (colors, tints, solids, radii, spacing, type scale), the six state
+    roles + `dim`, the four font slots with pixel sizes, and the reading
+    tokens. `mode` None = the system's first mode."""
+    mode = mode or modes(tokens)[0]
+    m = {k: _ref(tokens, v) for k, v in tokens["modes"][mode].items()}
+    bg, text, acc = m["bg"], m["text"], m["accent"]
+    f = tokens["fonts"]
+    body = f["body"]
+    mono = f.get("mono") or {}
+    ui = f.get("ui") or {}
+    reading = {**READING_DEFAULTS, **(tokens.get("reading") or {})}
+    icons = {**ICONS_DEFAULTS, **(tokens.get("icons") or {})}
+    v: Dict[str, str] = {
+        "system": slug(tokens), "name": str(tokens["name"]), "mode": mode,
+        "bg": bg, "surface": m["surface"], "text": text,
+        "accent": acc, "accent_pressed": m["accent_pressed"], "accent_text": m["accent_text"],
+        "tag_bg": m["tag_bg"], "tag_fg": m["tag_fg"],
+        "tag_neutral_bg": m["tag_neutral_bg"], "tag_neutral_fg": m["tag_neutral_fg"],
+        # ink tints (color-mix(text N%, transparent) in the CSS)
+        "divider": rgba(text, .16), "divider_strong": rgba(text, .30), "line": rgba(text, .55),
+        "border_hover": rgba(text, .45), "muted": rgba(text, .55),
+        "label": rgba(text, .70), "header_text": rgba(text, .60),
+        "text_hover": rgba(text, .07), "text_pressed": rgba(text, .14),
+        "row_hover": rgba(text, .04), "row_alt": rgba(text, .025),
+        "disabled_text": rgba(text, .35), "disabled_border": rgba(text, .10),
+        "scroll_handle": rgba(text, .18), "scroll_handle_hover": rgba(text, .34),
+        # accent tints
+        "accent_hover": rgba(acc, .12), "accent_press_tint": rgba(acc, .22),
+        "ghost_hover": rgba(acc, .10), "ghost_press": rgba(acc, .18),
+        "selection": rgba(acc, .30),
+        # solid equivalents for QPalette / painting / rich-text HTML
+        "divider_solid": mix(text, bg, .16), "divider_strong_solid": mix(text, bg, .30),
+        "line_solid": mix(text, bg, .55),
+        "muted_solid": mix(text, bg, .55), "label_solid": mix(text, bg, .70),
+        "selection_solid": mix(acc, bg, .30), "row_alt_solid": mix(text, bg, .025),
+        "disabled_solid": mix(text, bg, .35),
+        "backdrop": rgba(tokens["ramps"]["neutral"][8], .5),
+        "shadow": m["shadow"], "shadow_strength": str(m.get("shadow_strength", 1.0)),
+        # the state channel: six roles + dim (muted text, the seventh word the spines use)
+        **{role: m[role] for role in STATE_ROLES},
+        "dim": mix(text, bg, .55),
+        # typography slots (pixel sizes — Qt setPixelSize, CSS px)
+        "font_heading": f["heading"]["family"], "heading_weight": str(f["heading"]["weight"]),
+        "font_body": body["family"], "fs_body": str(body["size"]),
+        "body_weight": str(body.get("weight", 400)),
+        "font_mono": str(mono.get("family", "")), "fs_mono": str(mono.get("size", max(1, body["size"] - 1))),
+        "font_ui": str(ui.get("family") or body["family"]), "fs_ui": str(ui.get("size", body["size"])),
+        # reading
+        "measure": str(reading["measure"]), "line_height": str(reading["line_height"]),
+        # icons
+        "icon_set": str(icons["set"]), "icon_stroke": str(icons["stroke_width"]),
+    }
+    for k, val in m.items():  # system-specific mode keys (e.g. fill, secondary) pass through
+        v.setdefault(k, str(val))
+        if isinstance(val, str) and val.startswith("#"):
+            v.setdefault(f"{k}_hover", rgba(val, .14))
+    # the shell chrome's ink (ruling d1e3043e): the title bar's glyphs are
+    # painted pixmaps, so the system names which mode key inks them — the
+    # text by default, a bar's own contrast key (Netrunner: fill_text) else
+    chrome = tokens.get("chrome") or {}
+    v["titlebar_ink"] = v.get(str(chrome.get("titlebar_ink", "text")), text)
+    for k, px in tokens["radius"].items():
+        v[f"radius_{k}"] = str(round(px))
+    for k, px in tokens["space"].items():
+        v[f"space_{k}"] = str(round(px))
+    for k, (size, weight) in tokens["type"].items():
+        v[f"fs_{k}"], v[f"fw_{k}"] = str(size), str(weight)
+    return v
+
+
+# ---- the web projection -----------------------------------------------------
+
+def to_css(tokens: Dict[str, Any], selector: str = ":root") -> str:
+    """The CSS custom-properties layer for a system — the ruling's second
+    consumer (the Quarto site 8079ae0f derives its theme from this, never from
+    Bootswatch). The first mode lands on `selector`; every other mode lands on
+    `selector[data-mode="<mode>"]`, so a page switches modes by one attribute.
+    Ramps, spacing, radii and the type scale are mode-independent and emitted
+    once. Variable names mirror the resolved vocabulary with dashes."""
+    out: List[str] = []
+    first = modes(tokens)[0]
+    static: List[str] = []
+    for ramp, steps in tokens["ramps"].items():
+        static += [f"  --{ramp}-{(i + 1) * 100}: {c};" for i, c in enumerate(steps)]
+    static += [f"  --space-{k}: {v}px;" for k, v in tokens["space"].items()]
+    static += [f"  --radius-{k}: {v}px;" for k, v in tokens["radius"].items()]
+    static += [f"  --fs-{k}: {s}px;\n  --fw-{k}: {w};" for k, (s, w) in tokens["type"].items()]
+    f = tokens["fonts"]
+    static += [f'  --font-heading: "{f["heading"]["family"]}";',
+               f'  --heading-weight: {f["heading"]["weight"]};',
+               f'  --font-body: "{f["body"]["family"]}";',
+               f'  --fs-body: {f["body"]["size"]}px;']
+    if f.get("mono", {}).get("family"):
+        static.append(f'  --font-mono: "{f["mono"]["family"]}";')
+    reading = {**READING_DEFAULTS, **(tokens.get("reading") or {})}
+    static += [f"  --measure: {reading['measure']}ch;", f"  --line-height: {reading['line_height']};"]
+    per_mode = tuple(MODE_KEYS) + STATE_ROLES + ("dim", "muted", "divider", "divider_strong", "line",
+                                                  "label", "selection", "accent_hover", "row_hover")
+    for mode in modes(tokens):
+        v = resolve(tokens, mode)
+        keys = list(per_mode) + [k for k in tokens["modes"][mode] if k not in per_mode and k in v]
+        body = [f"  --{k.replace('_', '-')}: {v[k]};" for k in keys if k != "shadow_strength"]
+        body.append(f"  --shadow-strength: {v['shadow_strength']};")
+        sel = selector if mode == first else f'{selector}[data-mode="{mode}"]'
+        block = body if mode != first else static + body
+        out.append("%s {\n%s\n}" % (sel, "\n".join(block)))
+    return "/* %s — design tokens, projected by cjm-design-system (schema v%d) */\n%s\n" % (
+        tokens["name"], SCHEMA_VERSION, "\n\n".join(out))

cjm_design_system-0.0.1/cjm_design_system/tools/__init__.py

@@ -0,0 +1,5 @@
+"""Design-system tools (run as modules):
+
+    python -m cjm_design_system.tools.css_to_tokens styles.css -o mysystem/tokens.json --name "My System"
+    python -m cjm_design_system.tools.build tokens.json -o build/     # check + the CSS layer
+"""

cjm_design_system-0.0.1/cjm_design_system/tools/build.py

@@ -0,0 +1,37 @@
+"""Build the static web projections of a design system: the CSS
+custom-properties layer (`tokens.to_css`, the web consumer 8079ae0f), after
+the schema check. The Qt projections (QSS per mode, recolored icons) build
+from the kit (`python -m cjm_substrate_qt_kit.tools.build`).
+
+    python -m cjm_design_system.tools.build netrunner -o build/
+    python -m cjm_design_system.tools.build path/to/mysystem/tokens.json --check
+"""
+
+import argparse
+from pathlib import Path
+
+from .. import systems, tokens as T
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(prog="python -m cjm_design_system.tools.build")
+    ap.add_argument("system", help="a vendored slug or a tokens.json path")
+    ap.add_argument("-o", "--out", default="build")
+    ap.add_argument("--check", action="store_true", help="validate only; write nothing")
+    a = ap.parse_args(argv)
+    path = systems.tokens_path(a.system)
+    tok = T.load(path)
+    T.check(tok, str(path))
+    if a.check:
+        print(f"{T.slug(tok)}: schema v{T.SCHEMA_VERSION} OK — modes {T.modes(tok)}")
+        return 0
+    out = Path(a.out)
+    out.mkdir(parents=True, exist_ok=True)
+    css = out / f"{T.slug(tok)}.css"
+    css.write_text(T.to_css(tok), encoding="utf-8")
+    print(f"wrote {css}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cjm_design_system-0.0.1/cjm_design_system/tools/css_to_tokens.py

@@ -0,0 +1,123 @@
+"""Import a web-first design system's CSS into a schema-v1 tokens file.
+
+    python -m cjm_design_system.tools.css_to_tokens styles.css -o mysystem/tokens.json [--name "My System"]
+
+Reads the `:root { --color-*; --font-*; --space-*; --radius-* }` block (the
+shape a Claude Design handoff uses) and writes light-mode tokens straight
+from it; dark mode is DERIVED from the 100-900 ramps and the six state roles
+are seeded from the reading-tuned set — review both by eye in the
+gallery (a derivation is a starting point, never a verdict; ruling a439c226:
+the CSS is an import source, the tokens file is the source of truth). The
+output passes `tokens.check` or the tool refuses to write it."""
+
+import argparse
+import json
+import re
+from pathlib import Path
+
+from .. import tokens as T
+
+VAR = re.compile(r"--([\w-]+)\s*:\s*([^;]+);")
+HEX = re.compile(r"#[0-9a-fA-F]{6}")
+
+STATE_LIGHT = {"danger": "#a4382a", "warn": "#8c5e14", "ok": "#3a7a3a",
+               "info": "#4a5f96", "meta": "#2a6f7c", "note": "#7a4a8a"}
+STATE_DARK = {"danger": "#dc8070", "warn": "#d0a552", "ok": "#7dbb7d",
+              "info": "#8fa6d6", "meta": "#67b2bf", "note": "#bb93c9"}
+
+
+def parse_root(css: str) -> dict:
+    css = re.sub(r"/\*.*?\*/", "", css, flags=re.S)
+    m = re.search(r":root\s*{(.*?)}", css, flags=re.S)
+    if not m:
+        raise SystemExit("no :root block found")
+    return {k: v.strip() for k, v in VAR.findall(m.group(1))}
+
+
+def family(v: str) -> str:
+    return v.split(",")[0].strip().strip("'\"")
+
+
+def px(v: str) -> float:
+    return float(re.sub(r"[^\d.]", "", v) or 0)
+
+
+def ramp(vars_: dict, role: str):
+    steps = [vars_.get(f"color-{role}-{s}") for s in range(100, 1000, 100)]
+    return steps if all(steps) else None
+
+
+def darker(h: str, k: float) -> str:
+    r, g, b = (int(h[i:i + 2], 16) for i in (1, 3, 5))
+    return "#%02x%02x%02x" % tuple(round(c * k) for c in (r, g, b))
+
+
+def convert(css: str, name: str) -> dict:
+    v = parse_root(css)
+    col = lambda k: (HEX.findall(v.get(f"color-{k}", "")) or [None])[0]  # noqa: E731
+    neutral, accent = ramp(v, "neutral"), ramp(v, "accent")
+    if not (neutral and accent):
+        raise SystemExit("need --color-neutral-100..900 and --color-accent-100..900 ramps")
+    hw = int(px(v.get("font-heading-weight", "600")))
+    heading, body = family(v["font-heading"]), family(v["font-body"])
+    mono = family(v["font-mono"]) if v.get("font-mono") else ""
+    light_ground = int(col("bg")[1:3], 16) > 128
+    light = {
+        "bg": col("bg"), "surface": col("surface"), "text": col("text"), "accent": col("accent"),
+        "accent_pressed": "@accent.600", "accent_text": "@accent.700",
+        "tag_bg": "@accent.100", "tag_fg": "@accent.800",
+        "tag_neutral_bg": "@neutral.100", "tag_neutral_fg": "@neutral.800",
+        "shadow": "@neutral.900", "shadow_strength": 1.0, **STATE_LIGHT,
+    }
+    dark = {
+        "bg": darker(neutral[8], .68), "surface": darker(neutral[8], .86), "text": neutral[0],
+        "accent": accent[4] if light_ground else col("accent"),
+        "accent_pressed": "@accent.400", "accent_text": "@accent.300",
+        "tag_bg": "@accent.900", "tag_fg": "@accent.200",
+        "tag_neutral_bg": "@neutral.900", "tag_neutral_fg": "@neutral.200",
+        "shadow": "#000000", "shadow_strength": 2.2, **STATE_DARK,
+    }
+    modes = {"light": light, "dark": dark} if light_ground else {"dark": light}
+    out = {
+        "schema": T.SCHEMA_VERSION,
+        "name": name,
+        "fonts": {
+            "heading": {"family": heading, "weight": hw},
+            "body": {"family": body, "size": 15},
+            "mono": {"family": mono, "size": 13},
+            "files": [heading.replace(" ", "") + "*.ttf", body.replace(" ", "") + "*.ttf"],
+        },
+        "space": {k.split("-")[1]: px(x) for k, x in v.items() if re.fullmatch(r"space-\d+", k)},
+        "radius": {k.split("-")[1]: px(x) for k, x in v.items() if re.fullmatch(r"radius-\w+", k)},
+        "type": {"h1": [42, 400], "h2": [32, 400], "h3": [25, hw], "h4": [20, hw], "h5": [16, hw],
+                 "title": [17, hw], "kicker": [10, 400], "caption": [11, 400]},
+        "ramps": {"neutral": neutral, "accent": accent},
+        "scheme": {"light": "light", "dark": "dark"} if light_ground else {"dark": "dark"},
+        "reading": dict(T.READING_DEFAULTS),
+        "icons": dict(T.ICONS_DEFAULTS),
+        "modes": modes,
+    }
+    if not out["space"]:
+        out["space"] = {"1": 4, "2": 8, "3": 12, "4": 16, "6": 24, "8": 32}
+    if not out["radius"]:
+        out["radius"] = {"sm": 2, "md": 4, "lg": 8}
+    T.check(out, f"<converted from CSS: {name}>")
+    return out
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(prog="python -m cjm_design_system.tools.css_to_tokens")
+    ap.add_argument("css")
+    ap.add_argument("-o", "--out", required=True)
+    ap.add_argument("--name")
+    a = ap.parse_args(argv)
+    name = a.name or Path(a.out).parent.name.title()
+    out = convert(Path(a.css).read_text(encoding="utf-8"), name)
+    Path(a.out).parent.mkdir(parents=True, exist_ok=True)
+    Path(a.out).write_text(json.dumps(out, indent=2) + "\n", encoding="utf-8")
+    print(f"wrote {a.out}  modes={list(out['modes'])}  heading={out['fonts']['heading']['family']}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cjm_design_system-0.0.1/cjm_design_system.egg-info/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: cjm-design-system
+Version: 0.0.1
+Summary: A design system as data (ruling a439c226): token schema v1 with its check and its headless resolution into one flat vocabulary, the CSS custom-properties projection for the web, the vendored seed systems (Classical, Netrunner) with their fonts, and the importer for a web-first system's CSS. No Qt: the Qt kit (cjm-substrate-qt-kit) consumes the same tokens. Born on-graph.
+Author-email: "Christian J. Mills" <9126128+cj-mills@users.noreply.github.com>
+License: Apache-2.0
+Project-URL: Repository, https://github.com/cj-mills/cjm-design-system
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# cjm-design-system
+
+<!-- generated from the context graph by `cjm-context-graph readme` — do not edit by hand; edit the graph (the urge to hand-edit = move it on-graph) -->
+
+A design system as data (ruling a439c226): token schema v1 with its check and its headless resolution into one flat vocabulary, the CSS custom-properties projection for the web, the vendored seed systems Classical and Netrunner with their OFL fonts, and the importer for a web-first system's CSS. Nothing here imports Qt, so a web build never needs PySide6; the Qt kit (cjm-substrate-qt-kit) consumes the same tokens and keeps only what Qt reads. Born out of the kit by design 0858bbd0, the theme half of the public-site redesign build 8079ae0f.
+
+## Modules
+
+- **`cjm_design_system.__init__`** — A design system as DATA (ruling a439c226): one canonical tokens file per
+- **`cjm_design_system.systems.__init__`** — The design systems this library ships as DATA (ruling a439c226): one
+- **`cjm_design_system.tokens`** — Token schema v1 — a design system as DATA, resolved headlessly (ruling
+- **`cjm_design_system.tools.__init__`** — Design-system tools (run as modules):
+- **`cjm_design_system.tools.build`** — Build the static web projections of a design system: the CSS
+- **`cjm_design_system.tools.css_to_tokens`** — Import a web-first design system's CSS into a schema-v1 tokens file.
+
+## API
+
+### `cjm_design_system.systems.__init__`
+
+- `available` _function_ — Every vendored system slug (a directory carrying a tokens.json).
+- `locate` _function_ — The directory of a system: a vendored slug, a directory holding a
+- `tokens_path` _function_
+
+### `cjm_design_system.tokens`
+
+- `SchemaError` _class_ — A tokens file that violates schema v1 — every problem listed, so one
+- `check` _function_ — Refuse a malformed system loudly: every missing / mistyped field named
+- `load` _function_ — Read a tokens file (JSON). `check` it before resolving anything.
+- `mix` _function_ — Flatten `fg` at opacity `t` over `bg` -> a solid hex (QPalette, painters,
+- `mode_for_scheme` _function_ — The mode the system maps an OS scheme ("light" / "dark") onto — None
+- `modes` _function_
+- `resolve` _function_ — tokens + mode -> the flat vocabulary every projection reads: the QSS
+- `rgba` _function_ — QSS rgba() with a 0-255 alpha (the form every Qt 6 version parses).
+- `slug` _function_ — The system's file-system / preference slug: lower-case, spaces -> dashes.
+- `to_css` _function_ — The CSS custom-properties layer for a system — the ruling's second
+- `to_hex` _function_
+
+### `cjm_design_system.tools.build`
+
+- `main` _function_
+
+### `cjm_design_system.tools.css_to_tokens`
+
+- `convert` _function_
+- `darker` _function_
+- `family` _function_
+- `main` _function_
+- `parse_root` _function_
+- `px` _function_
+- `ramp` _function_
+
+## Dependencies
+
+**Used by:** `cjm-context-graph-projection`, `cjm-substrate-qt-kit`

cjm_design_system-0.0.1/cjm_design_system.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+README.md
+pyproject.toml
+cjm_design_system/__init__.py
+cjm_design_system/tokens.py
+cjm_design_system.egg-info/PKG-INFO
+cjm_design_system.egg-info/SOURCES.txt
+cjm_design_system.egg-info/dependency_links.txt
+cjm_design_system.egg-info/top_level.txt
+cjm_design_system/systems/__init__.py
+cjm_design_system/systems/classical/tokens.json
+cjm_design_system/systems/classical/fonts/CormorantGaramond-Italic[wght].ttf
+cjm_design_system/systems/classical/fonts/CormorantGaramond[wght].ttf
+cjm_design_system/systems/classical/fonts/Lora-Italic[wght].ttf
+cjm_design_system/systems/classical/fonts/Lora[wght].ttf
+cjm_design_system/systems/classical/fonts/OFL.txt
+cjm_design_system/systems/netrunner/tokens.json
+cjm_design_system/systems/netrunner/fonts/CourierPrime-Bold.ttf
+cjm_design_system/systems/netrunner/fonts/CourierPrime-Italic.ttf
+cjm_design_system/systems/netrunner/fonts/CourierPrime-Regular.ttf
+cjm_design_system/systems/netrunner/fonts/OFL.txt
+cjm_design_system/systems/netrunner/fonts/Silkscreen-Bold.ttf
+cjm_design_system/systems/netrunner/fonts/Silkscreen-Regular.ttf
+cjm_design_system/tools/__init__.py
+cjm_design_system/tools/build.py
+cjm_design_system/tools/css_to_tokens.py
+tests/test_tokens.py

cjm_design_system-0.0.1/cjm_design_system.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cjm_design_system-0.0.1/cjm_design_system.egg-info/top_level.txt

@@ -0,0 +1 @@
+cjm_design_system

cjm_design_system-0.0.1/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cjm-design-system"
+dynamic = ["version"]
+description = "A design system as data (ruling a439c226): token schema v1 with its check and its headless resolution into one flat vocabulary, the CSS custom-properties projection for the web, the vendored seed systems (Classical, Netrunner) with their fonts, and the importer for a web-first system's CSS. No Qt: the Qt kit (cjm-substrate-qt-kit) consumes the same tokens. Born on-graph."
+readme = "README.md"
+requires-python = ">=3.12"
+license = {text = "Apache-2.0"}
+authors = [{name = "Christian J. Mills", email = "9126128+cj-mills@users.noreply.github.com"}]
+classifiers = ["Programming Language :: Python :: 3", "Programming Language :: Python :: 3 :: Only"]
+dependencies = []
+
+[project.urls]
+Repository = "https://github.com/cj-mills/cjm-design-system"
+
+[tool.setuptools.dynamic]
+version = {attr = "cjm_design_system.__version__"}
+
+[tool.setuptools.packages.find]
+include = ["cjm_design_system*"]
+
+[tool.setuptools.package-data]
+cjm_design_system = ["systems/*/tokens.json", "systems/*/fonts/*.ttf", "systems/*/fonts/*.otf",
+                     "systems/*/fonts/OFL.txt"]

cjm_design_system-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cjm_design_system-0.0.1/tests/test_tokens.py

@@ -0,0 +1,109 @@
+"""Schema v1 contract: both vendored systems pass `check`; a malformed system
+is refused loudly with every problem named; `resolve` emits the one
+vocabulary (holes, state roles, dim, typography slots, scale) headlessly;
+`to_css` projects the same tokens for the web side."""
+
+import copy
+import json
+
+import pytest
+
+from cjm_design_system import systems
+from cjm_design_system import tokens as T
+
+
+@pytest.fixture(params=["classical", "netrunner"])
+def system(request):
+    return request.param, T.load(systems.tokens_path(request.param))
+
+
+def test_vendored_systems_pass_check(system):
+    slug, tok = system
+    T.check(tok, slug)
+    assert T.slug(tok) == slug
+    assert len(T.modes(tok)) >= 2
+
+
+def test_check_refuses_loudly_naming_every_problem():
+    tok = T.load(systems.tokens_path("classical"))
+    bad = copy.deepcopy(tok)
+    del bad["modes"]["light"]["danger"]            # a state role missing
+    bad["modes"]["dark"]["accent"] = "red"         # not a hex / ref
+    bad["ramps"]["accent"] = bad["ramps"]["accent"][:5]   # short ramp
+    bad["scheme"]["dark"] = "midnight"             # names a mode that does not exist
+    bad["schema"] = 2
+    with pytest.raises(T.SchemaError) as e:
+        T.check(bad, "bad.json")
+    msg = str(e.value)
+    assert "bad.json" in msg
+    for needle in ("modes.light.danger", "modes.dark.accent", "ramps.accent", "scheme.dark", "schema:"):
+        assert needle in msg, needle
+    assert len(e.value.problems) >= 5
+
+
+def test_resolve_emits_the_one_vocabulary(system):
+    slug, tok = system
+    for mode in T.modes(tok):
+        v = T.resolve(tok, mode)
+        assert v["system"] == slug and v["mode"] == mode
+        for key in ("bg", "surface", "text", "accent", "muted", "muted_solid", "divider", "divider_solid",
+                    "selection", "selection_solid", "disabled_text", "font_heading", "font_body",
+                    "font_mono", "font_ui", "fs_body", "fs_mono", "fs_ui", "measure", "line_height",
+                    "radius_md", "space_2", "fs_h1", "fw_h1", "icon_stroke"):
+            assert key in v, key
+        for role in T.STATE_ROLES:
+            assert v[role].startswith("#"), role
+        assert v["dim"].startswith("#") and v["dim"] == v["muted_solid"]
+        # a ramp reference resolved to its step
+        assert not v["accent_pressed"].startswith("@")
+
+
+def test_resolve_passes_system_keys_through():
+    tok = T.load(systems.tokens_path("netrunner"))
+    v = T.resolve(tok, "blue")
+    assert v["fill"] == tok["modes"]["blue"]["fill"]
+    assert v["fill_hover"].startswith("rgba(")
+    assert v["fs_display"] == "30"
+
+
+def test_mode_for_scheme_follows_only_declared_maps():
+    classical = T.load(systems.tokens_path("classical"))
+    netrunner = T.load(systems.tokens_path("netrunner"))
+    assert T.mode_for_scheme(classical, "dark") == "dark"
+    assert T.mode_for_scheme(netrunner, "dark") is None
+
+
+def test_color_helpers():
+    assert T.rgba("#ff0000", .5) == "rgba(255, 0, 0, 128)"
+    assert T.mix("#000000", "#ffffff", .5) == "#808080"
+    assert T.to_hex((300, -5, 12.6)) == "#ff000d"
+
+
+def test_to_css_projects_every_mode(system):
+    slug, tok = system
+    css = T.to_css(tok)
+    first = T.modes(tok)[0]
+    assert ":root {" in css
+    for mode in T.modes(tok)[1:]:
+        assert f':root[data-mode="{mode}"]' in css
+    assert "--neutral-900:" in css and "--fs-h1:" in css and "--font-body:" in css
+    assert f"--bg: {T.resolve(tok, first)['bg']};" in css
+    assert "--danger:" in css and "--dim:" in css
+
+
+def test_load_round_trips_json(tmp_path):
+    tok = T.load(systems.tokens_path("classical"))
+    p = tmp_path / "tokens.json"
+    p.write_text(json.dumps(tok))
+    assert T.load(p) == tok
+
+
+def test_systems_locate_by_slug_dir_and_path(tmp_path):
+    root = systems.locate("classical")
+    assert (root / "tokens.json").is_file()
+    assert systems.locate(root) == root
+    assert systems.locate(root / "tokens.json") == root
+    with pytest.raises(KeyError) as e:
+        systems.locate("no-such-system")
+    assert "classical" in str(e.value)
+    assert systems.available() == ["classical", "netrunner"]