Sheet documents

import {
  createEmptyDocument,
  validateDocument,
  findSavedView,
  UnresolvedSavedViewError,
} from '@opengeometry/floorkit';

import { createEmptyDocument, pageSize } from '@opengeometry/floorkit';

const document = createEmptyDocument();
document.unitSystem = 'metric';
document.sheets.push({
  id: 'ground-plan',
  name: 'Ground floor',
  page: {
    format: 'A3',
    orientation: 'landscape',
    size: pageSize('A3', 'landscape'),
    margin: 10,
  },
  viewports: [],
  annotations: [],
});
const json = JSON.stringify(document);

function createEmptyDocument(): PaperDocument;

function validateDocument(doc: unknown): doc is PaperDocument;

function findSavedView(
  viewId: string,
  views: readonly SavedDrawingView[],
): SavedDrawingView | undefined;

class UnresolvedSavedViewError extends Error {
  readonly viewportId: string;
  readonly viewId: string;
  readonly code = 'unresolved-saved-view';
  constructor(viewportId: string, viewId: string);
}

interface PaperDocument {
  version: 1;
  unitSystem?: UnitSystem;
  dimensionStyles?: DimensionStyleRegistry;
  styleId?: PaperStyleId;
  styleOverride?: PaperStyle;
  paperStyles?: PaperStyleRegistry;
  sheets: Sheet[];
}

interface Sheet {
  number?: string;
  id: string;
  name: string;
  page: PageSpec;
  viewports: Viewport[];
  annotations: Annotation[];
  titleblock?: TitleblockInstance;
  styleId?: PaperStyleId;
  styleOverride?: PaperStyle;
}

type Viewport = ViewportBase &
  (
    | {
        source: ViewSource;
        viewId?: never;
      }
    | {
        viewId: string;
        source?: never;
      }
  );

type SavedDrawingView =
  | SavedRasterIsometricView
  | (SavedViewBase & {
      kind: 'plan';
      storeyId: string;
      cutHeightAboveStorey: number;
      visibleRange?: {
        below: number;
        above: number;
      };
      elementIds?: string[] | 'all';
      showMassing?: boolean;
    })
  | (SavedViewBase &
      PhysicalDrawingScope & {
        kind: 'section';
        line: {
          start: WorldXZ;
          end: WorldXZ;
        };
        lookSide: 'left' | 'right';
        depth: number;
        verticalCrop: {
          minY: number;
          maxY: number;
        };
      })
  | (SavedViewBase &
      PhysicalDrawingScope & {
        kind: 'elevation';
        origin: WorldXZ;
        lookDirection: WorldXZ;
        crop: {
          left: number;
          right: number;
          bottom: number;
          top: number;
        };
      })
  | (SavedViewBase & {
      kind: 'iso';
      camera: ProjectionCamera & {
        projection_mode: 'Orthographic';
      };
      elementIds?: string[] | 'all';
    });

type PaperStyleId = BuiltinPaperStyleId | (string & {});

interface PaperStyle {
  id?: string;
  name?: string;
  extends?: string;
  paper?: {
    color?: string;
    ground?: 'screen' | 'print' | 'both';
  };
  ink?: string;
  ladderStep?: number;
  classes?: Record<string, ClassStyle>;
  edgeClasses?: Record<string, ClassStyle>;
  producerFill?: 'allow' | 'ignore';
  typography?: Typography;
  hand?: HandProfile;
}

type PaperStyleRegistry = Record<string, PaperStyle>;

interface PageSpec {
  format: PageFormat;
  orientation: PageOrientation;
  size: {
    width: number;
    height: number;
  };
  margin: number;
  frame?: SheetFrameOptions;
}

type Annotation =
  | TextAnnotation
  | DimensionAnnotation
  | MeasureAnnotation
  | AngularMeasureAnnotation
  | RadialMeasureAnnotation
  | LeaderAnnotation
  | ImageAnnotation
  | ShapeAnnotation;

interface TitleblockInstance {
  templateId: string;
  values: Record<string, string>;
}

interface ViewportBase {
  representation?: 'vector' | 'raster';
  drawingNumber?: string;
  id: string;
  frame: {
    x: number;
    y: number;
    width: number;
    height: number;
  };
  scale: number;
  scaleId?: string;
  rotationDeg: number;
  clip: boolean;
  viewCenter?: Point2;
  title?: {
    text?: string;
    showScale?: boolean;
  };
  styleId?: PaperStyleId;
  styleOverride?: PaperStyle;
}

