lombok-typescript 0.3.0 → 0.6.0

package/dist/stage3/index.cjs

@@ -98,10 +98,19 @@ var MetadataKeys = {
   FIELD_DEFAULTS: `${PREFIX}fieldDefaults`,
   ACCESSORS: `${PREFIX}accessors`,
   LOG: `${PREFIX}log`,
+  // Class-level (TS-only)
+  OBSERVABLE: `${PREFIX}observable`,
   // Class-level (GoF)
   SINGLETON: `${PREFIX}singleton`,
   FACTORY: `${PREFIX}factory`,
   PROTOTYPE: `${PREFIX}prototype`,
+  CHAIN_OF_RESPONSIBILITY: `${PREFIX}chainOfResponsibility`,
+  COMMAND: `${PREFIX}command`,
+  ITERABLE: `${PREFIX}iterable`,
+  MEMENTO: `${PREFIX}memento`,
+  MEMENTO_EXCLUDE: `${PREFIX}memento:exclude`,
+  STATE: `${PREFIX}state`,
+  STRATEGY: `${PREFIX}strategy`,
   // Field-level
   GETTER: `${PREFIX}getter`,
   SETTER: `${PREFIX}setter`,
@@ -109,8 +118,11 @@ var MetadataKeys = {
   WITH: `${PREFIX}with`,
   DELEGATE: `${PREFIX}delegate`,
   EQUALS_EXCLUDE: `${PREFIX}equals:exclude`,
+  ITERATE_OVER: `${PREFIX}iterateOver`,
   // Method-level
-  MEMOIZE: `${PREFIX}memoize`};
+  MEMOIZE: `${PREFIX}memoize`,
+  HANDLER: `${PREFIX}handler`,
+  TRANSITION: `${PREFIX}transition`};
 
 // src/decorators/shared/factory.ts
 var factoryRegistry = /* @__PURE__ */ new Map();
@@ -360,6 +372,510 @@ function withFieldStage3(backend, context) {
   fieldMarkerStage3(backend, context, MetadataKeys.WITH);
 }
 
