@istar-ts/core 0.2.0 → 0.3.0

package/dist/index.d.cts

@@ -0,0 +1,578 @@
+//#endregion
+//#region src/metamodel.d.ts
+/**
+ * The iStar 2.0 metamodel, ported from piStar's `tool/language/metamodel.js`.
+ *
+ * Kind names carry the `istar.` prefix exactly as they appear in piStar save files.
+ */
+export declare const ISTAR_PREFIX = "istar";
+export declare const METAMODEL_VERSION = "0.2";
+/** Containers: elements that hold inner elements (piStar `metamodel.containers`). */
+export declare const ACTOR_KINDS: readonly ["istar.Actor", "istar.Agent", "istar.Role"];
+export type ActorKind = (typeof ACTOR_KINDS)[number];
+/** Intentional elements (piStar `metamodel.nodes`). */
+export declare const NODE_KINDS: readonly ["istar.Goal", "istar.Quality", "istar.Resource", "istar.Task"];
+export type NodeKind = (typeof NODE_KINDS)[number];
+export type ElementKind = ActorKind | NodeKind;
+export declare const ELEMENT_KINDS: readonly ElementKind[];
+/** Links between two containers (piStar `metamodel.containerLinks`). */
+export declare const ACTOR_LINK_KINDS: readonly ["istar.IsALink", "istar.ParticipatesInLink"];
+export type ActorLinkKind = (typeof ACTOR_LINK_KINDS)[number];
+/** Links that connect two containers through a dependum (piStar `metamodel.dependencyLinks`). */
+export declare const DEPENDENCY_LINK_KINDS: readonly ["istar.DependencyLink"];
+export type DependencyLinkKind = (typeof DEPENDENCY_LINK_KINDS)[number];
+/** Links between two intentional elements (piStar `metamodel.nodeLinks`). */
+export declare const NODE_LINK_KINDS: readonly ["istar.AndRefinementLink", "istar.OrRefinementLink", "istar.NeededByLink", "istar.QualificationLink", "istar.ContributionLink"];
+export type NodeLinkKind = (typeof NODE_LINK_KINDS)[number];
+export type LinkKind = ActorLinkKind | DependencyLinkKind | NodeLinkKind;
+export declare const LINK_KINDS: readonly LinkKind[];
+/** Possible values of a Contribution link's `label`. */
+export declare const CONTRIBUTION_LABELS: readonly ["make", "help", "hurt", "break"];
+export type ContributionLabel = (typeof CONTRIBUTION_LABELS)[number];
+export interface NodeKindInfo {
+  /** Can be added inside an actor. */
+  readonly canBeInnerElement: boolean;
+  /** Can be the dependum of a dependency. */
+  readonly canBeDependum: boolean;
+  /** Can be placed directly on the diagram, outside any actor. */
+  readonly canBeOnPaper: boolean;
+}
+export interface LinkKindInfo {
+  /** Fixed text drawn on the link (e.g. "is-a"). */
+  readonly label?: string;
+  /** piStar retries with source and target swapped when the first attempt is invalid. */
+  readonly tryReversedWhenAdding?: boolean;
+  /** The link carries a user-selectable label, stored as `label` in the save file. */
+  readonly changeableLabel?: boolean;
+  readonly possibleLabels?: readonly string[];
+}
+export declare const NODE_KIND_INFO: Readonly<Record<NodeKind, NodeKindInfo>>;
+export declare const LINK_KIND_INFO: Readonly<Record<LinkKind, LinkKindInfo>>;
+export interface Size {
+  width: number;
+  height: number;
+}
+/**
+ * Default sizes of each element kind, from piStar's `shapes.js`. For actors this is the
+ * initial boundary size; the collapsed actor symbol is a circle of radius 40.
+ */
+export declare const DEFAULT_ELEMENT_SIZE: Readonly<Record<ElementKind, Size>>;
+export declare function isActorKind(kind: string): kind is ActorKind;
+export declare function isNodeKind(kind: string): kind is NodeKind;
+export declare function isElementKind(kind: string): kind is ElementKind;
+export declare function isLinkKind(kind: string): kind is LinkKind;
+export declare function isActorLinkKind(kind: string): kind is ActorLinkKind;
+export declare function isNodeLinkKind(kind: string): kind is NodeLinkKind;
+export declare function isDependencyLinkKind(kind: string): kind is DependencyLinkKind;
+export declare function isContributionLabel(value: string): value is ContributionLabel;
+/** `'istar.Goal'` → `'Goal'` */
+export declare function shortKindName(kind: ElementKind | LinkKind): string;
+//#endregion
+//#region src/model.d.ts
+/**
+ * piStar stores every custom property value as a string (e.g. `"initialValue": "false"`).
+ * Typed access is layered on top with property schemas (see `properties.ts`).
+ */
+export type CustomProperties = Readonly<Record<string, string>>;
+/** Arbitrary JSON keys the library does not interpret; kept so they survive a round trip. */
+export type Extra = Readonly<Record<string, unknown>>;
+export interface Point {
+  readonly x: number;
+  readonly y: number;
+}
+/** Per-element entry of the save file's `display` section. */
+export interface ElementDisplay {
+  readonly backgroundColor?: string;
+  readonly width?: number;
+  readonly height?: number;
+  /** Actors only. */
+  readonly collapsed?: boolean;
+  readonly [key: string]: unknown;
+}
+/** Per-link entry of the save file's `display` section. */
+export interface LinkDisplay {
+  readonly vertices?: readonly Point[];
+  readonly [key: string]: unknown;
+}
+export interface IstarElement<K extends ElementKind = ElementKind> {
+  readonly id: string;
+  readonly kind: K;
+  /** The element's label; `text` in the save file. */
+  readonly name: string;
+  /** Absolute diagram coordinates, as in the save file (children are not relative to actors). */
+  readonly x: number;
+  readonly y: number;
+  /** Id of the containing actor, for inner elements. */
+  readonly parent?: string;
+  /** True when the element is the dependum of a dependency (lives in `dependencies`). */
+  readonly isDependum?: boolean;
+  /**
+   * Depender/dependee recorded in the save file for a dependum. The dependency links are the
+   * source of truth; this is only a fallback used when those links are missing.
+   */
+  readonly dependency?: {
+    readonly source: string;
+    readonly target: string;
+  };
+  readonly customProperties?: CustomProperties;
+  readonly display?: ElementDisplay;
+  readonly extra?: Extra;
+}
+export type IstarActor = IstarElement<ActorKind>;
+export type IstarNode = IstarElement<NodeKind>;
+export interface IstarLink<K extends LinkKind = LinkKind> {
+  readonly id: string;
+  readonly kind: K;
+  readonly source: string;
+  readonly target: string;
+  /** Contribution value (`make`/`help`/`hurt`/`break`), stored as `label` in the save file. */
+  readonly label?: string;
+  readonly name?: string;
+  readonly customProperties?: CustomProperties;
+  readonly display?: LinkDisplay;
+  readonly extra?: Extra;
+}
+export interface Diagram {
+  readonly width?: number;
+  readonly height?: number;
+  readonly name?: string;
+  readonly customProperties?: CustomProperties;
+  readonly extra?: Extra;
+}
+/**
+ * An immutable iStar model. Maps preserve insertion order, which is the order elements and
+ * links are written back to disk.
+ */
+export interface IstarModel {
+  readonly elements: ReadonlyMap<string, IstarElement>;
+  readonly links: ReadonlyMap<string, IstarLink>;
+  readonly diagram?: Diagram;
+  readonly tool?: string;
+  readonly istar?: string;
+  readonly saveDate?: string;
+  /** `display` entries whose id matches no element or link. */
+  readonly extraDisplay?: Extra;
+  /** Unknown top-level keys (e.g. `metamodelVersion`). */
+  readonly extra?: Extra;
+}
+/** Tool identifier written by piStar 2.1.0, whose file format this library emulates. */
+export declare const PISTAR_TOOL = "pistar.2.1.0";
+export declare const ISTAR_VERSION = "2.0";
+export declare const DEFAULT_DIAGRAM: Diagram;
+export declare function createEmptyModel(diagram?: Diagram): IstarModel;
+export declare function isActor(element: IstarElement | undefined): element is IstarActor;
+export declare function isNode(element: IstarElement | undefined): element is IstarNode;
+/** Inner elements of an actor, in model order. */
+export declare function childrenOf(model: IstarModel, actorId: string): IstarElement[];
+/** Links that have the element as source or target. */
+export declare function linksOf(model: IstarModel, elementId: string): IstarLink[];
+/** For a dependum, the two halves of its dependency: depender → dependum → dependee. */
+export declare function dependencyLinksOf(model: IstarModel, dependumId: string): {
+  inbound?: IstarLink;
+  outbound?: IstarLink;
+};
+//#endregion
+//#region src/constraints.d.ts
+export type ConstraintCode = "unknown-element" | "unknown-link-kind" | "invalid-source" | "invalid-target" | "actor-types-differ" | "self-link" | "duplicate-link" | "dependum-endpoint" | "same-actor" | "different-actors" | "refined-depender" | "contributed-depender" | "depender-target" | "mixed-refinement" | "contribution-and-qualification";
+export type LinkCheck = {
+  ok: true;
+} | {
+  ok: false;
+  reason: string;
+  code: ConstraintCode;
+};
+type ElementRef = string | IstarElement;
+/**
+ * Checks whether a link of `kind` may be added from `source` to `target` in `model`.
+ *
+ * For `istar.DependencyLink`, `source` is the depender and `target` the dependee (an actor or
+ * one of its inner elements); the dependum sits between them and is not part of the check.
+ */
+export declare function canLink(model: IstarModel, source: ElementRef, target: ElementRef, kind: LinkKind): LinkCheck;
+export interface ModelIssue {
+  readonly linkId: string;
+  readonly kind: LinkKind;
+  readonly source: string;
+  readonly target: string;
+  readonly code: ConstraintCode;
+  readonly message: string;
+}
+/**
+ * Re-validates every link of a model, the way piStar does when loading a file: dependencies
+ * first (each checked before its own links are added), then the remaining links in file
+ * order, each against the graph built so far. Invalid links are reported, not removed.
+ */
+export declare function validateModel(model: IstarModel): ModelIssue[];
+//#endregion
+//#region src/serialization.d.ts
+export interface PistarElementJson {
+  id: string;
+  text: string;
+  type: string;
+  x: number;
+  y: number;
+  customProperties?: Record<string, string>;
+  [key: string]: unknown;
+}
+export interface PistarActorJson extends PistarElementJson {
+  nodes: PistarElementJson[];
+}
+export interface PistarDependencyJson extends PistarElementJson {
+  source: string;
+  target: string;
+}
+export interface PistarLinkJson {
+  id: string;
+  type: string;
+  source: string;
+  target: string;
+  name?: string;
+  customProperties?: Record<string, string>;
+  label?: string;
+  [key: string]: unknown;
+}
+export interface PistarDiagramJson {
+  width?: number;
+  height?: number;
+  name?: string;
+  customProperties?: Record<string, string>;
+  [key: string]: unknown;
+}
+/** A piStar save file. Older piStar versions may omit some sections (e.g. `orphans`). */
+export interface PistarFile {
+  actors: PistarActorJson[];
+  orphans?: PistarElementJson[];
+  dependencies?: PistarDependencyJson[];
+  links?: PistarLinkJson[];
+  display?: Record<string, Record<string, unknown>>;
+  tool?: string;
+  istar?: string;
+  saveDate?: string;
+  diagram?: PistarDiagramJson;
+  [key: string]: unknown;
+}
+export declare class PistarParseError extends Error {
+  override name: string;
+}
+/**
+ * Parse-time bookkeeping that lets `toPistar` reproduce the original key order. It has no
+ * meaning for the model itself and may be dropped.
+ */
+export interface SourceLayout {
+  /** Top-level keys in file order. */
+  readonly keys: readonly string[];
+  /** `display` ids in file order. */
+  readonly display: readonly string[];
+}
+/** The key order recorded when `model` was parsed, if it came from `parsePistar`. */
+export declare function getSourceLayout(model: IstarModel): SourceLayout | undefined;
+/**
+ * Carries the recorded key order over to a model derived from `from` (the store does this for
+ * every edit, so saving an edited file keeps a stable diff).
+ */
+export declare function inheritSourceLayout<M extends IstarModel>(from: IstarModel, to: M): M;
+/**
+ * Parses a piStar save file (JSON text or an already-parsed object). The input is not mutated.
+ *
+ * Unlike the piStar tool, elements with `x` or `y` equal to 0 are kept: upstream's
+ * `if (element.x && element.y)` silently drops them, which looks unintended.
+ */
+export declare function parsePistar(input: string | PistarFile | Record<string, unknown>): IstarModel;
+export interface ToPistarOptions {
+  /**
+   * Value for `saveDate`. Defaults to the model's own `saveDate` (so a load/save round trip is
+   * lossless), or the current time for models that never had one. Pass `new Date()` when
+   * saving an edited model, as piStar does.
+   */
+  saveDate?: string | Date;
+}
+/** Builds the save-file object for a model. `toPistar` is this plus `JSON.stringify`. */
+export declare function toPistarObject(model: IstarModel, options?: ToPistarOptions): PistarFile;
+/** Serializes a model to piStar's JSON text (2-space indentation, no trailing newline). */
+export declare function toPistar(model: IstarModel, options?: ToPistarOptions): string;
+declare namespace operations_d_exports {
+  export { AddDependencyResult, ConnectOptions, ConnectResult, ElementPatch, IdGenerator, LinkPatch, ModelOperationError, NewDependency, NewElement, NewLink, OperationContext, addDependency, addElement, connect, defaultIdGenerator, dependencyEnds, disconnect, moveElement, nestElement, removeElement, removeElements, updateDiagram, updateElement, updateLink };
+}
+export declare class ModelOperationError extends Error {
+  override name: string;
+}
+/** Generates ids for new elements and links. piStar uses UUID v4. */
+export type IdGenerator = () => string;
+export declare const defaultIdGenerator: IdGenerator;
+export interface OperationContext {
+  readonly createId?: IdGenerator;
+}
+export interface NewElement {
+  readonly kind: ElementKind;
+  readonly x: number;
+  readonly y: number;
+  readonly id?: string;
+  /** Defaults to the kind's short name ("Goal"), like piStar. */
+  readonly name?: string;
+  /** Actor to place the element in. Required in practice for iStar nodes (see NodeKindInfo). */
+  readonly parent?: string;
+  readonly customProperties?: CustomProperties;
+  readonly display?: ElementDisplay;
+}
+export declare function addElement(model: IstarModel, input: NewElement, ctx?: OperationContext): {
+  model: IstarModel;
+  element: IstarElement;
+};
+export interface ElementPatch {
+  readonly name?: string;
+  /** Replaces the whole map. Use `null` to remove it. */
+  readonly customProperties?: CustomProperties | null;
+  /** Merged into the current display; a key set to `undefined` is removed. `null` clears it. */
+  readonly display?: {
+    readonly [key: string]: unknown;
+  } | null;
+}
+export declare function updateElement(model: IstarModel, id: string, patch: ElementPatch): IstarModel;
+/**
+ * Moves an element to an absolute position. Moving an actor shifts its inner elements by the
+ * same offset.
+ */
+export declare function moveElement(model: IstarModel, id: string, x: number, y: number): IstarModel;
+/**
+ * Moves an inner element into another actor (or out of any actor with `null`). The element
+ * becomes the actor's last child. Links that become invalid are kept; `validateModel` reports
+ * them.
+ */
+export declare function nestElement(model: IstarModel, id: string, parent: string | null): IstarModel;
+/**
+ * Removes elements and everything that depends on them: inner elements of removed actors,
+ * links touching removed elements, and the rest of any dependency that loses a part.
+ */
+export declare function removeElements(model: IstarModel, ids: Iterable<string>): IstarModel;
+export declare function removeElement(model: IstarModel, id: string): IstarModel;
+export interface NewLink {
+  readonly kind: Exclude<LinkKind, "istar.DependencyLink">;
+  readonly source: string;
+  readonly target: string;
+  readonly id?: string;
+  /** Contribution value: make, help, hurt or break. */
+  readonly label?: string;
+  readonly name?: string;
+  readonly customProperties?: CustomProperties;
+}
+export interface ConnectOptions extends OperationContext {
+  /** Skip constraint checking (used when loading or scripting known-good data). */
+  readonly force?: boolean;
+  /**
+   * Retry with source and target swapped if the link is invalid as given. Defaults to the
+   * metamodel's `tryReversedWhenAdding` (Needed-By and Qualification), as in piStar.
+   */
+  readonly tryReversed?: boolean;
+}
+export type ConnectResult = {
+  ok: true;
+  model: IstarModel;
+  link: IstarLink;
+  reversed: boolean;
+} | Extract<LinkCheck, {
+  ok: false;
+}>;
+/** Adds a link between two elements if the iStar constraints allow it. */
+export declare function connect(model: IstarModel, input: NewLink, options?: ConnectOptions): ConnectResult;
+export interface NewDependency {
+  /** The depender: an actor or one of its inner elements. */
+  readonly depender: string;
+  /** The dependee: an actor or one of its inner elements. */
+  readonly dependee: string;
+  readonly dependum: {
+    readonly kind: NodeKind;
+    readonly name?: string;
+    readonly id?: string;
+    /** Defaults to the midpoint between depender and dependee, as in piStar. */
+    readonly x?: number;
+    readonly y?: number;
+    readonly customProperties?: CustomProperties;
+  };
+  readonly linkIds?: readonly [string, string];
+}
+export type AddDependencyResult = {
+  ok: true;
+  model: IstarModel;
+  dependum: IstarElement;
+  links: readonly [IstarLink, IstarLink];
+} | Extract<LinkCheck, {
+  ok: false;
+}>;
+/** Adds depender → dependum → dependee. */
+export declare function addDependency(model: IstarModel, input: NewDependency, options?: Omit<ConnectOptions, "tryReversed">): AddDependencyResult;
+/** Removes a link. Removing either half of a dependency removes the whole dependency. */
+export declare function disconnect(model: IstarModel, id: string): IstarModel;
+export interface LinkPatch {
+  /** `null` removes it. */
+  readonly label?: string | null;
+  readonly name?: string | null;
+  readonly customProperties?: CustomProperties | null;
+  readonly display?: {
+    readonly [key: string]: unknown;
+  } | null;
+}
+export declare function updateLink(model: IstarModel, id: string, patch: LinkPatch): IstarModel;
+export declare function updateDiagram(model: IstarModel, patch: Partial<Diagram>): IstarModel;
+/** Where dependency depender/dependee currently point (see `dependencyLinksOf`). */
+export declare function dependencyEnds(model: IstarModel, dependumId: string): {
+  depender?: string;
+  dependee?: string;
+};
+//#endregion
+//#region src/store.d.ts
+/** What happened, for listeners that want more than the new snapshot. */
+export type ModelChange = {
+  type: "addElement";
+  id: string;
+} | {
+  type: "updateElement";
+  id: string;
+  patch: ElementPatch;
+} | {
+  type: "moveElement";
+  id: string;
+  x: number;
+  y: number;
+} | {
+  type: "nestElement";
+  id: string;
+  parent: string | null;
+} | {
+  type: "removeElements";
+  ids: readonly string[];
+} | {
+  type: "connect";
+  id: string;
+} | {
+  type: "addDependency";
+  dependumId: string;
+  linkIds: readonly [string, string];
+} | {
+  type: "updateLink";
+  id: string;
+  patch: LinkPatch;
+} | {
+  type: "disconnect";
+  id: string;
+} | {
+  type: "updateDiagram";
+  patch: Partial<Diagram>;
+} | {
+  type: "replace";
+};
+export interface ModelChangeEvent {
+  readonly model: IstarModel;
+  readonly previous: IstarModel;
+  /** `undo`/`redo`/`load` carry no changes; a transaction carries all of its changes. */
+  readonly changes: readonly ModelChange[];
+  readonly source: "edit" | "undo" | "redo" | "load";
+}
+export type ModelListener = (event: ModelChangeEvent) => void;
+export interface ModelStoreOptions {
+  readonly createId?: IdGenerator;
+  /** Maximum number of undo steps kept. Default 100. */
+  readonly historyLimit?: number;
+}
+export interface ModelStore {
+  getModel(): IstarModel;
+  /** Returns an unsubscribe function. */
+  subscribe(listener: ModelListener): () => void;
+  canLink(source: string | IstarElement, target: string | IstarElement, kind: LinkKind): LinkCheck;
+  addElement(input: NewElement): IstarElement;
+  updateElement(id: string, patch: ElementPatch): void;
+  moveElement(id: string, x: number, y: number): void;
+  nestElement(id: string, parent: string | null): void;
+  removeElement(id: string): void;
+  removeElements(ids: Iterable<string>): void;
+  setCollapsed(actorId: string, collapsed: boolean): void;
+  connect(input: NewLink, options?: Omit<ConnectOptions, "createId">): ConnectResult;
+  addDependency(input: NewDependency, options?: Omit<ConnectOptions, "createId" | "tryReversed">): AddDependencyResult;
+  updateLink(id: string, patch: LinkPatch): void;
+  disconnect(id: string): void;
+  updateDiagram(patch: Partial<Diagram>): void;
+  /** Replaces the model as one undoable edit. */
+  replace(model: IstarModel): void;
+  /** Replaces the model and clears history (like opening a file in piStar). */
+  load(model: IstarModel): void;
+  /**
+   * Groups several edits into one undo step and one change event. Nested calls join the
+   * outermost transaction. If `fn` throws, the model is rolled back.
+   */
+  transaction<T>(fn: () => T): T;
+  undo(): boolean;
+  redo(): boolean;
+  canUndo(): boolean;
+  canRedo(): boolean;
+  clearHistory(): void;
+}
+export declare function createModelStore(initial?: IstarModel, options?: ModelStoreOptions): ModelStore;
+//#endregion
+//#region src/properties.d.ts
+export type PropertyResult<T> = {
+  ok: true;
+  value: T;
+} | {
+  ok: false;
+  error: string;
+};
+export interface PropertyOptions<T> {
+  default?: T;
+  optional?: boolean;
+  label?: string;
+  description?: string;
+}
+export interface PropertyType<T> {
+  readonly type: "string" | "number" | "boolean" | "enum";
+  readonly options: PropertyOptions<T>;
+  readonly values?: readonly string[];
+  readonly integer?: boolean;
+  readonly min?: number;
+  readonly max?: number;
+  parse(raw: string): PropertyResult<T>;
+  serialize(value: T): string;
+}
+export declare function string(options?: PropertyOptions<string>): PropertyType<string>;
+export declare function number(options?: PropertyOptions<number> & {
+  integer?: boolean;
+  min?: number;
+  max?: number;
+}): PropertyType<number>;
+export declare function boolean(options?: PropertyOptions<boolean>): PropertyType<boolean>;
+export declare function enumOf<const V extends readonly string[]>(values: V, options?: PropertyOptions<V[number]>): PropertyType<V[number]>;
+export declare const prop: {
+  string: typeof string;
+  number: typeof number;
+  boolean: typeof boolean;
+  enum: typeof enumOf;
+};
+export type PropertyShape = Record<string, PropertyType<unknown>>;
+export type InferProperties<S extends PropertyShape> = { [K in keyof S]: S[K] extends PropertyType<infer T> ? T : never; };
+export interface PropertyIssue {
+  key: string;
+  message: string;
+}
+export interface PropertySchema<S extends PropertyShape = PropertyShape> {
+  readonly kind: ElementKind | LinkKind;
+  readonly shape: S;
+  read(source: CustomProperties | undefined | PropertyOwner): {
+    values: Partial<InferProperties<S>>;
+    issues: PropertyIssue[];
+  };
+  validate(source: CustomProperties | undefined | PropertyOwner): PropertyIssue[];
+  write(current: CustomProperties | undefined, patch: { [K in keyof S]?: InferProperties<S>[K] | undefined; }): CustomProperties;
+  defaults(): CustomProperties;
+}
+/** An element or link, read through its `customProperties`. */
+export interface PropertyOwner {
+  readonly kind: string;
+  readonly customProperties?: CustomProperties;
+}
+export interface ModelPropertyIssue extends PropertyIssue {
+  id: string;
+}
+export declare function defineProperties<const S extends PropertyShape>(kind: ElementKind | LinkKind, shape: S, options?: {
+  validate?: (values: Partial<InferProperties<S>>) => PropertyIssue[];
+}): PropertySchema<S>;
+export declare function validateModelProperties(model: IstarModel, schemas: readonly PropertySchema[]): ModelPropertyIssue[];
+//#endregion
+//# sourceMappingURL=index.d.cts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@istar-ts/core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Framework-free iStar 2.0 goal-model core: metamodel, constraints, piStar-compatible serialization, undoable store.",
   "license": "MIT",
   "type": "module",
@@ -21,13 +21,20 @@
   "exports": {
     ".": {
       "@istar-ts/source": "./src/index.ts",
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     },
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.cts",
   "files": [
     "dist",
     "README.md",