@tsplc/config 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,574 @@
+// packages/config/src/schema.ts
+import { z as z3 } from "zod";
+
+// packages/config/src/build-schema.ts
+import { z } from "zod";
+var commandArgumentSchema = z.string().refine((value) => value.trim().length > 0, "Command arguments must not be empty").refine((value) => !/["\r\n\0]/.test(value), "Command arguments must not contain quotes, line breaks, or null bytes");
+var codesysTimeouts = {
+  build: 20 * 60 * 1000,
+  hostCommand: 15000,
+  runtime: 60000,
+  startup: 20 * 60 * 1000,
+  stop: 1e4,
+  terminate: 5000
+};
+var positiveMilliseconds = z.number().int().positive();
+var pathSchema = z.string().trim().nonempty();
+var wineSchema = z.strictObject({
+  prefix: pathSchema,
+  binary: pathSchema.default("wine"),
+  pathBinary: pathSchema.default("winepath"),
+  debug: z.string().default("-all"),
+  nativeExit: z.boolean().default(false)
+});
+var localCodesysSchema = z.strictObject({
+  executable: commandArgumentSchema,
+  profile: commandArgumentSchema,
+  wine: wineSchema.optional(),
+  commandProcessor: pathSchema.default("cmd.exe")
+});
+var iecName = z.string().regex(/^[A-Za-z][A-Za-z0-9_]*$/);
+var cyclicTasksSchema = z.array(z.strictObject({
+  name: iecName,
+  intervalNanoseconds: z.string().regex(/^[1-9][0-9]*$/).refine((value) => {
+    if (!/^[1-9][0-9]*$/.test(value)) {
+      return false;
+    }
+    const ns = BigInt(value);
+    return ns % 1000000n === 0n && ns <= 4294967295000000n;
+  }, "Cyclic tasks require an exact positive TIME interval in milliseconds"),
+  priority: z.number().int().min(0).max(31),
+  programs: z.array(iecName).nonempty()
+})).nonempty().superRefine((tasks, context) => {
+  const names = new Set, programs = new Set;
+  tasks.forEach((task, index) => {
+    if (names.has(task.name.toLowerCase())) {
+      context.addIssue({
+        code: "custom",
+        path: [index, "name"],
+        message: "Task names must be unique"
+      });
+    }
+    names.add(task.name.toLowerCase());
+    task.programs.forEach((program, position) => {
+      if (programs.has(program.toLowerCase())) {
+        context.addIssue({
+          code: "custom",
+          path: [index, "programs", position],
+          message: "A program can be scheduled only once"
+        });
+      }
+      programs.add(program.toLowerCase());
+    });
+  });
+});
+var ioBindingOptions = {
+  inverted: z.boolean().optional(),
+  shared: z.boolean().optional()
+};
+var directIoBindingSchema = z.strictObject({
+  address: z.string().regex(/^%[IQ](?:X\d+\.[0-7]|[BWD]\d+)$/),
+  type: z.string().optional(),
+  ...ioBindingOptions
+});
+var ethernetSchema = z.strictObject({
+  interface: z.string().nonempty().optional(),
+  address: z.ipv4().optional(),
+  subnet: z.ipv4().optional(),
+  gateway: z.ipv4().optional()
+});
+var processImageSchema = z.strictObject({
+  address: z.string().regex(/^%[IQ]B\d+$/),
+  size: z.number().int().positive()
+});
+var deviceTreeSchema = z.strictObject({
+  ethernet: ethernetSchema.default({}),
+  devices: z.array(z.strictObject({
+    name: iecName,
+    eds: z.string().nonempty(),
+    address: z.ipv4().optional(),
+    rpiMicroseconds: z.number().int().positive().optional(),
+    inputs: processImageSchema.optional(),
+    outputs: processImageSchema.optional(),
+    modbus: z.strictObject({
+      port: z.number().int().positive(),
+      registers: z.array(z.strictObject({
+        name: iecName,
+        offset: z.number().int().nonnegative(),
+        value: z.string().regex(/^%QW\d+$/),
+        write: z.string().regex(/^%QX\d+\.[0-7]$/),
+        status: z.string().regex(/^%IB\d+$/),
+        requests: z.string().regex(/^%ID\d+$/)
+      }))
+    }).optional(),
+    comments: z.array(z.strictObject({
+      address: z.string().regex(/^%[IQ](?:X\d+\.[0-7]|B\d+)$/),
+      text: z.string().nonempty()
+    })).default([])
+  })).nonempty(),
+  mappings: z.array(z.strictObject({
+    address: z.string().regex(/^%[IQ](?:X\d+\.[0-7]|B\d+)$/),
+    variable: z.string().nonempty()
+  })).default([])
+});
+var controllerSchema = z.strictObject({
+  type: z.number().int().positive(),
+  id: z.string().regex(/^[0-9A-F]{4} [0-9A-F]{4}$/),
+  version: z.string().regex(/^\d+\.\d+\.\d+\.\d+$/)
+});
+var controllerTargetSchema = controllerSchema.pick({ version: true }).extend({
+  target: z.enum(["linux-sl", "virtual-linux-arm64-sl"])
+});
+var controllerDevices = {
+  "linux-sl": { type: 4102, id: "0000 0005" },
+  "virtual-linux-arm64-sl": { type: 4096, id: "0000 1008" }
+};
+var configSchema = z.strictObject({
+  io: z.record(z.string(), directIoBindingSchema).optional(),
+  deviceTree: deviceTreeSchema.optional(),
+  controller: controllerSchema.optional(),
+  libraryReferences: z.array(z.string().nonempty()).default([]),
+  libraries: z.array(z.strictObject({
+    title: z.string(),
+    company: z.string().optional(),
+    version: z.string().optional(),
+    namespace: z.string().optional(),
+    path: pathSchema,
+    sha256: z.string().regex(/^[a-f0-9]{64}$/),
+    url: z.string().optional()
+  })).optional(),
+  docker: z.strictObject({
+    cpuSet: z.string().regex(/^\d+(?:-\d+)?(?:,\d+(?:-\d+)?)*$/).optional()
+  }).optional(),
+  template: pathSchema.optional(),
+  sourceDir: pathSchema.default("src"),
+  entry: pathSchema.default("src/Main.st"),
+  outDir: pathSchema.default("build"),
+  task: z.string().nonempty().default("MainTask"),
+  tasks: cyclicTasksSchema.optional(),
+  removeObjects: z.array(z.string().nonempty()).default([]),
+  symbols: z.boolean().default(false),
+  online: z.strictObject({
+    network: pathSchema.default("bridge"),
+    gateway: z.strictObject({
+      host: pathSchema,
+      port: z.number().int().min(1).max(65535).default(1217)
+    }),
+    device: z.strictObject({
+      host: pathSchema,
+      port: z.number().int().min(1).max(65535).default(11740)
+    }),
+    credentials: z.strictObject({
+      usernameEnv: z.string().regex(/^[A-Za-z_][A-Za-z_0-9]*$/),
+      passwordEnv: z.string().regex(/^[A-Za-z_][A-Za-z_0-9]*$/)
+    }).optional()
+  }).optional(),
+  timeouts: z.strictObject({
+    startup: positiveMilliseconds.default(codesysTimeouts.startup),
+    build: positiveMilliseconds.default(codesysTimeouts.build),
+    stop: positiveMilliseconds.default(codesysTimeouts.stop),
+    terminate: positiveMilliseconds.default(codesysTimeouts.terminate),
+    hostCommand: positiveMilliseconds.default(codesysTimeouts.hostCommand),
+    runtime: positiveMilliseconds.default(codesysTimeouts.runtime)
+  }).prefault({})
+});
+
+// packages/config/src/compiler.ts
+import { z as z2 } from "zod";
+var durationSchema = z2.object({
+  kind: z2.literal("duration"),
+  nanoseconds: z2.string().regex(/^[1-9][0-9]*$/)
+}).strict();
+function duration(value, scale) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error("Task duration must be finite and positive.");
+  }
+  const nanoseconds = value * scale;
+  if (!Number.isSafeInteger(nanoseconds)) {
+    throw new Error("Task duration must be an exact, safe number of nanoseconds.");
+  }
+  return { kind: "duration", nanoseconds: String(nanoseconds) };
+}
+var ns = (value) => duration(value, 1);
+var ms = (value) => duration(value, 1e6);
+var seconds = (value) => duration(value, 1e9);
+var sourceExportSchema = z2.object({ module: z2.string().min(1), export: z2.string().min(1) }).strict();
+var taskSchema = z2.object({
+  name: z2.string().min(1),
+  schedule: z2.object({ kind: z2.literal("cyclic"), interval: durationSchema }).strict(),
+  priority: z2.number().int().nonnegative(),
+  programs: z2.array(z2.string().min(1)).min(1)
+}).strict();
+var targetSchema = z2.object({
+  kind: z2.string().min(1),
+  options: z2.unknown().refine((value) => value !== undefined, { message: "Target options are required." })
+}).strict();
+var common = {
+  name: z2.string().min(1),
+  tsconfig: z2.string().min(1),
+  tasks: z2.array(taskSchema).min(1),
+  target: targetSchema
+};
+var entryConfigSchema = z2.object({ ...common, entry: sourceExportSchema }).strict();
+var programsConfigSchema = z2.object({ ...common, programs: z2.record(z2.string().min(1), sourceExportSchema) }).strict();
+function definePlcConfig(config) {
+  return config;
+}
+function validateConfig(value) {
+  const multiplePrograms = typeof value === "object" && value !== null && Object.hasOwn(value, "programs") && !Object.hasOwn(value, "entry");
+  const parsed = (multiplePrograms ? programsConfigSchema : entryConfigSchema).safeParse(value);
+  if (!parsed.success) {
+    return {
+      diagnostics: parsed.error.issues.map((issue) => ({
+        origin: "config",
+        code: "PLC5001",
+        severity: "error",
+        message: `${issue.path.join(".") || "config"}: ${issue.message}`
+      }))
+    };
+  }
+  const { data } = parsed;
+  const programs = "entry" in data ? { main: data.entry } : data.programs;
+  const diagnostics = [];
+  const report = (message) => {
+    diagnostics.push({ origin: "config", code: "PLC5002", severity: "error", message });
+  };
+  if (Object.keys(programs).length === 0) {
+    report("At least one program is required.");
+  }
+  const taskNames = new Set;
+  const assigned = new Set;
+  for (const task of data.tasks) {
+    if (taskNames.has(task.name)) {
+      report(`Duplicate task name: ${task.name}.`);
+    }
+    taskNames.add(task.name);
+    for (const program of task.programs) {
+      if (!Object.hasOwn(programs, program)) {
+        report(`Task ${task.name} references unknown program ${program}.`);
+      }
+      if (assigned.has(program)) {
+        report(`Program ${program} must belong to exactly one task.`);
+      }
+      assigned.add(program);
+    }
+  }
+  for (const program of Object.keys(programs)) {
+    if (!assigned.has(program)) {
+      report(`Program ${program} is not assigned to a task.`);
+    }
+  }
+  if (diagnostics.length) {
+    return { diagnostics };
+  }
+  return {
+    config: {
+      name: data.name,
+      tsconfig: data.tsconfig,
+      programs,
+      tasks: data.tasks,
+      target: data.target
+    },
+    diagnostics
+  };
+}
+
+// packages/config/src/schema.ts
+var httpOptionsSchema = z3.strictObject({
+  timeoutMs: z3.number().int().positive().max(60000).default(2000),
+  credentials: z3.array(z3.strictObject({
+    originEnv: z3.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/),
+    bearerTokenEnv: z3.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/)
+  })).default([])
+}).default({ timeoutMs: 2000, credentials: [] });
+var ioBindingSchema = z3.union([
+  directIoBindingSchema,
+  z3.strictObject({
+    device: z3.string().min(1),
+    channel: z3.string().min(1),
+    ...ioBindingOptions
+  })
+]);
+var assemblySchema = z3.strictObject({
+  assembly: z3.number().int().nonnegative().optional(),
+  size: z3.number().int().positive().optional(),
+  address: z3.string().regex(/^%[IQ]B\d+$/).optional()
+});
+var hardwareDeviceSchema = z3.strictObject({
+  file: z3.string().min(1),
+  connection: z3.string().min(1).optional(),
+  inputs: assemblySchema.optional(),
+  outputs: assemblySchema.optional(),
+  modbus: z3.strictObject({
+    port: z3.number().int().min(1).max(65535).default(502),
+    registers: z3.record(z3.string().regex(/^[A-Za-z][A-Za-z0-9_]*$/), z3.number().int().min(0).max(65535))
+  }).optional(),
+  statusSymbols: z3.record(z3.string(), z3.string()).optional(),
+  network: z3.strictObject({
+    address: z3.ipv4().optional(),
+    rpi: durationSchema.refine((rpi) => BigInt(rpi.nanoseconds) % 1000n === 0n, "An RPI must be a whole number of microseconds.").optional()
+  }).optional()
+});
+var dependencySchema = z3.union([
+  z3.string().regex(/^\d+\.\d+\.\d+\.\d+$/),
+  z3.strictObject({
+    version: z3.string().regex(/^\d+\.\d+\.\d+\.\d+$/),
+    company: z3.string().optional(),
+    namespace: z3.string().optional()
+  }),
+  z3.strictObject({ path: z3.string().min(1), namespace: z3.string().optional() })
+]);
+var taskSchema2 = z3.strictObject({
+  name: z3.string().regex(/^[A-Za-z][A-Za-z0-9_]*$/),
+  schedule: z3.strictObject({ kind: z3.literal("cyclic"), interval: durationSchema }),
+  priority: z3.number().int().min(0).max(31),
+  programs: z3.array(z3.string().min(1)).nonempty()
+});
+var monitorSchema = z3.strictObject({
+  endpoint: z3.string().url(),
+  namespaceUri: z3.string().optional(),
+  symbols: z3.array(z3.string().min(1)).optional(),
+  securityMode: z3.enum(["None", "Sign", "SignAndEncrypt"]).default("SignAndEncrypt"),
+  securityPolicy: z3.enum(["None", "Basic256Sha256"]).optional(),
+  certificateDirectory: z3.string().min(1).default(".tsplc/opcua-pki"),
+  username: z3.string().min(1).optional(),
+  passwordEnv: z3.string().regex(/^[A-Za-z_][A-Za-z_0-9]*$/).optional()
+}).superRefine((monitor, context) => {
+  if (monitor.securityPolicy && monitor.securityMode === "None" !== (monitor.securityPolicy === "None"))
+    context.addIssue({
+      code: "custom",
+      path: ["securityPolicy"],
+      message: "None mode requires None policy; secure modes require Basic256Sha256."
+    });
+  if (monitor.passwordEnv && !monitor.username)
+    context.addIssue({
+      code: "custom",
+      path: ["username"],
+      message: "Configure username when passwordEnv is used."
+    });
+  if (monitor.username && monitor.securityMode === "None")
+    context.addIssue({
+      code: "custom",
+      path: ["securityMode"],
+      message: "Username authentication requires a secure OPC-UA connection."
+    });
+}).transform((monitor) => ({
+  ...monitor,
+  securityPolicy: monitor.securityPolicy ?? (monitor.securityMode === "None" ? "None" : "Basic256Sha256")
+}));
+var typegenSchema = z3.strictObject({
+  types: z3.union([z3.string(), z3.array(z3.string())]).optional(),
+  globals: z3.union([z3.string(), z3.array(z3.string())]).optional(),
+  dir: z3.string().default("generated"),
+  declarations: z3.boolean().default(true),
+  ioTypes: z3.boolean().default(true)
+});
+var buildTargetSchema = z3.enum(["production", "development"]);
+var publicationSchema = z3.strictObject({
+  production: z3.array(z3.string().nonempty()),
+  development: z3.array(z3.string().nonempty())
+});
+var hmiTarget = z3.string().regex(/^\w+(\.\w+|\[\d+\])+$/);
+var hmiControlSchema = z3.discriminatedUnion("kind", [
+  z3.strictObject({
+    kind: z3.literal("button"),
+    label: z3.string().nonempty(),
+    target: hmiTarget,
+    tone: z3.enum(["start", "stop"]).optional(),
+    confirm: z3.boolean().optional()
+  }),
+  z3.strictObject({
+    kind: z3.literal("toggle"),
+    label: z3.string().nonempty(),
+    target: hmiTarget
+  }),
+  z3.strictObject({
+    kind: z3.literal("slider"),
+    label: z3.string().nonempty(),
+    target: hmiTarget,
+    min: z3.number().int(),
+    max: z3.number().int()
+  })
+]);
+var hmiSchema = z3.strictObject({
+  title: z3.string().nonempty(),
+  controls: z3.array(hmiControlSchema).default([]),
+  conveyors: z3.array(z3.strictObject({
+    label: z3.string().nonempty(),
+    positions: z3.number().int().positive(),
+    diverters: z3.array(z3.number().int().nonnegative()).default([])
+  })).default([])
+});
+var tsplcConfigSchema = z3.strictObject({
+  name: z3.string().default("Application"),
+  backend: z3.literal("codesys"),
+  publish: publicationSchema.optional(),
+  server: z3.strictObject({
+    baseUrlEnv: z3.string().optional(),
+    transport: z3.enum(["http", "opcua"]).default("http"),
+    runtime: z3.strictObject({
+      entry: z3.string(),
+      target: z3.enum([
+        "bun-linux-x64",
+        "bun-linux-arm64",
+        "bun-darwin-x64",
+        "bun-darwin-arm64",
+        "bun-windows-x64"
+      ]).optional()
+    }).optional()
+  }).optional(),
+  compiler: z3.strictObject({
+    tsconfig: z3.string().default("tsconfig.json"),
+    programs: z3.record(z3.string(), z3.strictObject({ module: z3.string(), export: z3.string() }))
+  }).optional(),
+  tasks: z3.array(taskSchema2).nonempty().optional(),
+  build: configSchema.extend({ task: configSchema.shape.task.unwrap().optional() }).optional(),
+  codesys: z3.strictObject({
+    http: httpOptionsSchema.optional(),
+    programNames: z3.record(z3.string(), z3.string()).optional(),
+    deviceTree: z3.strictObject({ ethernet: ethernetSchema.optional() }).optional(),
+    controllers: z3.strictObject({
+      production: controllerTargetSchema.optional(),
+      development: controllerTargetSchema.optional()
+    }).optional()
+  }).optional(),
+  eds: z3.union([z3.string(), z3.array(z3.string())]).default("eds"),
+  devices: z3.record(z3.string(), hardwareDeviceSchema).default({}),
+  io: z3.record(z3.string(), ioBindingSchema).default({}),
+  dependencies: z3.record(z3.string(), dependencySchema).default({}),
+  typegen: typegenSchema.optional(),
+  monitor: monitorSchema.optional(),
+  hmi: hmiSchema.optional()
+});
+var buildTargetFor = (command) => ["run", "download", "online-change", "inspect"].includes(command) ? "development" : "production";
+var controllerFor = (config, command) => {
+  const controller = config.codesys?.controllers?.[buildTargetFor(command)];
+  return controller && { ...controllerDevices[controller.target], version: controller.version };
+};
+var simulationConfig = (config) => ({
+  ...config,
+  eds: [],
+  devices: {},
+  io: {},
+  ...config.codesys && {
+    codesys: {
+      ...config.codesys,
+      deviceTree: undefined
+    }
+  }
+});
+function defineConfig(config) {
+  return config;
+}
+function rawBuildConfig(config) {
+  if (config.compiler)
+    throw new Error("Use the compiler build plan for TypeScript projects.");
+  if (!config.build)
+    throw new Error("Configure build settings.");
+  if (!config.tasks)
+    return config.build;
+  if (config.build.tasks || config.build.task !== undefined)
+    throw new Error("Configure the raw ST schedule in tasks or build.tasks/build.task, not both.");
+  return {
+    ...config.build,
+    tasks: cyclicTasksSchema.parse(config.tasks.map((task) => ({
+      name: task.name,
+      intervalNanoseconds: task.schedule.interval.nanoseconds,
+      priority: task.priority,
+      programs: task.programs
+    })))
+  };
+}
+function compilerConfig(config, io, buildTarget = "production") {
+  if (!config.compiler || !config.tasks)
+    throw new Error("This project uses raw Structured Text; no TypeScript compiler is configured.");
+  const { deviceTree: _deviceTree, controllers: _controllers, ...codesys } = config.codesys ?? {};
+  const value = {
+    name: config.name,
+    tsconfig: config.compiler.tsconfig,
+    programs: config.compiler.programs,
+    tasks: config.tasks,
+    target: {
+      kind: config.backend,
+      options: {
+        ...codesys,
+        publish: config.publish,
+        buildTarget,
+        io: Object.fromEntries(Object.entries(io).map(([name, binding]) => [
+          name,
+          {
+            kind: "direct",
+            ...binding,
+            ...mappedChannel(config, name, binding) && { mapped: true }
+          }
+        ])),
+        engineering: {
+          kind: "v3.5",
+          ...config.build ? { build: compilerBuildOptions(config.build) } : {}
+        }
+      }
+    }
+  };
+  const validated = validateConfig(value);
+  if (!validated.config)
+    throw new Error(validated.diagnostics.map((item) => item.message).join(`
+`));
+  return validated.config;
+}
+function mappedChannel(config, name, binding) {
+  const source = config.io[name];
+  return config.codesys?.deviceTree !== undefined && source !== undefined && "device" in source && !binding.inverted && !binding.shared && /^%[IQ][XB]/.test(binding.address) && !/^ARRAY/i.test(binding.type ?? "");
+}
+function compilerBuildOptions(build) {
+  const {
+    sourceDir: _source,
+    entry: _entry,
+    outDir: _out,
+    task: _task,
+    tasks: _tasks,
+    ...settings
+  } = build;
+  return settings;
+}
+// packages/config/src/loader.ts
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { createJiti } from "jiti";
+async function loadTsplcConfig(file = "tsplc.config.ts") {
+  const configFile = resolve(file);
+  await readFile(configFile);
+  const jiti = createJiti(import.meta.url, {
+    moduleCache: false,
+    fsCache: false,
+    interopDefault: false,
+    tryNative: false
+  });
+  const module = await jiti.import(configFile);
+  const config = tsplcConfigSchema.parse(module.default ?? module.config);
+  if (config.compiler && !config.tasks)
+    throw new Error("TypeScript programs require a tasks configuration.");
+  return { configFile, root: dirname(configFile), config };
+}
+export {
+  buildTargetFor,
+  buildTargetSchema,
+  compilerConfig,
+  controllerFor,
+  defineConfig,
+  definePlcConfig,
+  hmiSchema,
+  httpOptionsSchema,
+  loadTsplcConfig,
+  ms,
+  ns,
+  publicationSchema,
+  rawBuildConfig,
+  seconds,
+  simulationConfig,
+  tsplcConfigSchema,
+  typegenSchema,
+  validateConfig
+};
+
+//# debugId=35D15C1A44FCA22C64756E2164756E21
+//# sourceMappingURL=index.js.map