+// src/decorators/shared/strategy.ts
+var strategyRegistry = /* @__PURE__ */ new Map();
+function familyBucket(family, create = false) {
+  let bucket = strategyRegistry.get(family);
+  if (!bucket && create) {
+    bucket = /* @__PURE__ */ new Map();
+    strategyRegistry.set(family, bucket);
+  }
+  return bucket;
+}
+function registerStrategy(family, name, ctor) {
+  const bucket = familyBucket(family, true);
+  bucket.set(name, ctor);
+}
+function getStrategyFromRegistry(family, name) {
+  const ctor = familyBucket(family)?.get(name);
+  if (!ctor) {
+    throw new Error(`No strategy registered for family "${family}" and name "${name}"`);
+  }
+  return new ctor();
+}
+function listStrategies(family) {
+  const bucket = familyBucket(family);
+  return bucket ? Array.from(bucket.keys()) : [];
+}
+function getStrategyRegistry() {
+  return strategyRegistry;
+}
+var StrategyRegistry = {
+  get: getStrategyFromRegistry,
+  list: listStrategies
+};
+function strategyClassStage3(backend, value, context, family, name) {
+  backend.metadata.set(MetadataKeys.STRATEGY, context.metadata, void 0, {
+    family,
+    name
+  });
+  registerStrategy(family, name, value);
+}
+
+// src/decorators/shared/transition.ts
+function normalizeFromStates(from) {
+  return Array.isArray(from) ? from : [from];
+}
+function transitionMethodStage3(backend, value, context, options) {
+  backend.metadata.set(MetadataKeys.TRANSITION, context.metadata, context.name, options);
+  return value;
+}
+
+// src/decorators/shared/state.ts
+var STATE_SYMBOL = /* @__PURE__ */ Symbol("lombok-ts:state");
+function collectTransitionMethods(metadata, proto, classMetadata) {
+  const transitions = /* @__PURE__ */ new Map();
+  for (const key of Object.getOwnPropertyNames(proto)) {
+    if (key === "constructor") continue;
+    const options = metadata.get(MetadataKeys.TRANSITION, proto, key) ?? (classMetadata ? metadata.get(MetadataKeys.TRANSITION, classMetadata, key) : void 0);
+    if (!options) continue;
+    const desc = Object.getOwnPropertyDescriptor(proto, key);
+    if (!desc || typeof desc.value !== "function") continue;
+    transitions.set(key, { options, original: desc.value });
+  }
+  return transitions;
+}
+function applyStateWrapping(backend, target, options, classMetadata) {
+  const { states, initial, onEnter, onExit, onTransition } = options;
+  if (!states.includes(initial)) {
+    throw new Error(`@State initial state "${initial}" is not in states: [${states.join(", ")}]`);
+  }
+  const transitions = collectTransitionMethods(
+    backend.metadata,
+    target.prototype,
+    classMetadata
+  );
+  const StateClass = class extends target {
+    constructor(...args) {
+      super(...args);
+      Object.defineProperty(this, STATE_SYMBOL, {
+        value: initial,
+        writable: true,
+        enumerable: false,
+        configurable: false
+      });
+      onEnter?.(initial);
+    }
+    get state() {
+      return this[STATE_SYMBOL] ?? initial;
+    }
+  };
+  const stateProto = StateClass.prototype;
+  for (const [methodName, { options: transition, original }] of transitions) {
+    const fromStates = normalizeFromStates(transition.from);
+    const toState = transition.to;
+    if (!states.includes(toState)) {
+      throw new Error(`@Transition on "${methodName}" targets unknown state "${toState}"`);
+    }
+    for (const from of fromStates) {
+      if (!states.includes(from)) {
+        throw new Error(`@Transition on "${methodName}" references unknown state "${from}"`);
+      }
+    }
+    Object.defineProperty(stateProto, methodName, {
+      configurable: true,
+      enumerable: false,
+      writable: true,
+      value: function stateTransitionWrapper(...args) {
+        const self = this;
+        const current = self[STATE_SYMBOL] ?? "";
+        if (!fromStates.includes(current)) {
+          throw new Error(
+            `Cannot transition from "${current}" to "${toState}" via ${methodName}()`
+          );
+        }
+        onExit?.(current);
+        const result = original.apply(this, args);
+        self[STATE_SYMBOL] = toState;
+        onTransition?.(current, toState);
+        onEnter?.(toState);
+        return result;
+      }
+    });
+  }
+  return StateClass;
+}
+function stateClassStage3(backend, value, context, options) {
+  backend.metadata.set(MetadataKeys.STATE, context.metadata, void 0, options);
+  return applyStateWrapping(backend, value, options, context.metadata);
+}
+
+// src/decorators/shared/command.ts
+function assertCommand(target) {
+  const proto = target.prototype;
+  if (typeof proto.execute !== "function") {
+    throw new Error(`@Command class ${target.name} must define execute()`);
+  }
+}
+function commandClassStage3(backend, value, context) {
+  assertCommand(value);
+  backend.metadata.set(MetadataKeys.COMMAND, context.metadata, void 0, true);
+}
+
+// src/decorators/shared/command-history.ts
+var CommandHistory = class {
+  undoStack = [];
+  redoStack = [];
+  execute(cmd) {
+    const result = cmd.execute();
+    this.undoStack.push(cmd);
+    this.redoStack.length = 0;
+    return result;
+  }
+  undo() {
+    const cmd = this.undoStack.pop();
+    if (!cmd) {
+      throw new Error("Nothing to undo");
+    }
+    if (typeof cmd.undo !== "function") {
+      this.undoStack.push(cmd);
+      throw new Error("Command does not support undo()");
+    }
+    const result = cmd.undo();
+    this.redoStack.push(cmd);
+    return result;
+  }
+  redo() {
+    const cmd = this.redoStack.pop();
+    if (!cmd) {
+      throw new Error("Nothing to redo");
+    }
+    const result = cmd.execute();
+    this.undoStack.push(cmd);
+    return result;
+  }
+  get canUndo() {
+    return this.undoStack.length > 0;
+  }
+  get canRedo() {
+    return this.redoStack.length > 0;
+  }
+  clear() {
+    this.undoStack.length = 0;
+    this.redoStack.length = 0;
+  }
+};
+
+// src/decorators/shared/memento.ts
+var MEMENTO_SNAPSHOT = /* @__PURE__ */ Symbol("lombok-ts:memento-snapshot");
+var stage3MementoExcluded = /* @__PURE__ */ new WeakMap();
+var legacyMementoExcluded = /* @__PURE__ */ new WeakMap();
+function registerStage3MementoExclude(classMetadata, field) {
+  const set = stage3MementoExcluded.get(classMetadata) ?? /* @__PURE__ */ new Set();
+  set.add(field);
+  stage3MementoExcluded.set(classMetadata, set);
+}
+function isMementoSnapshot(value) {
+  return typeof value === "object" && value !== null && value[MEMENTO_SNAPSHOT] === true;
+}
+function collectExcludedFields(metadata, proto, classMetadata) {
+  const excluded = /* @__PURE__ */ new Set();
+  for (const key of Object.getOwnPropertyNames(proto)) {
+    if (key === "constructor") continue;
+    if (metadata.has(MetadataKeys.MEMENTO_EXCLUDE, proto, key) || classMetadata && metadata.has(MetadataKeys.MEMENTO_EXCLUDE, classMetadata, key)) {
+      excluded.add(key);
+    }
+  }
+  if (classMetadata) {
+    for (const key of stage3MementoExcluded.get(classMetadata) ?? []) {
+      excluded.add(key);
+    }
+  }
+  for (const key of legacyMementoExcluded.get(proto) ?? []) {
+    excluded.add(key);
+  }
+  return excluded;
+}
+function snapshotInstance(instance, excluded) {
+  const data = {};
+  for (const key of Object.keys(instance)) {
+    if (excluded.has(key)) continue;
+    if (key === "save" || key === "restore") continue;
+    data[key] = deepClone(instance[key]);
+  }
+  return { [MEMENTO_SNAPSHOT]: true, data };
+}
+function applySnapshot(instance, snapshot) {
+  for (const [key, value] of Object.entries(snapshot.data)) {
+    instance[key] = deepClone(value);
+  }
+}
+function wrapMementoClass(backend, target, classMetadata) {
+  const excluded = collectExcludedFields(
+    backend.metadata,
+    target.prototype,
+    classMetadata
+  );
+  const MementoClass = class extends target {
+    save() {
+      return snapshotInstance(this, excluded);
+    }
+    restore(snapshot) {
+      if (!isMementoSnapshot(snapshot)) {
+        throw new TypeError("restore() expects a snapshot returned from save()");
+      }
+      applySnapshot(this, snapshot);
+    }
+  };
+  return MementoClass;
+}
+function mementoClassStage3(backend, value, context) {
+  backend.metadata.set(MetadataKeys.MEMENTO, context.metadata, void 0, true);
+  return wrapMementoClass(backend, value, context.metadata);
+}
+function mementoExcludeFieldStage3(backend, context) {
+  backend.metadata.set(
+    MetadataKeys.MEMENTO_EXCLUDE,
+    context.metadata,
+    context.name,
+    true
+  );
+  registerStage3MementoExclude(context.metadata, String(context.name));
+}
+
+// src/decorators/shared/observable.ts
+var LISTENERS = /* @__PURE__ */ Symbol("lombok-ts:observable-listeners");
+function findGetter(proto, key) {
+  let current = proto;
+  while (current) {
+    const desc = Object.getOwnPropertyDescriptor(current, key);
+    if (desc?.get) return desc.get;
+    current = Object.getPrototypeOf(current);
+  }
+  return void 0;
+}
+function getInternals(target) {
+  const bag = target;
+  if (!bag[LISTENERS]) {
+    bag[LISTENERS] = {
+      listeners: /* @__PURE__ */ new Map(),
+      wildcards: /* @__PURE__ */ new Set(),
+      derivedKeys: /* @__PURE__ */ new Set(),
+      derivedCache: /* @__PURE__ */ new Map()
+    };
+  }
+  return bag[LISTENERS];
+}
+function notify(internals, key, next, prev) {
+  const keyListeners = internals.listeners.get(key);
+  if (keyListeners) {
+    for (const listener of keyListeners) {
+      listener(next, prev);
+    }
+  }
+  for (const listener of internals.wildcards) {
+    listener(key, next, prev);
+  }
+  if (internals.derivedKeys.size > 0) {
+    const instance = targetWithInternals(internals);
+    for (const derivedKey of internals.derivedKeys) {
+      const prevDerived = internals.derivedCache.get(derivedKey);
+      internals.derivedCache.delete(derivedKey);
+      const getter = findGetter(Object.getPrototypeOf(instance), derivedKey);
+      if (!getter) continue;
+      const newDerived = getter.call(instance);
+      internals.derivedCache.set(derivedKey, newDerived);
+      if (prevDerived !== newDerived) {
+        const derivedListeners = internals.listeners.get(derivedKey);
+        if (derivedListeners) {
+          for (const listener of derivedListeners) {
+            listener(newDerived, prevDerived);
+          }
+        }
+      }
+    }
+  }
+}
+var INSTANCE = /* @__PURE__ */ Symbol("lombok-ts:observable-instance");
+function targetWithInternals(internals) {
+  return internals[INSTANCE] ?? {};
+}
+function installSubscribe(proto) {
+  Object.defineProperty(proto, "subscribe", {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: function subscribe(key, listener) {
+      const internals = getInternals(this);
+      internals[INSTANCE] = this;
+      if (key === "*") {
+        const wildcardListener = listener;
+        internals.wildcards.add(wildcardListener);
+        return () => internals.wildcards.delete(wildcardListener);
+      }
+      const keyListener = listener;
+      let set = internals.listeners.get(key);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        internals.listeners.set(key, set);
+      }
+      set.add(keyListener);
+      const proto2 = Object.getPrototypeOf(this);
+      if (findGetter(proto2, key)) {
+        internals.derivedKeys.add(key);
+      }
+      return () => set.delete(keyListener);
+    }
+  });
+}
+function wrapObservableInstance(instance) {
+  const internals = getInternals(instance);
+  internals[INSTANCE] = instance;
+  return new Proxy(instance, {
+    set(target, prop, value, receiver) {
+      if (typeof prop === "symbol") {
+        return Reflect.set(target, prop, value, receiver);
+      }
+      const prev = Reflect.get(target, prop, receiver);
+      const result = Reflect.set(target, prop, value, receiver);
+      if (prev !== value) {
+        notify(internals, prop, value, prev);
+      }
+      return result;
+    }
+  });
+}
+function wrapObservableClass(target) {
+  installSubscribe(target.prototype);
+  const ObservableClass = class extends target {
+    constructor(...args) {
+      super(...args);
+      return wrapObservableInstance(this);
+    }
+  };
+  return ObservableClass;
+}
+function observableClassStage3(backend, value, context) {
+  backend.metadata.set(MetadataKeys.OBSERVABLE, context.metadata, void 0, true);
+  return wrapObservableClass(value);
+}
+function observableDerivedStage3(backend, value, context) {
+  backend.metadata.set(MetadataKeys.OBSERVABLE, context.metadata, context.name, {
+    derived: true
+  });
+  const key = context.name;
+  return function derivedGetter() {
+    const internals = getInternals(this);
+    internals[INSTANCE] = this;
+    internals.derivedKeys.add(key);
+    if (internals.derivedCache.has(key)) {
+      return internals.derivedCache.get(key);
+    }
+    const result = value.call(this);
+    internals.derivedCache.set(key, result);
+    return result;
+  };
+}
+function observerClassStage3(backend, value, context) {
+  return observableClassStage3(backend, value, context);
+}
+
+// src/decorators/shared/chain-of-responsibility.ts
+function collectHandlers(backend, proto, classMetadata) {
+  const handlers = [];
+  for (const key of Object.getOwnPropertyNames(proto)) {
+    if (key === "constructor") continue;
+    const options = backend.metadata.get(MetadataKeys.HANDLER, proto, key) ?? (classMetadata ? backend.metadata.get(MetadataKeys.HANDLER, classMetadata, key) : void 0);
+    if (!options) continue;
+    const desc = Object.getOwnPropertyDescriptor(proto, key);
+    if (!desc || typeof desc.value !== "function") continue;
+    handlers.push({
+      order: options.order,
+      method: key,
+      fn: desc.value
+    });
+  }
+  handlers.sort((a, b) => a.order - b.order);
+  return handlers;
+}
+function wrapChainClass(backend, target, classMetadata) {
+  const handlers = collectHandlers(backend, target.prototype, classMetadata);
+  const ChainClass = class extends target {
+    handle(context) {
+      for (const handler of handlers) {
+        const result = handler.fn.call(this, context);
+        if (result === true || result !== void 0 && result !== false) {
+          return true;
+        }
+      }
+      return false;
+    }
+  };
+  return ChainClass;
+}
+function chainOfResponsibilityClassStage3(backend, value, context) {
+  backend.metadata.set(
+    MetadataKeys.CHAIN_OF_RESPONSIBILITY,
+    context.metadata,
+    void 0,
+    true
+  );
+  return wrapChainClass(backend, value, context.metadata);
+}
+function handlerMethodStage3(backend, value, context, options) {
+  backend.metadata.set(MetadataKeys.HANDLER, context.metadata, context.name, options);
+  return value;
+}
+
+// src/decorators/shared/iterable.ts
+var ITERATE_FIELD = /* @__PURE__ */ Symbol("lombok-ts:iterate-over-field");
+var legacyIterateFields = /* @__PURE__ */ new WeakMap();
+var stage3IterateFields = /* @__PURE__ */ new WeakMap();
+function registerStage3IterateField(classMetadata, field) {
+  const existing = stage3IterateFields.get(classMetadata) ?? [];
+  existing.push(field);
+  stage3IterateFields.set(classMetadata, existing);
+}
+function resolveIterateField(backend, proto, classMetadata) {
+  const fields = [];
+  for (const key of [
+    ...Object.getOwnPropertyNames(proto),
+    ...Object.getOwnPropertySymbols(proto)
+  ]) {
+    if (key === "constructor") continue;
+    if (backend.metadata.has(MetadataKeys.ITERATE_OVER, proto, key) || classMetadata && backend.metadata.has(MetadataKeys.ITERATE_OVER, classMetadata, key)) {
+      fields.push(key);
+    }
+  }
+  if (classMetadata) {
+    fields.push(...stage3IterateFields.get(classMetadata) ?? []);
+  }
+  fields.push(...legacyIterateFields.get(proto) ?? []);
+  if (fields.length === 0) {
+    throw new Error("@Iterable requires exactly one @IterateOver field");
+  }
+  if (fields.length > 1) {
+    throw new Error("@Iterable allows only one @IterateOver field");
+  }
+  return fields[0];
+}
+function installIterator(target, fieldKey) {
+  Object.defineProperty(target.prototype, Symbol.iterator, {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: function* iterateOver() {
+      const collection = this[fieldKey];
+      if (collection == null) return;
+      yield* collection;
+    }
+  });
+}
+function iterableClassStage3(backend, value, context) {
+  backend.metadata.set(MetadataKeys.ITERABLE, context.metadata, void 0, true);
+  const fieldKey = resolveIterateField(
+    backend,
+    value.prototype,
+    context.metadata
+  );
+  value[ITERATE_FIELD] = fieldKey;
+  installIterator(value, fieldKey);
+}
+function iterateOverFieldStage3(backend, context) {
+  backend.metadata.set(MetadataKeys.ITERATE_OVER, context.metadata, context.name, true);
+  registerStage3IterateField(context.metadata, context.name);
+}
+
 // src/decorators/stage3/index.ts
 var NonNull = defineFieldDecorator(nonNullFieldStage3);
 var Singleton = defineClassDecorator(singletonClassStage3);
