@openmbee/opensysml 0.9.2 → 0.10.1

package/dist/node/generate-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/node/generate-cli.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// The opensysml-generate bin: generate typed TypeScript classes from a model.
+import { main } from "./generate.js";
+try {
+    process.exitCode = await main(process.argv.slice(2));
+}
+catch (error) {
+    console.error(`error: ${error.message}`);
+    process.exitCode = 2;
+}

package/dist/node/generate.d.ts

@@ -0,0 +1,99 @@
+import type { Connection } from "../core/connection.js";
+import type { Model, SpecializationFacts, TypeFacts } from "../core/model.js";
+export declare const GENERATED_HEADER = "// Generated by opensysml-generate. Do not edit.";
+export declare const GENERATOR_VERSION = "5";
+export declare const MODEL_HASH_ALGORITHM = "sha256";
+export declare const UNSTAMPED = "unstamped";
+/** Whether a symbol kind declares a type, e.g. `partDef` or `metaclass`. */
+export declare function isDefinitionKind(kind: string): boolean;
+/** Whether a symbol kind is a usage exposed as an instance feature. */
+export declare function isFeatureKind(kind: string): boolean;
+/** One SysML feature to emit as a getter. */
+export interface Feature {
+    readonly id: string;
+    readonly name: string;
+    readonly kind: string;
+    readonly type?: TypeFacts | undefined;
+    readonly multiplicity?: {
+        lower: string;
+        upper: string;
+    } | undefined;
+}
+/** One SysML definition to emit as a class. */
+export declare class Definition {
+    readonly id: string;
+    readonly name: string;
+    readonly kind: string;
+    readonly specializations: readonly SpecializationFacts[];
+    readonly features: readonly Feature[];
+    constructor(init: {
+        id: string;
+        name: string;
+        kind: string;
+        specializations?: readonly SpecializationFacts[] | undefined;
+        features?: readonly Feature[] | undefined;
+    });
+    /** FQNs of what this definition specializes, subsets or redefines, in
+     * declaration order, without repetition. */
+    get baseIds(): readonly string[];
+}
+/** A rendered TypeScript annotation plus the decoder and note behind it. */
+export interface TypeScriptType {
+    readonly annotation: string;
+    readonly decoder: string;
+    readonly comment: string;
+}
+/** A symbol in a symbol tree; {@link ModelSymbol} satisfies this structurally. */
+export interface SymbolTree {
+    readonly id: string;
+    readonly name: string;
+    readonly kind: string;
+    readonly type?: TypeFacts | undefined;
+    readonly multiplicity?: {
+        lower: string;
+        upper: string;
+    } | undefined;
+    readonly specializations?: readonly SpecializationFacts[] | undefined;
+    children(): Promise<readonly SymbolTree[]>;
+}
+/** Collect the definitions in one or more symbol trees, sorted by FQN, each
+ * feature taking the type and multiplicity it inherits. */
+export declare function collectDefinitions(...roots: readonly SymbolTree[]): Promise<Definition[]>;
+/** Map definition FQN → TypeScript class name.
+ *
+ * A simple name declared by more than one definition is qualified with its
+ * owning path so that every generated class name is unique and stable. */
+export declare function classNames(definitions: readonly Definition[]): Map<string, string>;
+/** TypeScript name of the getter for a feature; the SysML feature name is unchanged. */
+export declare function propertyName(name: string): string;
+/** Map the type of a single value to a TypeScript annotation and decoder. */
+export declare function elementType(typeFacts: TypeFacts | undefined, names: Map<string, string>): TypeScriptType;
+/** Map a feature to its TypeScript annotation, decoder and accessor, honoring multiplicity. */
+export declare function featureType(feature: Feature, names: Map<string, string>): TypeScriptType;
+/** Hash of the model source a generated module was produced from.
+ *
+ * Newlines are normalized so the same model checked out with CRLF endings
+ * stamps identically; nothing else about the text is interpreted. */
+export declare function modelStamp(sourceText: string): string;
+/** Render a complete, importable TypeScript module for `definitions`.
+ *
+ * `stamp` is the {@link modelStamp} of the model source, recorded in the
+ * module so a reader — and the `--check` gate — can tell what it was generated
+ * from. Without one the module says `unstamped` rather than claim a hash it
+ * does not have. */
+export declare function renderModule(definitions: readonly Definition[], stamp?: string): string;
+/** Render the typed module for a loaded model.
+ *
+ * `sourceText` is the model source the module is stamped with; it is required
+ * so a module cannot silently claim the hash of nothing. A model of several
+ * documents (`Connection.parseSources`) is generated whole, from every
+ * document's root. */
+export declare function generateSource(model: Model, sourceText: string): Promise<string>;
+/** Fail unless `connection`'s service can supply static type facts. */
+export declare function requireTypeFacts(connection: Connection): void;
+/** The externally managed service `--host`/`--port` names, or undefined when
+ * neither names one and the connection starts a private child — or honors
+ * $OPENSYSML_SERVICE — the way `connect()` does with no address. */
+export declare function serviceAddress(host: string, port?: number): string | undefined;
+/** Entry point for the `opensysml-generate` bin. */
+export declare function main(argv?: readonly string[]): Promise<number>;