type ViewSource =
  | {
      kind: 'plan';
      levelId: string;
      cutElevation?: number;
      hideHidden?: boolean;
      entities?: string[] | 'all';
    }
  | {
      kind: 'elevation';
      sectionId: string;
    }
  | {
      kind: 'section';
      sectionId: string;
    }
  | {
      kind: 'iso';
      camera: ProjectionCamera;
    };

interface SavedRasterIsometricView {
  id: string;
  name: string;
  kind: 'raster-iso';
  camera: ProjectionCamera & {
    projection_mode: 'Orthographic';
  };
  frame: RasterViewFrame;
  far: number;
  elementIds?: string[] | 'all';
  background: string | null;
}

interface SavedViewBase {
  id: string;
  name: string;
}

interface PhysicalDrawingScope {
  buildingId?: string;
  elementIds?: string[] | 'all';
  settings?: PhysicalDrawingSettings;
}

type WorldXZ = [number, number];

type ProjectionCamera = PlanProjectionCamera;

interface ClassStyle {
  visible?: boolean;
  weightMm?: number;
  ladderStep?: number;
  ink?: string;
  dash?: number[] | 'none';
  fill?: string | 'none';
  hatch?: string | HatchSpec | 'none';
  cap?: 'butt' | 'round';
  byKind?: Partial<Record<PrimitiveKind, Omit<ClassStyle, 'byKind'>>>;
}

interface Typography {
  fontFamily?: string;
  letterSpacingEm?: number;
  textTransform?: 'none' | 'uppercase';
  scale?: number;
}

interface HandProfile {
  salt: number;
  bowAmplitudeMm: number;
  weightRefMm: number;
  fieldLatticeMm: number;
  minLengthMm: number;
  segmentLenMm: number;
  capN: number;
  detail?: {
    amplitudeMm: number;
    latticeMm: number;
  };
  overshootStartMm: number;
  overshootEndMm: number;
  cornerTurnDeg: number;
  crossedProbability: number;
  openGapMinMm: number;
  openGapMaxMm: number;
  strikeTiers: Array<{
    atOrAboveMm: number;
    strikes: number;
  }>;
  restrikeOffsetMm: number;
  restrikeWeightFactor: number;
  restrikeTrimStartMm: number;
  restrikeTrimEndMm: number;
  restrikeWanderMm?: number;
  startBeadMm: number;
  startBeadWidthFactor: number;
  endTaperMm: number;
  endTaperWidthFactor: number;
  weightVariance: number;
  arcCentreOffsetMm: number;
  arcRadiusVar: number;
  arcSweepOverDeg: number;
  arcSweepUnderDeg: number;
  arcRestrikes: number;
  pocheInsetMm: number;
  pocheScribble?: boolean;
  scribbleJitter?: number;
  hatchAngleJitterDeg: number;
  hatchRegionDriftDeg: number;
  hatchSpacingVar: number;
  hatchEndShortMm: number;
  hatchEndOverMm: number;
  textRunRotationDeg: number;
  textBaselineMm: number;
  maxPrimitives: number;
  shedClasses: string[];
  reach?: HandReach;
}

interface SheetFrameOptions {
  border?: boolean;
  zones?: boolean;
  centringMarks?: boolean;
  margins?: Partial<SheetMargins>;
  bindingEdge?: 'left' | 'top';
}

interface TextAnnotation {
  id: string;
  kind: 'text';
  text: string;
  position: Point2;
  fontSize: number;
  fontFamily?: string;
  color?: string;
  align?: 'left' | 'center' | 'right';
  rotationDeg?: number;
}

interface DimensionAnnotation {
  id: string;
  kind: 'dimension';
  styleId?: string;
  start: Point2;
  end: Point2;
  offset: number;
  label?: string;
  fontSize: number;
}

interface LeaderAnnotation {
  id: string;
  kind: 'leader';
  styleId?: string;
  target: Point2;
  points: Point2[];
  text: string;
  fontSize: number;
}

interface ImageAnnotation {
  id: string;
  kind: 'image';
  src: string;
  rect: {
    x: number;
    y: number;
    width: number;
    height: number;
  };
}

interface ShapeAnnotation {
  id: string;
  kind: 'shape';
  shape: ShapeKind;
  points: Point2[];
  radius?: number;
  stroke?: string;
  strokeWidth?: number;
  fill?: string;
}

interface PhysicalDrawingSettings {
  context?: 'visible' | 'cut-only';
  hiddenLines?: boolean;
  background?: string | null;
  levelLabels?: {
    datum: number;
    unit: 'm' | 'ft';
  };
}

interface HandReach {
  annotations?: boolean;
  frame?: boolean;
  titleblock?: boolean;
}

type ShapeKind = 'line' | 'polyline' | 'rect' | 'circle';