@@ -435,6 +951,42 @@ function Delegate(...methods) {
   );
 }
 var EqualsExclude = defineFieldDecorator(equalsExcludeFieldStage3);
+function Strategy(family, name) {
+  return defineClassDecorator((backend, value, context) => {
+    strategyClassStage3(backend, value, context, family, name);
+  });
+}
+function State(options) {
+  return defineClassDecorator(
+    (backend, value, context) => stateClassStage3(backend, value, context, options)
+  );
+}
+function Transition(options) {
+  return defineMethodDecorator(
+    (backend, value, context) => transitionMethodStage3(backend, value, context, options)
+  );
+}
+var Command = defineClassDecorator(commandClassStage3);
+var observableClassDec = defineClassDecorator(observableClassStage3);
+var observableDerivedDec = defineGetterDecorator(observableDerivedStage3);
+function Observable() {
+  return observableClassDec;
+}
+Observable.Derived = observableDerivedDec;
+var Observer = defineClassDecorator(observerClassStage3);
+var mementoClassDec = defineClassDecorator(mementoClassStage3);
+function Memento() {
+  return mementoClassDec;
+}
+Memento.Exclude = defineFieldDecorator(mementoExcludeFieldStage3);
+var ChainOfResponsibility = defineClassDecorator(chainOfResponsibilityClassStage3);
+function Handler(options) {
+  return defineMethodDecorator(
+    (backend, value, context) => handlerMethodStage3(backend, value, context, options)
+  );
+}
+var Iterable = defineClassDecorator(iterableClassStage3);
+var IterateOver = defineFieldDecorator(iterateOverFieldStage3);
 
 // src/stage3/index.ts
 function getClassMetadata(cls) {
@@ -443,6 +995,9 @@ function getClassMetadata(cls) {
 
 exports.Accessors = Accessors;
 exports.Builder = Builder;
+exports.ChainOfResponsibility = ChainOfResponsibility;
+exports.Command = Command;
+exports.CommandHistory = CommandHistory;
 exports.Data = Data;
 exports.Delegate = Delegate;
 exports.Equals = Equals;
@@ -450,14 +1005,24 @@ exports.EqualsExclude = EqualsExclude;
 exports.Factory = Factory;
 exports.FieldDefaults = FieldDefaults;
 exports.Getter = Getter;
+exports.Handler = Handler;
+exports.Iterable = Iterable;
+exports.IterateOver = IterateOver;
 exports.Log = Log;
+exports.Memento = Memento;
 exports.Memoize = Memoize;
 exports.NonNull = NonNull;
+exports.Observable = Observable;
+exports.Observer = Observer;
 exports.Prototype = Prototype;
 exports.Setter = Setter;
 exports.Singleton = Singleton;
 exports.Stage3Backend = Stage3Backend;
+exports.State = State;
+exports.Strategy = Strategy;
+exports.StrategyRegistry = StrategyRegistry;
 exports.ToString = ToString;
+exports.Transition = Transition;
 exports.UtilityClass = UtilityClass;
 exports.Value = Value;
 exports.With = With;
@@ -469,7 +1034,11 @@ exports.defineMethodDecorator = defineMethodDecorator;
 exports.defineSetterDecorator = defineSetterDecorator;
 exports.getClassMetadata = getClassMetadata;
 exports.getFactoryRegistry = getFactoryRegistry;
+exports.getStrategyFromRegistry = getStrategyFromRegistry;
+exports.getStrategyRegistry = getStrategyRegistry;
+exports.listStrategies = listStrategies;
 exports.registerFactory = registerFactory;
+exports.registerStrategy = registerStrategy;
 exports.stage3Backend = stage3Backend;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map