@nativemason/contracts 0.0.0-stage → 0.3.0

package/dist/native-protocol.d.ts

@@ -0,0 +1,262 @@
+import { z } from 'zod';
+/** Explicit local interface for development pairing; never a wildcard/public listener. */
+export declare const NativeBindHostSchema: z.ZodIPv4;
+export type NativeBindHost = z.infer<typeof NativeBindHostSchema>;
+export declare const NativeClientMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"hello">;
+    token: z.ZodString;
+    scenarioId: z.ZodString;
+    protocolVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    platform: z.ZodOptional<z.ZodEnum<{
+        android: "android";
+        ios: "ios";
+    }>>;
+    targetId: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        textFits: z.ZodBoolean;
+        scenarioActions: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"action_result">;
+    requestId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"snapshot">;
+    requestId: z.ZodString;
+    snapshot: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        sessionId: z.ZodString;
+        snapshotId: z.ZodString;
+        platform: z.ZodEnum<{
+            web: "web";
+            android: "android";
+            ios: "ios";
+        }>;
+        scenarioId: z.ZodString;
+        profile: z.ZodObject<{
+            window: z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strict>;
+            pixelRatio: z.ZodNumber;
+            fontScale: z.ZodNumber;
+            insets: z.ZodObject<{
+                top: z.ZodNumber;
+                right: z.ZodNumber;
+                bottom: z.ZodNumber;
+                left: z.ZodNumber;
+            }, z.core.$strict>;
+            root: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strict>;
+            orientation: z.ZodEnum<{
+                portrait: "portrait";
+                landscape: "landscape";
+            }>;
+        }, z.core.$strict>;
+        revisions: z.ZodRecord<z.ZodString, z.ZodString>;
+        nodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            parentId: z.ZodNullable<z.ZodString>;
+            kind: z.ZodEnum<{
+                View: "View";
+                Text: "Text";
+                Pressable: "Pressable";
+                TextInput: "TextInput";
+                ScrollView: "ScrollView";
+                Image: "Image";
+            }>;
+            role: z.ZodNullable<z.ZodString>;
+            rect: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strict>;
+            styles: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            source: z.ZodNullable<z.ZodObject<{
+                path: z.ZodString;
+                styleForm: z.ZodOptional<z.ZodLiteral<"pressable-state">>;
+                dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                hash: z.ZodString;
+                start: z.ZodNumber;
+                end: z.ZodNumber;
+                line: z.ZodNumber;
+                column: z.ZodNumber;
+            }, z.core.$strict>>;
+            editable: z.ZodBoolean;
+            editReason: z.ZodNullable<z.ZodString>;
+            pressableState: z.ZodOptional<z.ZodEnum<{
+                pressed: "pressed";
+                rest: "rest";
+            }>>;
+            accessibility: z.ZodOptional<z.ZodObject<{
+                authoredLabel: z.ZodOptional<z.ZodString>;
+                authoredHint: z.ZodOptional<z.ZodString>;
+                accessible: z.ZodOptional<z.ZodBoolean>;
+                focusable: z.ZodOptional<z.ZodBoolean>;
+                hidden: z.ZodOptional<z.ZodBoolean>;
+                disabled: z.ZodOptional<z.ZodBoolean>;
+                direction: z.ZodEnum<{
+                    unknown: "unknown";
+                    ltr: "ltr";
+                    rtl: "rtl";
+                }>;
+                directionSource: z.ZodOptional<z.ZodEnum<{
+                    unknown: "unknown";
+                    authored: "authored";
+                    "native-global": "native-global";
+                    "browser-computed": "browser-computed";
+                }>>;
+                browser: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodNullable<z.ZodString>;
+                    focusOrder: z.ZodNullable<z.ZodNumber>;
+                    focusOrderSource: z.ZodLiteral<"dom-sequential-estimate">;
+                    contrast: z.ZodObject<{
+                        status: z.ZodEnum<{
+                            measured: "measured";
+                            unavailable: "unavailable";
+                        }>;
+                        ratio: z.ZodOptional<z.ZodNumber>;
+                        requiredRatio: z.ZodOptional<z.ZodNumber>;
+                        reason: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            textFit: z.ZodOptional<z.ZodObject<{
+                status: z.ZodEnum<{
+                    unavailable: "unavailable";
+                    supported: "supported";
+                }>;
+                fullLineCount: z.ZodOptional<z.ZodNumber>;
+                limitedLineCount: z.ZodOptional<z.ZodNumber>;
+                fullHeight: z.ZodOptional<z.ZodNumber>;
+                availableHeight: z.ZodOptional<z.ZodNumber>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            authoredTextProps: z.ZodOptional<z.ZodObject<{
+                fontSize: z.ZodOptional<z.ZodNumber>;
+                lineHeight: z.ZodOptional<z.ZodNumber>;
+                numberOfLines: z.ZodOptional<z.ZodNumber>;
+                allowFontScaling: z.ZodOptional<z.ZodBoolean>;
+                ellipsizeMode: z.ZodOptional<z.ZodEnum<{
+                    head: "head";
+                    middle: "middle";
+                    tail: "tail";
+                    clip: "clip";
+                }>>;
+            }, z.core.$strict>>;
+            measuredLineCount: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        status: z.ZodEnum<{
+            stable: "stable";
+            unstable: "unstable";
+        }>;
+        generation: z.ZodNumber;
+        nativeTarget: z.ZodOptional<z.ZodObject<{
+            targetId: z.ZodString;
+            platform: z.ZodEnum<{
+                android: "android";
+                ios: "ios";
+            }>;
+            kind: z.ZodEnum<{
+                physical: "physical";
+                emulator: "emulator";
+                simulator: "simulator";
+            }>;
+        }, z.core.$strict>>;
+        webDiagnostics: z.ZodOptional<z.ZodObject<{
+            nodes: z.ZodRecord<z.ZodString, z.ZodObject<{
+                clipping: z.ZodEnum<{
+                    unknown: "unknown";
+                    confirmed: "confirmed";
+                    clear: "clear";
+                }>;
+                centerHitTest: z.ZodEnum<{
+                    unknown: "unknown";
+                    confirmed: "confirmed";
+                    clear: "clear";
+                }>;
+                scrollOverflow: z.ZodObject<{
+                    horizontal: z.ZodBoolean;
+                    vertical: z.ZodBoolean;
+                }, z.core.$strict>;
+                paintOrder: z.ZodNullable<z.ZodNumber>;
+                fonts: z.ZodArray<z.ZodObject<{
+                    family: z.ZodString;
+                    glyphCount: z.ZodNumber;
+                    isCustom: z.ZodNullable<z.ZodBoolean>;
+                }, z.core.$strict>>;
+                lineBoxCount: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+            warnings: z.ZodArray<z.ZodObject<{
+                elementId: z.ZodString;
+                code: z.ZodEnum<{
+                    CLIPPED: "CLIPPED";
+                    OCCLUDED: "OCCLUDED";
+                    FONT_LOAD_FAILED: "FONT_LOAD_FAILED";
+                    EVIDENCE_UNAVAILABLE: "EVIDENCE_UNAVAILABLE";
+                }>;
+                severity: z.ZodEnum<{
+                    confirmed: "confirmed";
+                    uncertain: "uncertain";
+                }>;
+                message: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    requestId: z.ZodString;
+    error: z.ZodObject<{
+        code: z.ZodEnum<{
+            INVALID_INPUT: "INVALID_INPUT";
+            MISSING_ELEMENT: "MISSING_ELEMENT";
+            DUPLICATE_ELEMENT: "DUPLICATE_ELEMENT";
+            STALE_SNAPSHOT: "STALE_SNAPSHOT";
+            STALE_SOURCE: "STALE_SOURCE";
+            UNSUPPORTED_EDIT: "UNSUPPORTED_EDIT";
+            UNSUPPORTED_PROFILE: "UNSUPPORTED_PROFILE";
+            UNSTABLE_LAYOUT: "UNSTABLE_LAYOUT";
+            NATIVE_DISCONNECTED: "NATIVE_DISCONNECTED";
+            TIMEOUT: "TIMEOUT";
+            VERIFICATION_FAILED: "VERIFICATION_FAILED";
+            SESSION_NOT_FOUND: "SESSION_NOT_FOUND";
+            TRIAL_NOT_FOUND: "TRIAL_NOT_FOUND";
+            SOURCE_OUTSIDE_PROJECT: "SOURCE_OUTSIDE_PROJECT";
+            INTERNAL_ERROR: "INTERNAL_ERROR";
+            RECOVERY_CONFLICT: "RECOVERY_CONFLICT";
+            TRANSACTION_CONFLICT: "TRANSACTION_CONFLICT";
+            UNSUPPORTED_ACTION: "UNSUPPORTED_ACTION";
+            PROTOCOL_MISMATCH: "PROTOCOL_MISMATCH";
+        }>;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "type">;
+export type NativeClientMessage = z.infer<typeof NativeClientMessageSchema>;
+export declare const NativeServerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"capture">;
+    requestId: z.ZodString;
+    sessionId: z.ZodString;
+    expectedRevisions: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"action">;
+    requestId: z.ZodString;
+    sessionId: z.ZodString;
+    name: z.ZodString;
+    value: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>], "type">;
+export type NativeServerMessage = z.infer<typeof NativeServerMessageSchema>;
+export interface NativeConnectionOptions {
+    port: number;
+    token: string;
+    scenarioId: string;
+    sessionId: string;
+    timeoutMs?: number;
+    targetId?: string;
+    platform?: 'android' | 'ios';
+    host?: NativeBindHost;
+}

package/dist/native-protocol.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { SpatialSnapshotSchema } from './graph.js';
+import { SourceRevisionsSchema, BridgeErrorSchema } from './source.js';
+/** Explicit local interface for development pairing; never a wildcard/public listener. */
+export const NativeBindHostSchema = z.ipv4().refine(host => { const [a = 0, b = 0] = host.split('.').map(Number); return a === 127 || a === 10 || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168); }, 'Use a loopback or private LAN IPv4 interface address');
+export const NativeClientMessageSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('hello'), token: z.string(), scenarioId: z.string(), protocolVersion: z.union([z.literal(1), z.literal(2)]), platform: z.enum(['android', 'ios']).optional(), targetId: z.string().optional(), capabilities: z.object({ textFits: z.boolean(), scenarioActions: z.boolean() }).optional() }).strict(),
+    z.object({ type: z.literal('action_result'), requestId: z.string() }).strict(),
+    z.object({ type: z.literal('snapshot'), requestId: z.string(), snapshot: SpatialSnapshotSchema }).strict(),
+    z.object({ type: z.literal('error'), requestId: z.string(), error: BridgeErrorSchema }).strict()
+]).superRefine((message, ctx) => { if (message.type === 'hello' && message.protocolVersion === 2 && (!message.platform || !message.targetId || !message.capabilities))
+    ctx.addIssue({ code: 'custom', message: 'Protocol v2 requires platform, targetId and capabilities' }); });
+export const NativeServerMessageSchema = z.discriminatedUnion('type', [z.object({ type: z.literal('capture'), requestId: z.string(), sessionId: z.string(), expectedRevisions: SourceRevisionsSchema }).strict(), z.object({ type: z.literal('action'), requestId: z.string(), sessionId: z.string(), name: z.string(), value: z.unknown().optional() }).strict()]);

package/dist/source.d.ts

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+export declare const SourceRefSchema: z.ZodObject<{
+    path: z.ZodString;
+    styleForm: z.ZodOptional<z.ZodLiteral<"pressable-state">>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    hash: z.ZodString;
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+    line: z.ZodNumber;
+    column: z.ZodNumber;
+}, z.core.$strict>;
+export type SourceRef = z.infer<typeof SourceRefSchema>;
+export declare const SourceRevisionsSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+export type SourceRevisions = z.infer<typeof SourceRevisionsSchema>;
+export declare const ErrorCodeSchema: z.ZodEnum<{
+    INVALID_INPUT: "INVALID_INPUT";
+    MISSING_ELEMENT: "MISSING_ELEMENT";
+    DUPLICATE_ELEMENT: "DUPLICATE_ELEMENT";
+    STALE_SNAPSHOT: "STALE_SNAPSHOT";
+    STALE_SOURCE: "STALE_SOURCE";
+    UNSUPPORTED_EDIT: "UNSUPPORTED_EDIT";
+    UNSUPPORTED_PROFILE: "UNSUPPORTED_PROFILE";
+    UNSTABLE_LAYOUT: "UNSTABLE_LAYOUT";
+    NATIVE_DISCONNECTED: "NATIVE_DISCONNECTED";
+    TIMEOUT: "TIMEOUT";
+    VERIFICATION_FAILED: "VERIFICATION_FAILED";
+    SESSION_NOT_FOUND: "SESSION_NOT_FOUND";
+    TRIAL_NOT_FOUND: "TRIAL_NOT_FOUND";
+    SOURCE_OUTSIDE_PROJECT: "SOURCE_OUTSIDE_PROJECT";
+    INTERNAL_ERROR: "INTERNAL_ERROR";
+    RECOVERY_CONFLICT: "RECOVERY_CONFLICT";
+    TRANSACTION_CONFLICT: "TRANSACTION_CONFLICT";
+    UNSUPPORTED_ACTION: "UNSUPPORTED_ACTION";
+    PROTOCOL_MISMATCH: "PROTOCOL_MISMATCH";
+}>;
+export type ErrorCode = z.infer<typeof ErrorCodeSchema>;
+export declare const BridgeErrorSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        INVALID_INPUT: "INVALID_INPUT";
+        MISSING_ELEMENT: "MISSING_ELEMENT";
+        DUPLICATE_ELEMENT: "DUPLICATE_ELEMENT";
+        STALE_SNAPSHOT: "STALE_SNAPSHOT";
+        STALE_SOURCE: "STALE_SOURCE";
+        UNSUPPORTED_EDIT: "UNSUPPORTED_EDIT";
+        UNSUPPORTED_PROFILE: "UNSUPPORTED_PROFILE";
+        UNSTABLE_LAYOUT: "UNSTABLE_LAYOUT";
+        NATIVE_DISCONNECTED: "NATIVE_DISCONNECTED";
+        TIMEOUT: "TIMEOUT";
+        VERIFICATION_FAILED: "VERIFICATION_FAILED";
+        SESSION_NOT_FOUND: "SESSION_NOT_FOUND";
+        TRIAL_NOT_FOUND: "TRIAL_NOT_FOUND";
+        SOURCE_OUTSIDE_PROJECT: "SOURCE_OUTSIDE_PROJECT";
+        INTERNAL_ERROR: "INTERNAL_ERROR";
+        RECOVERY_CONFLICT: "RECOVERY_CONFLICT";
+        TRANSACTION_CONFLICT: "TRANSACTION_CONFLICT";
+        UNSUPPORTED_ACTION: "UNSUPPORTED_ACTION";
+        PROTOCOL_MISMATCH: "PROTOCOL_MISMATCH";
+    }>;
+    message: z.ZodString;
+    details: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>;
+export type BridgeError = z.infer<typeof BridgeErrorSchema>;
+export type Result<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: BridgeError;
+};
+export declare class BridgeFault extends Error {
+    readonly code: ErrorCode;
+    readonly details?: unknown | undefined;
+    constructor(code: ErrorCode, message: string, details?: unknown | undefined);
+}
+export interface SourceFile {
+    path: string;
+    text: string;
+    hash: string;
+}
+export declare const EditPlanSchema: z.ZodObject<{
+    source: z.ZodObject<{
+        path: z.ZodString;
+        styleForm: z.ZodOptional<z.ZodLiteral<"pressable-state">>;
+        dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        hash: z.ZodString;
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+        line: z.ZodNumber;
+        column: z.ZodNumber;
+    }, z.core.$strict>;
+    expectedHash: z.ZodString;
+    updatedText: z.ZodString;
+    diff: z.ZodString;
+}, z.core.$strict>;
+export type EditPlan = z.infer<typeof EditPlanSchema>;
+export declare const CommitReceiptSchema: z.ZodObject<{
+    commitId: z.ZodString;
+    path: z.ZodString;
+    oldHash: z.ZodString;
+    newHash: z.ZodString;
+    diff: z.ZodString;
+    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        oldHash: z.ZodString;
+        newHash: z.ZodString;
+        diff: z.ZodString;
+    }, z.core.$strict>>>;
+    revertsCommitId: z.ZodOptional<z.ZodString>;
+    nativeStatus: z.ZodEnum<{
+        pending: "pending";
+        passed: "passed";
+        failed: "failed";
+    }>;
+}, z.core.$strict>;
+export type CommitReceipt = z.infer<typeof CommitReceiptSchema>;
+export interface SourcePort {
+    read(path: string): Promise<SourceFile>;
+    apply(plan: EditPlan): Promise<CommitReceipt>;
+}

