lombok-typescript 0.3.0 → 0.5.0

package/dist/legacy/index.js

@@ -77,10 +77,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`,
@@ -88,8 +97,11 @@ var MetadataKeys = {
   WITH: `${PREFIX}with`,
   DELEGATE: `${PREFIX}delegate`,
   EQUALS_EXCLUDE: `${PREFIX}equals:exclude`,
+  ITERATE_OVER: `${PREFIX}iterateOver`,
   // Method-level
   MEMOIZE: `${PREFIX}memoize`,
+  HANDLER: `${PREFIX}handler`,
+  TRANSITION: `${PREFIX}transition`,
   // Parameter-level
   NON_NULL_PARAM: `${PREFIX}nonNull:param`};
 
@@ -357,6 +369,484 @@ function withFieldLegacy(backend, targetPrototype, propertyKey) {
   fieldMarkerLegacy(backend, targetPrototype, propertyKey, 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 strategyClassLegacy(backend, target, family, name) {
+  backend.metadata.set(MetadataKeys.STRATEGY, target, void 0, { family, name });
+  registerStrategy(family, name, target);
+}
+
+// src/decorators/shared/transition.ts
+function normalizeFromStates(from) {
+  return Array.isArray(from) ? from : [from];
+}
+function transitionMethodLegacy(backend, targetPrototype, propertyKey, descriptor, options) {
+  backend.metadata.set(MetadataKeys.TRANSITION, targetPrototype, propertyKey, options);
+  return descriptor;
+}
+
+// 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) ?? (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);
+  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 stateClassLegacy(backend, target, options) {
+  backend.metadata.set(MetadataKeys.STATE, target, void 0, options);
+  return applyStateWrapping(backend, target, options);
+}
+
+// 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 commandClassLegacy(backend, target) {
+  assertCommand(target);
+  backend.metadata.set(MetadataKeys.COMMAND, target, 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 legacyMementoExcluded = /* @__PURE__ */ new WeakMap();
+function registerLegacyMementoExclude(proto, field) {
+  const set = legacyMementoExcluded.get(proto) ?? /* @__PURE__ */ new Set();
+  set.add(field);
+  legacyMementoExcluded.set(proto, 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) {
+      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 mementoClassLegacy(backend, target) {
+  backend.metadata.set(MetadataKeys.MEMENTO, target, void 0, true);
+  return wrapMementoClass(backend, target);
+}
+function mementoExcludeFieldLegacy(backend, targetPrototype, propertyKey) {
+  backend.metadata.set(MetadataKeys.MEMENTO_EXCLUDE, targetPrototype, propertyKey, true);
+  registerLegacyMementoExclude(targetPrototype, String(propertyKey));
+}
+
+// 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 observableClassLegacy(backend, target) {
+  backend.metadata.set(MetadataKeys.OBSERVABLE, target, void 0, true);
+  return wrapObservableClass(target);
+}
+function observableDerivedLegacy(backend, targetPrototype, propertyKey, descriptor) {
+  backend.metadata.set(MetadataKeys.OBSERVABLE, targetPrototype, propertyKey, { derived: true });
+  const originalGet = descriptor.get;
+  if (!originalGet) return;
+  const key = propertyKey;
+  return {
+    ...descriptor,
+    get() {
+      const internals = getInternals(this);
+      internals[INSTANCE] = this;
+      internals.derivedKeys.add(key);
+      if (internals.derivedCache.has(key)) {
+        return internals.derivedCache.get(key);
+      }
+      const value = originalGet.call(this);
+      internals.derivedCache.set(key, value);
+      return value;
+    }
+  };
+}
+function observerClassLegacy(backend, target) {
+  return observableClassLegacy(backend, target);
+}
+
+// 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) ?? (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);
+  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 chainOfResponsibilityClassLegacy(backend, target) {
+  backend.metadata.set(MetadataKeys.CHAIN_OF_RESPONSIBILITY, target, void 0, true);
+  return wrapChainClass(backend, target);
+}
+function handlerMethodLegacy(backend, targetPrototype, propertyKey, descriptor, options) {
+  backend.metadata.set(MetadataKeys.HANDLER, targetPrototype, propertyKey, options);
+  return descriptor;
+}
+
+// src/decorators/shared/iterable.ts
+var ITERATE_FIELD = /* @__PURE__ */ Symbol("lombok-ts:iterate-over-field");
+var legacyIterateFields = /* @__PURE__ */ new WeakMap();
+function registerLegacyIterateField(proto, field) {
+  const existing = legacyIterateFields.get(proto) ?? [];
+  existing.push(field);
+  legacyIterateFields.set(proto, 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) {
+      fields.push(key);
+    }
+  }
+  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 iterableClassLegacy(backend, target) {
+  backend.metadata.set(MetadataKeys.ITERABLE, target, void 0, true);
+  const fieldKey = resolveIterateField(backend, target.prototype);
+  target[ITERATE_FIELD] = fieldKey;
+  installIterator(target, fieldKey);
+}
+function iterateOverFieldLegacy(backend, targetPrototype, propertyKey) {
+  backend.metadata.set(MetadataKeys.ITERATE_OVER, targetPrototype, propertyKey, true);
+  registerLegacyIterateField(targetPrototype, propertyKey);
+}
+
 // src/decorators/legacy/index.ts
 var NonNull = defineFieldDecorator(nonNullFieldLegacy);
 function NonNullParam() {
@@ -430,7 +920,39 @@ function Delegate(...methods) {
   );
 }
 var EqualsExclude = defineFieldDecorator(equalsExcludeFieldLegacy);
+function Strategy(family, name) {
+  return defineClassDecorator((backend, target) => {
+    strategyClassLegacy(backend, target, family, name);
+  });
+}
+function State(options) {
+  return defineClassDecorator((backend, target) => stateClassLegacy(backend, target, options));
+}
+function Transition(options) {
+  return defineMethodDecorator(
+    (backend, target, key, descriptor) => transitionMethodLegacy(backend, target, key, descriptor, options)
+  );
+}
+var Command = defineClassDecorator(commandClassLegacy);
+var Observable = defineClassDecorator(observableClassLegacy);
+Observable.Derived = ((target, propertyKey, descriptor) => {
+  if (descriptor === void 0 || typeof descriptor.get !== "function") {
+    throw new TypeError("@Observable.Derived requires a getter");
+  }
+  observableDerivedLegacy(legacyBackend, target, propertyKey, descriptor);
+});
+var Observer = defineClassDecorator(observerClassLegacy);
+var Memento = defineClassDecorator(mementoClassLegacy);
+Memento.Exclude = defineFieldDecorator(mementoExcludeFieldLegacy);
+var ChainOfResponsibility = defineClassDecorator(chainOfResponsibilityClassLegacy);
+function Handler(options) {
+  return defineMethodDecorator(
+    (backend, target, key, descriptor) => handlerMethodLegacy(backend, target, key, descriptor, options)
+  );
+}
+var Iterable = defineClassDecorator(iterableClassLegacy);
+var IterateOver = defineFieldDecorator(iterateOverFieldLegacy);
 
-export { Accessors, Builder, Data, Delegate, Equals, EqualsExclude, Factory, FieldDefaults, Getter, LegacyBackend, Log, Memoize, NonNull, NonNullParam, Prototype, Setter, Singleton, ToString, UtilityClass, Value, With, createFromFactory, defineClassDecorator, defineFieldDecorator, defineMethodDecorator, defineParameterDecorator, getFactoryRegistry, legacyBackend, registerFactory };
+export { Accessors, Builder, ChainOfResponsibility, Command, CommandHistory, Data, Delegate, Equals, EqualsExclude, Factory, FieldDefaults, Getter, Handler, Iterable, IterateOver, LegacyBackend, Log, Memento, Memoize, NonNull, NonNullParam, Observable, Observer, Prototype, Setter, Singleton, State, Strategy, StrategyRegistry, ToString, Transition, UtilityClass, Value, With, createFromFactory, defineClassDecorator, defineFieldDecorator, defineMethodDecorator, defineParameterDecorator, getFactoryRegistry, getStrategyFromRegistry, getStrategyRegistry, legacyBackend, listStrategies, registerFactory, registerStrategy };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map