Is it posible to remove a key validating the current iteration of a map function?

[miguelbogota]

So, I'm working as hobbyists to build a web component framework, the idea I want is that you create a type like this:

import { T, createComponent } from 'unnamed-framework';

type ElementAttributes = {
  firstName: T.Attribute<string>;
  lastName: T.Attribute<string>;
  displayName: T.Computed<string>;
};

const element = createElement({
  selector: 'app-element',
  attributes: {
    firstName: 'Joe',
    lastName: 'Doe',
    displayName: ({ firstName, lastName }) => `${firstName()} ${lastName()}`,
  },
  content: ({ displayName }) => {
    console.log(`This is the full name ${displayName}`);
  };
});

Now, all of this I manage to do it with the following type:

type _MapAttributes<Attrs extends ValidAttributes, PrimitiveMatcher, ComputedMatcher> =
  H.Pipe<
    Attrs,
    [
      H.Match<[
        // If no attributes returns never.
        H.Match.With<NoAttributes, never>,
        H.Match.With<
          Attributes,
          H.ComposeLeft<[
            // Maps all the attributes.
            H.Objects.MapValues<
              H.Match<[
                // If is a primitive attribute.
                H.Match.With<
                  BaseAttributeType<unknown, 'attribute'>,
                  PrimitiveMatcher
                >,
                // If is a computed attribute.
                H.Match.With<
                  BaseAttributeType<unknown, 'computed'>,
                  ComputedMatcher
                >,
              ]>
            >,
          ]>
        >,
      ]>,
    ]
  >;

Then have single type for each case, for example this is for the config in the function, you need to create the default values:

/** Utility type to get the value type passed by the end user. */
type _GetAttributeType<T extends BaseAttributeType<unknown, unknown>> = T['__value'];

/** Matcher type using HotScript to pass in the `ConfigAttributes` type. */
interface _ConfigMatcher<Attrs extends ValidAttributes = NoAttributes> extends H.Fn {
  return: Attrs extends NoAttributes
    // If no attributes it means is an primitive attribute.
    ? _GetAttributeType<this['arg0']>
    // If has attributes it means is a computed attribute.
    : (self: SelfAttributes<Attrs>) => _GetAttributeType<this['arg0']>;
}

interface _SignalMatcher<ReadOnly extends boolean> extends H.Fn {
  return: Signal<_GetAttributeType<this['arg0']>, ReadOnly>;
}

/**
 * Attributes for the fragment config.
 */
export type ConfigAttributes<Attrs extends ValidAttributes> = _MapAttributes<
  Attrs,
  _ConfigMatcher<NoAttributes>,
  _ConfigMatcher<Attrs>
>;

Then you have another one for the content parameter to pass the values in the content function:

/**
 * Attributes for the fragment content.
 */
export type ContentAttributes<Attrs extends ValidAttributes> = _MapAttributes<
    Attrs,
    _SignalMatcher<false>,
    _SignalMatcher<true>
  >;

And finally the one I'm having issues is the parameters for the computed attributes, the idea is to have all the other attributes available but itself, so this:

displayName: ({ firstName, lastName }) => `${firstName()} ${lastName()}`

Should not have displayName inside of the param object. I haven figured how to so far. I was able to achieve this with raw types like this:

/**
 * Maps a single field of a fragment attributes to its real value.
 */
export type ToRealValue<
  Attrs extends ValidAttributes,
  FieldName extends string,
  FieldValue,
  AsSignal extends boolean,
  ReadOnly extends boolean,
> =
  // FieldName has a reserved name.
  FieldName extends 'children' ? ReservedErrorMessage<'children'>
    : FieldName extends 'fallback' ? ReservedErrorMessage<'fallback'>
    : FieldName extends 'errorBoundary' ? ReservedErrorMessage<'errorBoundary'>
    // FieldValue is an attribute.
    : FieldValue extends AttributeType<infer RealValue>
      ? AsSignal extends true ? Signal<_BooleanInfer<RealValue>, ReadOnly>
      : _BooleanInfer<RealValue>
    // FieldValue is a computed attribute.
    : FieldValue extends ComputedType<infer RealValue>
      ? AsSignal extends true ? Signal<ComputedReturn<_BooleanInfer<RealValue>>, true>
      : ComputedAttribute<Attrs, FieldName, _BooleanInfer<RealValue>>
    // FieldValue is of a un-allowed type.
    : never;

/**
 * Maps the attributes of a fragment to their real value.
 */
export type AttributesForComputed<Attrs extends ValidAttributes> = Attrs extends NoAttributes
  ? never
  : {
    // Here it maps each value and you can get the Value and Name.
    [FieldName in Extract<keyof Attrs, string>]: ToRealValue<
      Attrs,
      FieldName,
      Attrs[FieldName],
      true,
      true
    >;
  };