@cssints/css-grammar 0.0.0-stage → 0.1.0

package/dist/twin.d.mts

@@ -0,0 +1,12 @@
+import { ParseError, TwinError } from "./errors.mjs";
+import { Node, nullable } from "./twin-core.mjs";
+import { Effect } from "effect";
+//#region src/twin.d.ts
+/** The grammar as a tree, memoized by its text. */
+export declare const parse: (grammar: string) => Effect.Effect<Node, ParseError, never>;
+/** Whether `s` is a complete value of the grammar `syntax`; `pending`: a var(), env() or if() in it stands for any value. */
+export declare const matches: (syntax: string, s: string, pending?: boolean | undefined) => Effect.Effect<boolean, TwinError, never>;
+/** Twin of Valid<P, S>: the value, or the furthest point it reached and what the grammar expected there. */
+export declare const valid: (p: string, s: string) => Effect.Effect<string, TwinError, never>;
+//#endregion
+export { type Node, nullable };

package/dist/twin.mjs

@@ -0,0 +1,38 @@
+import { ParseError, isTwinError } from "./errors.mjs";
+import { matches as matches$1, nullable, parseGrammar, valid as valid$1 } from "./twin-core.mjs";
+import { Effect } from "effect";
+//#region src/twin.ts
+const grammarError = (grammar, e) => isTwinError(e) ? e : new ParseError({
+	message: `grammar: ${String(e)}`,
+	grammar,
+	position: 0,
+	expected: []
+});
+/** The grammar as a tree, memoized by its text. */
+const parse = Effect.fn("twin.parse")(function* (grammar) {
+	return yield* Effect.try({
+		try: () => parseGrammar(grammar),
+		catch: (e) => e instanceof ParseError ? e : new ParseError({
+			message: `grammar: ${String(e)}`,
+			grammar,
+			position: 0,
+			expected: []
+		})
+	});
+});
+/** Whether `s` is a complete value of the grammar `syntax`; `pending`: a var(), env() or if() in it stands for any value. */
+const matches = Effect.fnUntraced(function* (syntax, s, pending) {
+	return yield* Effect.try({
+		try: () => matches$1(syntax, s, pending),
+		catch: (e) => grammarError(syntax, e)
+	});
+});
+/** Twin of Valid<P, S>: the value, or the furthest point it reached and what the grammar expected there. */
+const valid = Effect.fnUntraced(function* (p, s) {
+	return yield* Effect.try({
+		try: () => valid$1(p, s),
+		catch: (e) => grammarError(p, e)
+	});
+});
+//#endregion
+export { matches, nullable, parse, valid };

package/dist/values.d.mts

@@ -0,0 +1,28 @@
+//#region src/values.d.ts
+export declare class CSSStyleValue<T extends string = string> {
+  readonly "~type": T;
+}
+export declare class CSSUnitValue<T extends string = string> extends CSSStyleValue<T> {
+  readonly value: number;
+  readonly unit: string;
+  constructor(value: number, unit: string);
+  toString(): string;
+}
+export declare class CSSColorValue extends CSSStyleValue<"color"> {
+  readonly value: string;
+  constructor(value: string);
+  toString(): string;
+}
+export declare class CSSImageValue extends CSSStyleValue<"image"> {
+  readonly value: string;
+  constructor(value: string);
+  toString(): string;
+}
+export declare const CSS: {
+  px: (v: number) => CSSUnitValue<"length">;
+  rem: (v: number) => CSSUnitValue<"length">;
+  em: (v: number) => CSSUnitValue<"length">;
+  percent: (v: number) => CSSUnitValue<"percentage">;
+  number: (v: number) => CSSUnitValue<"number">;
+};
+//#endregion

package/dist/values.mjs

@@ -0,0 +1,44 @@
+//#region src/values.ts
+var CSSStyleValue = class {};
+var CSSUnitValue = class extends CSSStyleValue {
+	value;
+	unit;
+	constructor(value, unit) {
+		super();
+		this.value = value;
+		this.unit = unit;
+	}
+	toString() {
+		return `${this.value}${this.unit === "percent" ? "%" : this.unit === "number" ? "" : this.unit}`;
+	}
+};
+var CSSColorValue = class extends CSSStyleValue {
+	value;
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	toString() {
+		return this.value;
+	}
+};
+var CSSImageValue = class extends CSSStyleValue {
+	value;
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	toString() {
+		return this.value;
+	}
+};
+const unit = (u) => (v) => new CSSUnitValue(v, u);
+const CSS = {
+	px: unit("px"),
+	rem: unit("rem"),
+	em: unit("em"),
+	percent: unit("percent"),
+	number: unit("number")
+};
+//#endregion
+export { CSS, CSSColorValue, CSSImageValue, CSSStyleValue, CSSUnitValue };

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "@cssints/css-grammar",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Type-level and runtime recognizer of CSS values over mdn-data grammars (the engine of cssints)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alexeiaccio/css-in-ts-compiler.git",
+    "directory": "packages/css-grammar"
+  },
+  "homepage": "https://cssints.dev",
+  "files": [
+    "dist",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    "./*": {
+      "types": "./dist/*.d.mts",
+      "default": "./dist/*.mjs"
+    }
+  },
+  "dependencies": {
+    "@mdn/browser-compat-data": "8.1.3",
+    "browserslist": "4.29.1",
+    "effect": "4.0.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}