Function to check if property exists in variable ruleset (lookup values)

[krsdcbl]

Underlying issue

I've come to love the property/variable accessors for writing & passing around configs, as it makes everything much more readable and finally does away with manually namespacing variables when managing a large central config.

Yet using it to pass variables to a mixin has a limitation: Mixins can't lookup up "default values" from within detached variable rulesets, as the detached ruleset as a whole is the fallback value for the mixin parameter, and calling it with only a partially filled out ruleset as parameter won't merge this ruleset with the fallback default.

This hasn't ever been an issue before property/variable accessors, as mixins could always define default values for parameters, and you could just use a guard and define a dummy @optional = false; for anything else.

Example

Suppose we'd be using lookup values in a mixin like this:

.mixin( @config: {
	value-01: default;
	value-02: default;
}){
	.result {
		property-01: @config[value-01];
		property-02: @config[value-02];
	}
}

Calling the mixin without passing parameters works as intended, as it has a default value:

.mixin(); /* works, runs with default values of @config */

But there seems to be currently no way of treating the contents of a detached ruleset as defaults. Using it like this will fail as expected, as there is no [value-01] to be accessed in this context:

.mixin({ value-02: optional }); /* property "value-01" not found */

Proposed Solution

A nice solution would be to introduce some way of checking if a variable or detached property exists before trying to access/use it (if it is possible at all to implement a checking function like this with the way LESS parses & processes variables and mixins).

This could ideally be implemented similarly to type-checking functions, and used in conjunction with guards:

& when (exists(@detached[property])) {
	access: @detached[property];
}

Example Usecase

Finally, to explain why I was trying to use variable rulesets in this way, and would prefer to do so compared to other available methods that don't have this limitation:

In my projects I use mixins to facilitate the creation of repetitive styles that need to be available in an undefined amount of different variants, like button sizes & colors.

In this buton-color-variant scenario, it isn't ideal to use with just variables as parameters

• expressing the named parameters can get quite verbose when there are many options & also states to declare
• not naming the parameters gets intransparent really quickly, as those mixins have a good dozen or more partially optional params.

/* not ideal for large sets of properties with different states */
.button-variant(
	@color: red,
	@hover-color: blue,
	@hover-icon-color: blue,
	/* etc */
);

/* even worse */
.button-variant( red, skip, skip, blue, skip, blue, ... );

So I'd like to refactor those mixins to use a detached ruleset that allows nesting of these parameters, to have a nicer and more readable interface and be able to use it like this:

/* this would be much nicer ... */
.button-variant({
	color: red;
	@hover: {
		color: blue;
		icon: blue;
	}
});

/* ... and even better, allow to use it like this: */
.button-variant( @global-config[@buttons][@variant] );

but this currently requires all the properties to always being set in the variable ruleset, and as much as it is nicer to write and to read, making certain properties optional won't work without the ability to check for the existence of a variable to be looked up.

[cadomac]

Unless I'm mistaken, I think isdefined() performs the action you're describing. Sounds like you want to see if a variable definition exists, and isdefined() does just that.