package/dist/source.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export const SourceRefSchema = z.object({ path: z.string().min(1), styleForm: z.literal('pressable-state').optional(), dependencies: z.array(z.string().min(1)).optional(), hash: z.string().regex(/^[a-f0-9]{64}$/), start: z.number().int().nonnegative(), end: z.number().int().positive(), line: z.number().int().positive(), column: z.number().int().nonnegative() }).strict().refine(s => s.end > s.start, 'Invalid source range');
+export const SourceRevisionsSchema = z.record(z.string(), z.string().regex(/^[a-f0-9]{64}$/));
+export const ErrorCodeSchema = z.enum(['INVALID_INPUT', 'MISSING_ELEMENT', 'DUPLICATE_ELEMENT', 'STALE_SNAPSHOT', 'STALE_SOURCE', 'UNSUPPORTED_EDIT', 'UNSUPPORTED_PROFILE', 'UNSTABLE_LAYOUT', 'NATIVE_DISCONNECTED', 'TIMEOUT', 'VERIFICATION_FAILED', 'SESSION_NOT_FOUND', 'TRIAL_NOT_FOUND', 'SOURCE_OUTSIDE_PROJECT', 'INTERNAL_ERROR', 'RECOVERY_CONFLICT', 'TRANSACTION_CONFLICT', 'UNSUPPORTED_ACTION', 'PROTOCOL_MISMATCH']);
+export const BridgeErrorSchema = z.object({ code: ErrorCodeSchema, message: z.string(), details: z.unknown().optional() }).strict();
+export class BridgeFault extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'BridgeFault';
+    }
+}
+export const EditPlanSchema = z.object({ source: SourceRefSchema, expectedHash: z.string(), updatedText: z.string(), diff: z.string() }).strict();
+export const CommitReceiptSchema = z.object({ commitId: z.string(), path: z.string(), oldHash: z.string(), newHash: z.string(), diff: z.string(), files: z.array(z.object({ path: z.string(), oldHash: z.string(), newHash: z.string(), diff: z.string() }).strict()).optional(), revertsCommitId: z.string().optional(), nativeStatus: z.enum(['pending', 'passed', 'failed']) }).strict();

