@pascal-app/core 1.0.4 → 1.0.5

package/dist/schema/nodes/zone.js

@@ -1,7 +1,15 @@
 import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base.js';
+import { GeometryScriptSource } from '../geometry-source.js';
 import { SurfacePaintRegion } from './surface-paint-region.js';
+/**
+ * A room's floor finish built by a three.js module for the room's floor (`lib/floor-script`): the
+ * module gets the floor's polygon and elevation and lays the planks, tiles or boards on exactly that
+ * outline. `inputs` is the key of the floor it was built for; once the room's floor differs (a wall
+ * moved, an edge pushed) the script is stale and runs again for the new one.
+ */
+export const ZoneFloorScript = GeometryScriptSource.extend({ inputs: z.string() });
 export const ZoneNode = BaseNode.extend({
     id: objectId('zone'),
     type: nodeType('zone'),
@@ -25,6 +33,7 @@ export const ZoneNode = BaseNode.extend({
         sourceSlabId: z.templateLiteral(['slab_', z.string()]).optional(),
         finish: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),
         regions: z.array(SurfacePaintRegion).optional(),
+        script: ZoneFloorScript.optional(),
     })
         .optional(),
     // Painted parts of the room's ceiling. The automatic ceilings are rebuilt
@@ -81,6 +90,7 @@ export const ZoneNode = BaseNode.extend({
   - spaceRole: generic site/analysis zone or architectural room
   - roomNumber/finishes/ceilingHeight/occupancy: construction-document room metadata
   - floor.regions / ceiling.regions: painted parts of the room's floor and ceiling ([x, z] polygons, later wins)
+  - floor.script: a three.js module that builds the room's floor finish (boards, tiles) for its floor polygon, drawn over the floor; it owns its colours
   - floorStepFinish: finish of the room's steps; floorStepOverrides: per-doorway step finishes keyed by door id (or the lower room id), optional step index
   - enclosureStatus: auto-detected, explicitly enclosed, or open
   - clearDimensionPolicy: optional room clear-dimension datum preference

package/dist/schema/provenance.d.ts

@@ -39,34 +39,34 @@ export declare const PROVENANCE_MAX_NODE_ID_BYTES = 128;
  * - `derived`: a copy or user variant; it never claims the element.
  */
 export declare const ProvenanceRole: z.ZodEnum<{
-    primary: "primary";
-    piece: "piece";
     absorbed: "absorbed";
     alias: "alias";
     derived: "derived";
+    piece: "piece";
+    primary: "primary";
 }>;
 export type ProvenanceRole = z.infer<typeof ProvenanceRole>;
 export declare const ProvenanceRef: z.ZodObject<{
     ns: z.ZodOptional<z.ZodString>;
     id: z.ZodString;
     role: z.ZodOptional<z.ZodEnum<{
-        primary: "primary";
-        piece: "piece";
         absorbed: "absorbed";
         alias: "alias";
         derived: "derived";
+        piece: "piece";
+        primary: "primary";
     }>>;
 }, z.core.$strip>;
 export type ProvenanceRef = z.infer<typeof ProvenanceRef>;
 export declare const ProvenanceLineageOp: z.ZodEnum<{
+    attach: "attach";
+    convert: "convert";
+    duplicate: "duplicate";
     import: "import";
-    split: "split";
+    "make-independent": "make-independent";
     merge: "merge";
-    duplicate: "duplicate";
-    convert: "convert";
     promote: "promote";
-    "make-independent": "make-independent";
-    attach: "attach";
+    split: "split";
 }>;
 export type ProvenanceLineageOp = z.infer<typeof ProvenanceLineageOp>;
 /**
@@ -76,14 +76,14 @@ export type ProvenanceLineageOp = z.infer<typeof ProvenanceLineageOp>;
  */
 export declare const ProvenanceLineage: z.ZodObject<{
     op: z.ZodEnum<{
+        attach: "attach";
+        convert: "convert";
+        duplicate: "duplicate";
         import: "import";
-        split: "split";
+        "make-independent": "make-independent";
         merge: "merge";
-        duplicate: "duplicate";
-        convert: "convert";
         promote: "promote";
-        "make-independent": "make-independent";
-        attach: "attach";
+        split: "split";
     }>;
     fromIds: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
@@ -93,23 +93,23 @@ export declare const Provenance: z.ZodObject<{
         ns: z.ZodOptional<z.ZodString>;
         id: z.ZodString;
         role: z.ZodOptional<z.ZodEnum<{
-            primary: "primary";
-            piece: "piece";
             absorbed: "absorbed";
             alias: "alias";
             derived: "derived";
+            piece: "piece";
+            primary: "primary";
         }>>;
     }, z.core.$strip>>;
     lineage: z.ZodOptional<z.ZodObject<{
         op: z.ZodEnum<{
+            attach: "attach";
+            convert: "convert";
+            duplicate: "duplicate";
             import: "import";
-            split: "split";
+            "make-independent": "make-independent";
             merge: "merge";
-            duplicate: "duplicate";
-            convert: "convert";
             promote: "promote";
-            "make-independent": "make-independent";
-            attach: "attach";
+            split: "split";
         }>;
         fromIds: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>;

package/dist/schema/scene-material.d.ts

@@ -7,16 +7,16 @@ export declare const SceneMaterial: z.ZodObject<{
     material: z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
-            custom: "custom";
-            white: "white";
             brick: "brick";
             concrete: "concrete";
-            wood: "wood";
+            custom: "custom";
             glass: "glass";
+            marble: "marble";
             metal: "metal";
             plaster: "plaster";
             tile: "tile";
-            marble: "marble";
+            white: "white";
+            wood: "wood";
         }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
@@ -25,9 +25,9 @@ export declare const SceneMaterial: z.ZodObject<{
             opacity: z.ZodDefault<z.ZodNumber>;
             transparent: z.ZodDefault<z.ZodBoolean>;
             side: z.ZodDefault<z.ZodEnum<{
-                front: "front";
                 back: "back";
                 double: "double";
+                front: "front";
             }>>;
         }, z.core.$strip>>;
         texture: z.ZodOptional<z.ZodObject<{

package/dist/schema/site-presentation.d.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+/** Saved rendering defaults. Geometry and canonical bake visibility are independent. */
+export declare const SitePresentation: z.ZodObject<{
+    theme: z.ZodOptional<z.ZodString>;
+    exposure: z.ZodOptional<z.ZodNumber>;
+    shading: z.ZodOptional<z.ZodEnum<{
+        rendered: "rendered";
+        solid: "solid";
+    }>>;
+    edges: z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        soft: "soft";
+        strong: "strong";
+    }>>;
+    shadows: z.ZodOptional<z.ZodBoolean>;
+    lighting: z.ZodOptional<z.ZodObject<{
+        background: z.ZodOptional<z.ZodString>;
+        backgroundSky: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        ground: z.ZodOptional<z.ZodString>;
+        ambient: z.ZodOptional<z.ZodObject<{
+            color: z.ZodString;
+            intensity: z.ZodNumber;
+        }, z.core.$strip>>;
+        hemi: z.ZodOptional<z.ZodObject<{
+            sky: z.ZodString;
+            ground: z.ZodString;
+            intensity: z.ZodNumber;
+        }, z.core.$strip>>;
+        lights: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            color: z.ZodString;
+            intensity: z.ZodNumber;
+            position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            target: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            castShadow: z.ZodOptional<z.ZodBoolean>;
+            shadow: z.ZodOptional<z.ZodObject<{
+                intensity: z.ZodOptional<z.ZodNumber>;
+                bias: z.ZodOptional<z.ZodNumber>;
+                normalBias: z.ZodOptional<z.ZodNumber>;
+                radius: z.ZodOptional<z.ZodNumber>;
+                mapSize: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<512>, z.ZodLiteral<1024>, z.ZodLiteral<2048>, z.ZodLiteral<4096>]>>;
+                camera: z.ZodOptional<z.ZodObject<{
+                    left: z.ZodNumber;
+                    right: z.ZodNumber;
+                    top: z.ZodNumber;
+                    bottom: z.ZodNumber;
+                    near: z.ZodNumber;
+                    far: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        environment: z.ZodOptional<z.ZodObject<{
+            source: z.ZodEnum<{
+                gradient: "gradient";
+                none: "none";
+                room: "room";
+            }>;
+            intensity: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    postprocessing: z.ZodOptional<z.ZodObject<{
+        ambientOcclusion: z.ZodOptional<z.ZodBoolean>;
+        colorGrading: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    display: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodEnum<{
+            construction: "construction";
+            finished: "finished";
+            systems: "systems";
+        }>>;
+        families: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+            device: "device";
+            "exposed-structure": "exposed-structure";
+            fill: "fill";
+            finish: "finish";
+            foundation: "foundation";
+            framing: "framing";
+            inspection: "inspection";
+            insulation: "insulation";
+            masonry: "masonry";
+            membrane: "membrane";
+            run: "run";
+            "service-space": "service-space";
+            sheathing: "sheathing";
+        }> & z.core.$partial, z.ZodBoolean>>;
+        disciplines: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+            electrical: "electrical";
+            fire: "fire";
+            "low-voltage": "low-voltage";
+            mechanical: "mechanical";
+            plumbing: "plumbing";
+        }> & z.core.$partial, z.ZodBoolean>>;
+        xray: z.ZodOptional<z.ZodBoolean>;
+        colorBy: z.ZodOptional<z.ZodEnum<{
+            material: "material";
+            service: "service";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SitePresentation = z.infer<typeof SitePresentation>;
+//# sourceMappingURL=site-presentation.d.ts.map

package/dist/schema/site-presentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"site-presentation.d.ts","sourceRoot":"","sources":["../../src/schema/site-presentation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAqBvB,wFAAwF;AACxF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0E3B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/schema/site-presentation.js

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+const color = z.string().regex(/^#[\da-f]{6}$/i);
+const intensity = z.number().nonnegative();
+const light = z.object({ color, intensity });
+const vector = z.tuple([z.number(), z.number(), z.number()]);
+const shadowCamera = z
+    .object({
+    left: z.number(),
+    right: z.number(),
+    top: z.number(),
+    bottom: z.number(),
+    near: z.number().positive(),
+    far: z.number().positive(),
+})
+    .refine((camera) => camera.left < camera.right && camera.bottom < camera.top && camera.near < camera.far, 'A shadow camera needs ordered horizontal, vertical and depth bounds.');
+/** Saved rendering defaults. Geometry and canonical bake visibility are independent. */
+export const SitePresentation = z.object({
+    theme: z.string().min(1).optional(),
+    exposure: intensity.optional(),
+    shading: z.enum(['solid', 'rendered']).optional(),
+    edges: z.enum(['off', 'soft', 'strong']).optional(),
+    shadows: z.boolean().optional(),
+    lighting: z
+        .object({
+        background: color.optional(),
+        backgroundSky: color.nullable().optional(),
+        ground: color.optional(),
+        ambient: light.optional(),
+        hemi: z.object({ sky: color, ground: color, intensity }).optional(),
+        lights: z
+            .array(light.extend({
+            position: vector,
+            target: vector.optional(),
+            castShadow: z.boolean().optional(),
+            shadow: z
+                .object({
+                intensity: z.number().min(0).max(1).optional(),
+                bias: z.number().optional(),
+                normalBias: intensity.optional(),
+                radius: intensity.optional(),
+                // One 4096 square map is the shared viewer's authored-shadow memory budget.
+                mapSize: z
+                    .union([z.literal(512), z.literal(1024), z.literal(2048), z.literal(4096)])
+                    .optional(),
+                camera: shadowCamera.optional(),
+            })
+                .optional(),
+        }))
+            .optional(),
+        environment: z.object({ source: z.enum(['gradient', 'room', 'none']), intensity }).optional(),
+    })
+        .optional(),
+    postprocessing: z
+        .object({ ambientOcclusion: z.boolean().optional(), colorGrading: z.boolean().optional() })
+        .optional(),
+    display: z
+        .object({
+        mode: z.enum(['finished', 'construction', 'systems']).optional(),
+        families: z
+            .partialRecord(z.enum([
+            'finish',
+            'exposed-structure',
+            'framing',
+            'masonry',
+            'sheathing',
+            'insulation',
+            'membrane',
+            'fill',
+            'foundation',
+            'service-space',
+            'device',
+            'run',
+            'inspection',
+        ]), z.boolean())
+            .optional(),
+        disciplines: z
+            .partialRecord(z.enum(['mechanical', 'plumbing', 'electrical', 'low-voltage', 'fire']), z.boolean())
+            .optional(),
+        xray: z.boolean().optional(),
+        colorBy: z.enum(['material', 'service']).optional(),
+    })
+        .optional(),
+});