Let's review the requirements and outline a plan for implementing them.

1. Create a static .defaults() method to set defaults

   The approach here would involve constructing a structure "above" the original constructor, essentially a child constructor. This structure would take default values along with the remaining values, merge them into a single object, and provide it to the original constructor. You were quite close to this concept. The implementation of this setup will undoubtedly include generics, but if you are familiar with generics, tackling this should not pose a challenge.

2. Optionalize the constructor options argument when none of the keys are mandatory

   This aspect of the requirement is more intricate than it appears at first glance. To address this, we'll need to leverage:

   • the behavior of the keyof operator, which yields never when applied to an object without properties ({}) ("empty objects do not possess properties or keys");
   • TypeScript's capability to rearrange function parameter lists in tuple form, enabling us to assign different parameters to the constructor based on a specific condition (in our case, when the object is empty);

3. Implement cascading defaults:

   Base.defaults({ one: "" }).defaults({ two: "" })

   Since the output of .defaults() is a child class (refer back to the above discussion), it must inherit all static members from its parent class—this includes .defaults() itself. Therefore, from a pure JavaScript standpoint, there shouldn't be any new implementations required; it should already work as expected.

   In TypeScript, however, we encounter a significant obstacle. The .defaults() method requires access to the existing class's defaults to determine types for the combined new defaults derived from both old and new objects. For instance, in the scenario mentioned, to derive

   { one: string } & { two: string }

   , we deduce { two: string } (new defaults) directly from the given argument, while obtaining { one: string } (old defaults) from elsewhere. The most suitable location would be the class's type arguments (e.g.,

   class Base<Defaults extends Options>

   ). However, the issue arises because static members cannot reference class type parameters.

   A workaround exists, albeit requiring certain reasonable assumptions and some compromise on DRY principles. Most notably, declaring the class imperatively instead of declaratively becomes necessary, forcing you to dynamically create the initial, top-level member of the inheritance chain (such as const Class = createClass();), which may seem rather unfortunate despite being functional.

Considering all this, here is the resulting solution (along with a playground; feel free to collapse/remove the <TRIAGE> section):

(code snippet provided)

Breakdown:

• createClass() should only be invoked explicitly to create the initial class in the inheritance chain (subsequent child classes are generated through .defaults() calls).

• createClass() accepts (all optionally):

  • a type definition for the options property;
  • a portion of options for pre-population (the defaults object, the initial value argument of the function);
  • a reference to the parent class (the second value argument), defaulted to Object (a common parent class for all objects).

• The Options type argument in createClass() needs to be explicitly provided.

• The OptionalKey type argument in createClass() is inferred automatically from the type of the supplied defaults object.

• createClass() returns a class featuring updated typings for constructor(), wherein properties already present in defaults are no longer obligatory in explicit.

• If all properties of options are optional, the explicit argument itself becomes discretionary.

• Since the entire class definition is enclosed within a function, the .defaults() method can access the aforementioned defaults object via closure. This allows the method to solely necessitate additional defaults; these two sets of defaults are then merged into a single object and, together with the current class definition, passed to createClass(defaults, Parent) to create a new child class replete with pre-filled defaults.

• To maintain consistency, the returned class must invoke super() somewhere in the constructor, warranting the parent class's constructor to accept options: Options as its primary argument. Nonetheless, a constructor has the ability to disregard this argument; thus, post super() invocation, the options property value is manually established regardless.

interface Options {
  version: string;
  [key: string]: unknown;
}

type CalssType = abstract new (...args: any) => any;

// retrieve parameters of constructor
type Params = ConstructorParameters<typeof Base>

// retrieve instance type
type Instance = InstanceType<typeof Base>

// transform first element of tuple to Partial
type FstPartial<Tuple extends any[]> = Tuple extends [infer Fst, ...infer Tail] ? [Partial<Fst>, ...Tail] : never

// duplicate constructor type and replace first argument in rest parameters with partial
type GetConstructor<T extends CalssType> = new (...args: FstPartial<ConstructorParameters<T>>) => InstanceType<T>

type Constructor<T> = new (...args: any[]) => T;

class Base<TOptions extends Options = Options> {
  static defaults<
    TDefaults extends Options,
    S extends Constructor<Base<TDefaults>>
  >(
    this: S,
    defaults: Partial<TDefaults>
  ): {
    new(...args: any[]): {
      options: TDefaults;
    };
  } & GetConstructor<typeof Base> { // <--- change is here
    return class extends this {
      constructor(...args: any[]) {
        super(Object.assign({}, defaults, args[0] || {}));
      }
    };
  }

  constructor(options: TOptions) {
    this.options = options;
  };

  options: TOptions;
}

const test = new Base({
  // `version` should be typed as required for the `Base` constructor
  version: "1.2.3"
})
const MyBaseWithDefaults = Base.defaults({
  // `version` should be typed as optional for `.defaults()`
  foo: "bar"
})
const MyBaseWithVersion = Base.defaults({
  version: "1.2.3",
  foo: "bar"
})
const testWithDefaults = new MyBaseWithVersion({}) // ok

// both properties should be typed as string
testWithDefaults.options.version
testWithDefaults.options.foo

Playground