@valancex/common 0.0.0-stage → 0.12.0

package/dist/state.js

@@ -0,0 +1,33 @@
+// The application's state beyond the page, however it was declared: field by field (`field(type, default)`), or as a hand-built schema with a separate initial value. Both become one thing here.
+// No Node and no Vite: the browser entry loads this too.
+import { Schema } from "effect";
+import { FIELD } from "./index.js";
+const isField = (value) => typeof value === "object" && value !== null && FIELD in value;
+/** The state a definition declares, or `undefined` for none. */
+export const stateOf = (author) => {
+    const state = author?.state;
+    if (state === undefined) {
+        return undefined;
+    }
+    const entries = Object.entries(state);
+    // A hand-built state is `{ schema, initial }` where `schema` is a Schema; a field named `schema` is a Field.
+    if (!entries.some(([, value]) => isField(value)) && "schema" in state && Schema.isSchema(state["schema"])) {
+        return { schema: state["schema"], initial: (state["initial"] ?? {}), declared: false };
+    }
+    const fields = entries.filter((entry) => isField(entry[1]));
+    return {
+        schema: Schema.Struct(Object.fromEntries(fields.map(([name, each]) => [name, each.schema]))),
+        initial: Object.fromEntries(fields.map(([name, each]) => [name, each.initial])),
+        declared: true,
+    };
+};
+/** The fields whose default is not a value of the field's own type (only for a state declared field by field). */
+export const badDefaults = (author) => {
+    const state = stateOf(author);
+    if (state === undefined || !state.declared) {
+        return [];
+    }
+    return Object.entries(state.schema.fields)
+        .filter(([name, schema]) => !Schema.is(schema)(state.initial[name]))
+        .map(([name]) => name);
+};

package/dist/transport.d.ts

@@ -0,0 +1,37 @@
+import type { Effect } from "effect";
+export type Method = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+/** Why a request did not give a value. None of them carries the response text, the address or a header: those can hold a secret. */
+export type HttpError = {
+    readonly _tag: "Offline";
+} | {
+    readonly _tag: "Status";
+    readonly status: number;
+} | {
+    readonly _tag: "Decode";
+} | {
+    readonly _tag: "Timeout";
+} | {
+    readonly _tag: "Aborted";
+} | {
+    readonly _tag: "TooLarge";
+} | {
+    readonly _tag: "Unsafe";
+    readonly reason: string;
+};
+/** The request as it goes out: already checked, with its final address. Headers are lower-case. */
+export interface TransportRequest {
+    readonly method: Method;
+    readonly url: string;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body?: string;
+    readonly timeoutMs: number;
+}
+/** The answer as it came back, whatever its status. Headers are lower-case. `text` is empty for no content. */
+export interface TransportResponse {
+    readonly status: number;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly text: string;
+}
+export type Transport = (request: TransportRequest) => Effect.Effect<TransportResponse, HttpError>;
+/** Wraps the next transport: change the request on the way in, the answer on the way out, call `next` more than once (retry) or not at all (a cached answer). */
+export type Interceptor = (next: Transport) => Transport;

package/dist/transport.js

@@ -0,0 +1 @@
+export {};

package/dist/viewport.d.ts

@@ -0,0 +1,15 @@
+import type { Viewport } from "./index.js";
+export declare const MEDIUM = 600;
+export declare const EXPANDED = 840;
+export declare const viewportOf: (width: number) => Viewport;
+interface Query {
+    readonly matches: boolean;
+    addEventListener(type: "change", listener: () => void): void;
+    removeEventListener(type: "change", listener: () => void): void;
+}
+export interface MediaWindow {
+    matchMedia(query: string): Query;
+}
+/** Calls `changed` with the current class now, and again whenever it changes. Returns the function that stops watching. */
+export declare const watchViewport: (win: MediaWindow, changed: (viewport: Viewport) => void) => (() => void);
+export {};

package/dist/viewport.js

@@ -0,0 +1,24 @@
+export const MEDIUM = 600;
+export const EXPANDED = 840;
+export const viewportOf = (width) => (width >= EXPANDED ? "expanded" : width >= MEDIUM ? "medium" : "compact");
+/** Calls `changed` with the current class now, and again whenever it changes. Returns the function that stops watching. */
+export const watchViewport = (win, changed) => {
+    const medium = win.matchMedia(`(min-width: ${MEDIUM}px)`);
+    const expanded = win.matchMedia(`(min-width: ${EXPANDED}px)`);
+    const current = () => (expanded.matches ? "expanded" : medium.matches ? "medium" : "compact");
+    let last;
+    const check = () => {
+        const now = current();
+        if (now !== last) {
+            last = now;
+            changed(now);
+        }
+    };
+    medium.addEventListener("change", check);
+    expanded.addEventListener("change", check);
+    check();
+    return () => {
+        medium.removeEventListener("change", check);
+        expanded.removeEventListener("change", check);
+    };
+};

package/dist/vocabulary.d.ts

@@ -0,0 +1,9 @@
+import type { WebPrimitives } from "@valancex/port-web";
+export interface Vocabulary {
+    /** The target's id (`web`). */
+    readonly target: string;
+    /** The tags, each with its props and events. */
+    readonly tags: WebPrimitives;
+}
+/** The web's vocabulary: HTML elements, with `class`, `theme`, `id` and `aria-*` as styling and accessibility hooks. */
+export declare const webVocabulary: Vocabulary;

package/dist/vocabulary.js

@@ -0,0 +1,3 @@
+import { primitives } from "./primitives.js";
+/** The web's vocabulary: HTML elements, with `class`, `theme`, `id` and `aria-*` as styling and accessibility hooks. */
+export const webVocabulary = { target: "web", tags: primitives };

package/package.json

@@ -1,6 +1,78 @@
 {
   "name": "@valancex/common",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.12.0",
+  "description": "The author's side of a VALANCE application (defineApp, component, field) and the runtime the vlx build runs: the browser and server entries. What src/main.ts imports; @valancex/cli builds what it describes.",
+  "keywords": [
+    "valance",
+    "defineApp",
+    "component"
+  ],
+  "homepage": "https://github.com/ValanceX/Valance/tree/main/packages/common#readme",
+  "bugs": {
+    "url": "https://github.com/ValanceX/Valance/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ValanceX/Valance.git",
+    "directory": "packages/common"
+  },
+  "license": "MIT",
+  "author": "Jack Miller <jackmiller0899@gmail.com>",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "default": "./dist/client.js"
+    },
+    "./http": {
+      "types": "./dist/http.d.ts",
+      "default": "./dist/http.js"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "default": "./dist/internal.js"
+    },
+    "./package.json": "./package.json",
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "types"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@valancex/mesh-runtime": "^0.11.0",
+    "@valancex/nexus": "^0.12.0",
+    "@valancex/port-web": "^0.4.0",
+    "@valancex/valance": "^0.12.0"
+  },
+  "peerDependencies": {
+    "effect": "^3.10.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "effect": "^3.10.0",
+    "typescript": "^5.6.0",
+    "vitest": "^3.2.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.typecheck.json",
+    "test": "vitest run"
+  }
 }

package/types/mprx.d.ts

@@ -0,0 +1,5 @@
+// What importing a template file gives the author's TypeScript: the file's address (see `Template` in src/index.ts, which this is structurally). The bundler (vite.ts) makes the import.
+declare module "*.mprx" {
+  const template: { readonly mprx: string };
+  export default template;
+}