package/dist/styles.d.ts

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+export declare const RnStylePatchSchema: z.ZodObject<{
+    flex: z.ZodOptional<z.ZodNumber>;
+    flexWrap: z.ZodOptional<z.ZodEnum<{
+        wrap: "wrap";
+        nowrap: "nowrap";
+        "wrap-reverse": "wrap-reverse";
+    }>>;
+    alignContent: z.ZodOptional<z.ZodEnum<{
+        center: "center";
+        "flex-start": "flex-start";
+        "flex-end": "flex-end";
+        stretch: "stretch";
+        "space-between": "space-between";
+        "space-around": "space-around";
+    }>>;
+    position: z.ZodOptional<z.ZodEnum<{
+        relative: "relative";
+        absolute: "absolute";
+        static: "static";
+    }>>;
+    top: z.ZodOptional<z.ZodNumber>;
+    bottom: z.ZodOptional<z.ZodNumber>;
+    left: z.ZodOptional<z.ZodNumber>;
+    right: z.ZodOptional<z.ZodNumber>;
+    start: z.ZodOptional<z.ZodNumber>;
+    end: z.ZodOptional<z.ZodNumber>;
+    aspectRatio: z.ZodOptional<z.ZodNumber>;
+    paddingStart: z.ZodOptional<z.ZodNumber>;
+    paddingEnd: z.ZodOptional<z.ZodNumber>;
+    marginStart: z.ZodOptional<z.ZodNumber>;
+    marginEnd: z.ZodOptional<z.ZodNumber>;
+    fontSize: z.ZodOptional<z.ZodNumber>;
+    lineHeight: z.ZodOptional<z.ZodNumber>;
+    fontFamily: z.ZodOptional<z.ZodString>;
+    fontWeight: z.ZodOptional<z.ZodEnum<{
+        normal: "normal";
+        bold: "bold";
+        100: "100";
+        200: "200";
+        300: "300";
+        400: "400";
+        500: "500";
+        600: "600";
+        700: "700";
+        800: "800";
+        900: "900";
+    }>>;
+    flexDirection: z.ZodOptional<z.ZodEnum<{
+        column: "column";
+        row: "row";
+        "row-reverse": "row-reverse";
+        "column-reverse": "column-reverse";
+    }>>;
+    justifyContent: z.ZodOptional<z.ZodEnum<{
+        center: "center";
+        "flex-start": "flex-start";
+        "flex-end": "flex-end";
+        "space-between": "space-between";
+        "space-around": "space-around";
+        "space-evenly": "space-evenly";
+    }>>;
+    alignItems: z.ZodOptional<z.ZodEnum<{
+        center: "center";
+        "flex-start": "flex-start";
+        "flex-end": "flex-end";
+        stretch: "stretch";
+        baseline: "baseline";
+    }>>;
+    alignSelf: z.ZodOptional<z.ZodEnum<{
+        center: "center";
+        "flex-start": "flex-start";
+        "flex-end": "flex-end";
+        stretch: "stretch";
+        baseline: "baseline";
+        auto: "auto";
+    }>>;
+    flexGrow: z.ZodOptional<z.ZodNumber>;
+    flexShrink: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    height: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    minWidth: z.ZodOptional<z.ZodNumber>;
+    maxWidth: z.ZodOptional<z.ZodNumber>;
+    minHeight: z.ZodOptional<z.ZodNumber>;
+    maxHeight: z.ZodOptional<z.ZodNumber>;
+    gap: z.ZodOptional<z.ZodNumber>;
+    rowGap: z.ZodOptional<z.ZodNumber>;
+    columnGap: z.ZodOptional<z.ZodNumber>;
+    padding: z.ZodOptional<z.ZodNumber>;
+    paddingHorizontal: z.ZodOptional<z.ZodNumber>;
+    paddingVertical: z.ZodOptional<z.ZodNumber>;
+    paddingTop: z.ZodOptional<z.ZodNumber>;
+    paddingBottom: z.ZodOptional<z.ZodNumber>;
+    paddingLeft: z.ZodOptional<z.ZodNumber>;
+    paddingRight: z.ZodOptional<z.ZodNumber>;
+    margin: z.ZodOptional<z.ZodNumber>;
+    marginHorizontal: z.ZodOptional<z.ZodNumber>;
+    marginVertical: z.ZodOptional<z.ZodNumber>;
+    marginTop: z.ZodOptional<z.ZodNumber>;
+    marginBottom: z.ZodOptional<z.ZodNumber>;
+    marginLeft: z.ZodOptional<z.ZodNumber>;
+    marginRight: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type RnStylePatch = z.infer<typeof RnStylePatchSchema>;
+export type NormalizedPatch = Readonly<RnStylePatch>;

package/dist/styles.js

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+const n = z.number().finite().nonnegative();
+export const RnStylePatchSchema = z.object({ flex: z.number().finite().optional(), flexWrap: z.enum(['wrap', 'nowrap', 'wrap-reverse']).optional(), alignContent: z.enum(['flex-start', 'flex-end', 'center', 'stretch', 'space-between', 'space-around']).optional(), position: z.enum(['relative', 'absolute', 'static']).optional(), top: z.number().finite().optional(), bottom: z.number().finite().optional(), left: z.number().finite().optional(), right: z.number().finite().optional(), start: z.number().finite().optional(), end: z.number().finite().optional(), aspectRatio: z.number().positive().optional(), paddingStart: n.optional(), paddingEnd: n.optional(), marginStart: z.number().finite().optional(), marginEnd: z.number().finite().optional(), fontSize: n.optional(), lineHeight: n.optional(), fontFamily: z.string().min(1).optional(), fontWeight: z.enum(['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900']).optional(), flexDirection: z.enum(['row', 'column', 'row-reverse', 'column-reverse']).optional(), justifyContent: z.enum(['flex-start', 'flex-end', 'center', 'space-between', 'space-around', 'space-evenly']).optional(), alignItems: z.enum(['flex-start', 'flex-end', 'center', 'stretch', 'baseline']).optional(), alignSelf: z.enum(['auto', 'flex-start', 'flex-end', 'center', 'stretch', 'baseline']).optional(), flexGrow: n.optional(), flexShrink: n.optional(), width: z.union([n, z.string().regex(/^\d+(?:\.\d+)?%$/)]).optional(), height: z.union([n, z.string().regex(/^\d+(?:\.\d+)?%$/)]).optional(), minWidth: n.optional(), maxWidth: n.optional(), minHeight: n.optional(), maxHeight: n.optional(), gap: n.optional(), rowGap: n.optional(), columnGap: n.optional(), padding: n.optional(), paddingHorizontal: n.optional(), paddingVertical: n.optional(), paddingTop: n.optional(), paddingBottom: n.optional(), paddingLeft: n.optional(), paddingRight: n.optional(), margin: z.number().finite().optional(), marginHorizontal: z.number().finite().optional(), marginVertical: z.number().finite().optional(), marginTop: z.number().finite().optional(), marginBottom: z.number().finite().optional(), marginLeft: z.number().finite().optional(), marginRight: z.number().finite().optional() }).strict().refine(p => Object.keys(p).length > 0, 'Patch must not be empty');