@chahidy/plannr 0.1.0

package/dist/index.js

@@ -0,0 +1,77 @@
+// src/generators/floors.ts
+function generateFloors(counts, cfg) {
+  const floors = [];
+  const ugCount = counts?.ug?.count ?? 0;
+  const ugPrefix = cfg?.ug?.prefix ?? counts?.ug?.prefix ?? "UG";
+  for (let i = ugCount; i >= 1; i--) {
+    floors.push(`${ugPrefix}${i}`);
+  }
+  const egName = cfg?.eg?.prefix ?? "EG";
+  floors.push(egName);
+  const ogCount = counts?.og?.count ?? 0;
+  const ogPrefix = cfg?.og?.prefix ?? counts?.og?.prefix ?? "OG";
+  for (let i = 1; i <= ogCount; i++) {
+    floors.push(`${ogPrefix}${i}`);
+  }
+  if (counts?.dg) {
+    const dgName = cfg?.dg?.prefix ?? "DG";
+    floors.push(dgName);
+  }
+  return floors;
+}
+
+// src/generators/plan-number.ts
+function buildPlanNumber(plan, projectNumber, separator = "_", suffix, index) {
+  const floor = plan.floor ?? "XX";
+  const trade = plan.trade ?? "AR";
+  const running = String(plan.runningNumber).padStart(3, "0");
+  return `${projectNumber}${separator}${trade}${separator}${plan.type}${separator}${floor}${separator}${running}${separator}${suffix}${separator}${index}`;
+}
+
+// src/api/build-plan-numbers.ts
+function buildPlanNumbers(input) {
+  let runningNumber = 1;
+  const plans = [];
+  for (const block of input.blocks) {
+    const floors = generateFloors(input.floorcfg);
+    for (const trade of block.trades) {
+      for (const type of block.planTypes) {
+        if (type === "GR") {
+          const perFloor = block.plansPerFloor ?? 1;
+          for (const floor of floors) {
+            for (let i = 0; i < perFloor; i++) {
+              plans.push({
+                trade,
+                type,
+                floor,
+                runningNumber: runningNumber++
+              });
+            }
+          }
+        } else if (type === "SC") {
+          const count = block.minimumPerTrade ?? 1;
+          for (let i = 0; i < count; i++) {
+            plans.push({
+              trade,
+              type,
+              floor: void 0,
+              runningNumber: runningNumber++
+            });
+          }
+        }
+      }
+    }
+  }
+  return plans.map(
+    (plan) => buildPlanNumber(
+      plan,
+      input.projectNumber,
+      input.separator ?? "-",
+      input.suffix ?? "F",
+      input.index ?? "A"
+    )
+  );
+}
+export {
+  buildPlanNumbers
+};

package/main.js

@@ -0,0 +1,14 @@
+import { buildPlanNumbers } from "./dist/index.cjs";
+
+const plans = buildPlanNumbers({
+  projectNumber: "21015",
+  floorcfg: { ug: {prefix: "KG", count:2} },
+  blocks: [
+    {
+      trades: ["LUE"],
+      planTypes: ["GR"],
+    },
+  ],
+});
+
+console.log(plans);

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@chahidy/plannr",
+  "version": "0.1.0",
+  "type": "module",
+  "author": "Chahid Yahya",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup"
+  },
+  "description": "automatischen Generierung von Plannummern",
+  "dependencies": {
+    "acorn": "^8.15.0",
+    "any-promise": "^1.3.0",
+    "bundle-require": "^5.1.0",
+    "cac": "^6.7.14",
+    "chokidar": "^4.0.3",
+    "commander": "^4.1.1",
+    "confbox": "^0.1.8",
+    "consola": "^3.4.2",
+    "debug": "^4.4.3",
+    "esbuild": "^0.27.2",
+    "fdir": "^6.5.0",
+    "fix-dts-default-cjs-exports": "^1.0.1",
+    "joycon": "^3.1.1",
+    "lilconfig": "^3.1.3",
+    "lines-and-columns": "^1.2.4",
+    "load-tsconfig": "^0.2.5",
+    "magic-string": "^0.30.21",
+    "mlly": "^1.8.0",
+    "ms": "^2.1.3",
+    "mz": "^2.7.0",
+    "object-assign": "^4.1.1",
+    "pathe": "^2.0.3",
+    "picocolors": "^1.1.1",
+    "picomatch": "^4.0.3",
+    "pirates": "^4.0.7",
+    "pkg-types": "^1.3.1",
+    "postcss-load-config": "^6.0.1",
+    "readdirp": "^4.1.2",
+    "resolve-from": "^5.0.0",
+    "rollup": "^4.54.0",
+    "source-map": "^0.7.6",
+    "sucrase": "^3.35.1",
+    "thenify": "^3.3.1",
+    "thenify-all": "^1.6.0",
+    "tinyexec": "^0.3.2",
+    "tinyglobby": "^0.2.15",
+    "tree-kill": "^1.2.2",
+    "ts-interface-checker": "^0.1.13",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "ufo": "^1.6.1"
+  },
+  "devDependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chahidy/plannr.git"
+  },
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/chahidy/plannr/issues"
+  },
+  "homepage": "https://github.com/chahidy/plannr#readme"
+}

package/src/api/build-plan-numbers.ts

@@ -0,0 +1,54 @@
+// api/build-plan-numbers.ts
+import { BuildPlanNumbersInput } from "../domain/build-plan-numbers";
+import { Plan } from "../domain/plan";
+import { generateFloors } from "../generators/floors";
+import { buildPlanNumber } from "../generators/plan-number";
+
+export function buildPlanNumbers(input: BuildPlanNumbersInput): string[] {
+  let runningNumber = 1;
+  const plans: Plan[] = [];
+
+  for (const block of input.blocks) {
+    const floors = generateFloors(input.floorcfg);
+
+    for (const trade of block.trades) {
+      for (const type of block.planTypes) {
+        if (type === "GR") {
+          const perFloor = block.plansPerFloor ?? 1;
+
+          for (const floor of floors) {
+            for (let i = 0; i < perFloor; i++) {
+              plans.push({
+                trade,
+                type,
+                floor,
+                runningNumber: runningNumber++,
+              });
+            }
+          }
+        } else if (type === "SC") {
+          const count = block.minimumPerTrade ?? 1;
+
+          for (let i = 0; i < count; i++) {
+            plans.push({
+              trade,
+              type,
+              floor: undefined,
+              runningNumber: runningNumber++,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  return plans.map((plan) =>
+    buildPlanNumber(
+      plan,
+      input.projectNumber,
+      input.separator ?? "-",
+      input.suffix ?? "F",
+      input.index ?? "A"
+    )
+  );
+}

package/src/domain/block-config.ts

@@ -0,0 +1,84 @@
+// domain/block-config.ts
+import { Trade } from "./trade";
+import { PlanType } from "./plan-type";
+/**
+ * Konfiguriert einen zusammenhängenden Block von Plänen,
+ * der in definierter Reihenfolge generiert wird.
+ *
+ * Die Reihenfolge der Blocks bestimmt die Reihenfolge
+ * der erzeugten Plannummern.
+ */
+export interface PlanBlockConfig {
+  /**
+   * Gewerke, für die dieser Block gilt.
+   *
+   * Für jedes Gewerk wird die Block-Logik separat angewendet.
+   *
+   * @example ["LUE", "HEI", "SAN"]
+   */
+  trades: Trade[];
+
+  /**
+   * Planarten, die in diesem Block erzeugt werden.
+   *
+   * - `GR` = Grundriss
+   * - `SC` = Schema / Strangschema
+   *
+   * @example ["GR"]
+   */
+  planTypes: PlanType[];
+
+  /**
+   * Gibt an, ob die Pläne geschossbezogen erzeugt werden.
+   *
+   * - Relevant für Grundrisse (`GR`)
+   * - Wird ignoriert bei Schemata (`SC`)
+   *
+   * @default true bei GR, false bei SC
+   *
+   * ⚠️ Empfehlung:
+   * In der Regel nicht manuell setzen,
+   * sondern über `planTypes` steuern.
+   *
+   * * @deprecated Wird implizit über `plansPerFloor` gesteuert.
+   *
+   */
+  perFloor?: boolean;
+
+  /**
+   * Anzahl der Grundrisspläne pro Geschoss und Gewerk.
+   *
+   * - Standard: 1
+   * - Beispiel: 2 → zwei Grundrisse pro Geschoss
+   *
+   * Wird **nur angewendet**, wenn `planTypes` `GR` enthält.
+   *
+   * @example 1
+   */
+  plansPerFloor?: number;
+
+  /**
+   * Minimale Anzahl von Plänen pro Gewerk.
+   *
+   * - Standard: 1
+   * - Typischer Anwendungsfall: Strangschemata (`SC`)
+   *
+   * Wird **nur angewendet**, wenn `planTypes` `SC` enthält.
+   *
+   * @example 3
+   */
+  minimumPerTrade?: number;
+
+  /**
+   * Optionale Reihenfolge der Geschosse für diesen Block.
+   *
+   * Ermöglicht z. B.:
+   * - erst EG, dann OGs
+   * - Sonderreihenfolgen für bestimmte Planarten
+   *
+   * Enthält nur Geschossnamen, die in `FloorConfig` existieren.
+   *
+   * @example ["EG", "1OG", "2OG"]
+   */
+  floorOrder?: string[];
+}

package/src/domain/build-plan-numbers.ts

@@ -0,0 +1,40 @@
+import { PlanBlockConfig } from "./block-config";
+import { FloorConfig } from "./floor";
+
+/**
+ * Erzeugt Plannummern auf Basis von Blöcken, Geschossen und Projektparametern.
+ *
+ * @example
+ * ```ts
+ * buildPlanNumbers({
+ *   projectNumber: "21015",
+ *   floorcfg: { eg: "EG", ogPrefix: "OG" },
+ *   blocks: [
+ *     { trades: ["LUE"], planTypes: ["GR"], plansPerFloor: 1 },
+ *     { trades: ["HEI"], planTypes: ["SC"], minimumPerTrade: 2 }
+ *   ]
+ * })
+ * ```
+ */
+export interface BuildPlanNumbersInput {
+  /**
+   * Vereinfachte Angabe:
+   * Gesamtanzahl Geschosse (inkl. EG).
+   *
+   * ⚠️ Wird ignoriert, wenn `floorCounts` gesetzt ist.
+   */
+  floors?: number;
+
+  /**
+   * Erweiterte Geschossdefinition.
+   *
+   * Überschreibt die automatische Geschossermittlung.
+   */
+  floorCounts?: FloorConfig;
+  floorcfg?: FloorConfig;
+  blocks: PlanBlockConfig[];
+  projectNumber: string;
+  separator?: string;
+  suffix?: string;
+  index?: string;
+}

package/src/domain/floor.ts

@@ -0,0 +1,63 @@
+/**
+ * Basis-Floors (feste Namen)
+ */
+type BaseFloor = "UG" | "EG" | "1OG" | "2OG" | "3OG" | "DG";
+
+/**
+ * Floor mit optionalem Index/Suffix
+ * - z.B. UG1, OG2, EG1, DG1
+ */
+export type Floor<I extends string = `${number}`> =
+  | BaseFloor
+  | `${BaseFloor}${I}`;
+
+/**
+ * FloorCode = Array von Floors
+ */
+export type FloorCode = Floor[];
+
+/**
+ * Konfiguration der Geschossbezeichnungen.
+ *
+ * Ermöglicht unterschiedliche Bürostandards:
+ * - UG vs. -01
+ * - OG1 vs. 1OG
+ * - optionales Dachgeschoss
+ */
+export interface FloorConfig {
+  /**
+   * Untergeschoss-Bezeichnung (z. B. "UG" oder "-01").
+   */
+  ug?: {
+    prefix?: Floor;
+    count: number;
+  };
+
+  /**
+   * Erdgeschoss-Bezeichnung (z. B. "EG").
+   */
+  eg?: {
+    prefix?: Floor;
+    count: number;
+  };
+
+  /**
+   * Präfix für Obergeschosse.
+   *
+   * Beispiel:
+   * - Prefix: "OG"
+   * - Ergebnis: OG1, OG2, OG3, ...
+   */
+  og?: {
+    prefix?: Floor;
+    count: number;
+  };
+
+  /**
+   * Dachgeschoss-Bezeichnung (z. B. "DG").
+   */
+  dg?: {
+    prefix?: Floor;
+    count: number;
+  };
+}

package/src/domain/plan-number-parts.ts

@@ -0,0 +1,35 @@
+import { Floor } from "./floor";
+
+/**
+ * Projektnummer (z. B. "21015")
+ */
+export type ProjectNumber = string;
+
+/**
+ * Geschosskennzeichen (z. B. "EG", "1OG", "UG", "DG")
+ */
+export type FloorCode = Floor[];
+
+/**
+ * Laufende Plannummer innerhalb eines Projekts
+ * (z. B. "001", "002", ...)
+ */
+export type RunningNumber = string;
+
+/**
+ * Planstatus / Freigabestatus
+ * (z. B. "F", "A", "P")
+ */
+export type PlanStatus = string;
+
+/**
+ * Index / Revisionskennzeichen
+ * (z. B. "a", "b", "c")
+ */
+export type PlanIndex = string;
+
+/**
+ * Trennzeichen zwischen Plannummernblöcken
+ * (z. B. "-", "_")
+ */
+export type Separator = string;

package/src/domain/plan-number-type.ts

@@ -0,0 +1,41 @@
+import type { Trade } from "./trade";
+import type { PlanType } from "./plan-type";
+import type {
+  ProjectNumber,
+  RunningNumber,
+  PlanStatus,
+  PlanIndex,
+  Separator,
+} from "./plan-number-parts";
+import { Floor } from "./floor";
+
+/**
+ * Template Literal Type für eine Plannummer.
+ *
+ * Aufbau:
+ * Projekt → Gewerk → Planart → Geschoss → laufende Nummer → Status → Index
+ */
+export type Plannummer<
+  Sep extends Separator,
+  PN extends ProjectNumber,
+  G extends Trade,
+  T extends PlanType,
+  F extends Floor,
+  N extends RunningNumber,
+  S extends PlanStatus,
+  I extends PlanIndex
+> = `${PN}${Sep}${G}${Sep}${T}${Sep}${F}${Sep}${N}${Sep}${S}${Sep}${I}`;
+
+/**
+ * Standard-Plannummer, wie sie von der API zurückgegeben wird.
+ */
+export type DefaultPlannummer = Plannummer<
+  "-",
+  ProjectNumber,
+  Trade,
+  PlanType,
+  Floor,
+  RunningNumber,
+  PlanStatus,
+  PlanIndex
+>;

package/src/domain/plan-type.ts

@@ -0,0 +1,7 @@
+/**
+ * Planarten im TGA-Bereich.
+ *
+ * - `GR` = Grundriss
+ * - `SC` = Schema / Strangschema
+ */
+export type PlanType = "GR" | "SC" | "DT";

package/src/domain/plan.ts

@@ -0,0 +1,11 @@
+import { Trade } from "./trade";
+import { PlanType } from "./plan-type";
+import { FloorCode } from "./plan-number-parts";
+import { Floor } from "./floor";
+
+export interface Plan {
+  trade: Trade;
+  type: PlanType;
+  floor?: Floor;
+  runningNumber: number;
+}

package/src/domain/trade.ts

@@ -0,0 +1,18 @@
+/**
+ * Technische Gewerke (TGA).
+ *
+ * LUE - Lüftung
+ *
+ * HZ - Heizung
+ *
+ * SAN -  Sanitär
+ *
+ * EL - Elektro
+ *
+ * TR - Tragwerk
+ *
+ * AR - Architektur
+ *
+ * HLS - Heizung/Lüftung/Sanitär
+ */
+export type Trade = "LUE" | "HZ" | "SAN" | "EL" | "TR" | "AR" | "HLS";

package/src/generators/floors.ts

@@ -0,0 +1,52 @@
+// generators/floors.ts
+import { Floor, FloorConfig } from "../domain/floor";
+import { FloorCode } from "../domain/plan-number-parts";
+
+/**
+ * Generiert alle Geschosse basierend auf FloorConfig und optionaler Zählung.
+ * Unterstützt UG, EG, OGs, DG.
+ *
+ * @param counts - optionale Anzahl und Präfix pro Geschoss
+ * @param cfg - FloorConfig mit individuellen Bezeichnungen/Präfixen
+ * @returns Floor[] - Liste aller Geschosse
+ */
+export function generateFloors(
+  counts?: FloorConfig,
+  cfg?: FloorConfig
+): Floor[] {
+  const floors: Floor[] = [];
+
+  // -------------------
+  // Untergeschosse (UG)
+  // -------------------
+  const ugCount = counts?.ug?.count ?? 0;
+  const ugPrefix = cfg?.ug?.prefix ?? counts?.ug?.prefix ?? "UG";
+  for (let i = ugCount; i >= 1; i--) {
+    floors.push(`${ugPrefix}${i}` as Floor<`${number}`>);
+  }
+
+  // -------------------
+  // Erdgeschoss (EG)
+  // -------------------
+  const egName = cfg?.eg?.prefix ?? "EG";
+  floors.push(egName as Floor<`${number}`>);
+
+  // -------------------
+  // Obergeschosse (OG)
+  // -------------------
+  const ogCount = counts?.og?.count ?? 0;
+  const ogPrefix = cfg?.og?.prefix ?? counts?.og?.prefix ?? "OG";
+  for (let i = 1; i <= ogCount; i++) {
+    floors.push(`${ogPrefix}${i}` as Floor<`${number}`>);
+  }
+
+  // -------------------
+  // Dachgeschoss (DG)
+  // -------------------
+  if (counts?.dg) {
+    const dgName = cfg?.dg?.prefix ?? "DG";
+    floors.push(dgName as Floor<`${number}`>);
+  }
+
+  return floors;
+}

package/src/generators/plan-generator.ts

@@ -0,0 +1,46 @@
+// src/generators/plan-generator.ts
+import { Trade } from "../domain/trade";
+import { OfficeStandard } from "../standards/office-standard";
+import { Plan } from "../domain/plan";
+
+export function generatePlans(
+  trades: Trade[],
+  floors: string[],
+  standard: OfficeStandard
+): Plan[] {
+  let runningNumber = 1;
+  const plans: Plan[] = [];
+
+  for (const trade of trades) {
+    for (const rule of standard.planRules) {
+      if (rule.perFloor) {
+        for (const floor of floors) {
+          plans.push({
+            trade,
+            type: rule.type,
+            floor,
+            runningNumber: runningNumber++,
+          });
+        }
+      } else {
+        // Strangschemata / minimumPerTrade
+        const existingCount = plans.filter(
+          (p) => p.trade === trade && p.type === rule.type
+        ).length;
+        const needed = rule.minimumPerTrade
+          ? Math.max(rule.minimumPerTrade - existingCount, 0)
+          : 0;
+
+        for (let i = 0; i < needed; i++) {
+          plans.push({
+            trade,
+            type: rule.type,
+            runningNumber: runningNumber++,
+          });
+        }
+      }
+    }
+  }
+
+  return plans;
+}

package/src/generators/plan-number.ts

@@ -0,0 +1,33 @@
+// generators/plan-number.ts
+import { Plan } from "../domain/plan";
+import { Trade } from "../domain/trade";
+import { PlanType } from "../domain/plan-type";
+import { Plannummer } from "../domain/plan-number-type";
+
+export function buildPlanNumber<
+  P extends string,
+  Suf extends string = "F",
+  I extends string = "A"
+>(
+  plan: Plan,
+  projectNumber: P,
+  separator: string = "_",
+  suffix: Suf,
+  index: I
+): Plannummer<typeof separator, P, Trade, PlanType, string, string, Suf, I> {
+  const floor = plan.floor ?? "XX";
+  const trade = plan.trade ?? "AR";
+  const running = String(plan.runningNumber).padStart(3, "0");
+
+  // TypeScript prüft hier den Typ via Template Literal Type
+  return `${projectNumber}${separator}${trade}${separator}${plan.type}${separator}${floor}${separator}${running}${separator}${suffix}${separator}${index}` as Plannummer<
+    typeof separator,
+    P,
+    Trade,
+    PlanType,
+    string,
+    string,
+    Suf,
+    I
+  >;
+}

package/src/index.ts

@@ -0,0 +1,34 @@
+/**
+ * Plannummern-Generator für Bau- und TGA-Projekte.
+ *
+ * Dieses Paket ermöglicht die strukturierte Erzeugung von
+ * Plannummern auf Basis von:
+ * - Gewerken (Trades)
+ * - Planarten (Grundriss / Schema)
+ * - Geschossen
+ * - frei konfigurierbaren Bürostandards
+ *
+ * @example
+ * ```ts
+ * import { buildPlanNumbers } from "@dein-name/plannummern";
+ *
+ * const plans = buildPlanNumbers({
+ *   projectNumber: "21015",
+ *   floorcfg: { eg: "EG", ogPrefix: "OG" },
+ *   blocks: [
+ *     { trades: ["LUE"], planTypes: ["GR"], plansPerFloor: 1 },
+ *     { trades: ["HEI","SAN"], planTypes: ["SC"], minimumPerTrade: 2 }
+ *   ]
+ * });
+ * ```
+ */
+export { buildPlanNumbers } from "./api/build-plan-numbers";
+// zentrale Domänen-Typen
+export type { Trade } from "./domain/trade";
+export type { PlanType } from "./domain/plan-type";
+export type { FloorConfig } from "./domain/floor";
+export type { PlanBlockConfig } from "./domain/block-config";
+
+// Template Literal Type
+export type { DefaultPlannummer } from "./domain/plan-number-type";
+export type { BuildPlanNumbersInput } from "./domain/build-plan-numbers";