pad_spa/node_modules/less/test/less-bom/mixins-guards-default-func.less


// basics:

guard-default-basic-1 {
    .m(1)                   {case:     1}
    .m(@x) when (default()) {default: @x}

    &-1 {.m(1)}
    &-2 {.m(2)}
}

guard-default-basic-2 {
    .m(1)                   {case:     1}
    .m(2)                   {case:     2}
    .m(3)                   {case:     3}
    .m(@x) when (default()) {default: @x}

    &-0 {.m(0)}
    &-2 {.m(2)}
}

guard-default-basic-3 {
    .m(@x) when (@x = 1)    {case:     1}
    .m(2)                   {case:     2}
    .m(@x) when (@x = 3)    {case:     3}
    .m(@x) when (default()) {default: @x}

    &-0 {.m(0)}
    &-2 {.m(2)}
    &-3 {.m(3)}
}

guard-default-definition-order {
    .m(@x) when (default()) {default: @x}
    .m(@x) when (@x = 1)    {case:     1}
    .m(2)                   {case:     2}
    .m(@x) when (@x = 3)    {case:     3}

    &-0 {.m(0)}
    &-2 {.m(2)}
    &-2 {.m(3)}
}

// out of guard:

guard-default-out-of-guard {
    .m(1)                              {case-1:   1}
    .m(@x: default()) when (default()) {default: @x}

    &-0 {
        case-0: default();
        .m(1);
        .m(2);
        case-2: default();
    }
    &-1 {.m(default())}
    &-2 {.m()}
}

// expressions:

guard-default-expr-not {
    .m(1)                      {case:     1}
    .m(@x) when not(default()) {default: @x}

    &-1 {.m(1)}
    &-2 {.m(2)}
}

guard-default-expr-eq {
    .m(@x) when (@x = true)      {case:    @x}
    .m(@x) when (@x = false)     {case:    @x}
    .m(@x) when (@x = default()) {default: @x}

    &-true  {.m(true)}
    &-false {.m(false)}
}

guard-default-expr-or {
    .m(1)                             {case:     1}
    .m(2)                             {case:     2}
    .m(@x) when (default()), (@x = 2) {default: @x}

    &-1 {.m(1)}
    &-2 {.m(2)}
    &-3 {.m(3)}
}

guard-default-expr-and {
    .m(1)                                {case:     1}
    .m(2)                                {case:     2}
    .m(@x) when (default()) and (@x = 3) {default: @x}

    &-1 {.m(1)}
    &-2 {.m(2)}
    &-3 {.m(3)}
    &-4 {.m(4)}
}

guard-default-expr-always {
    .m(1)                                   {case:     1}
    .m(@x) when (default()), not(default()) {default: @x} // always match

    &-1 {.m(1)}
    &-2 {.m(2)}
}

guard-default-expr-never {
    .m(1)                                      {case:     1}
    .m(@x) when (default()) and not(default()) {default: @x} // never match

    &-1 {.m(1)}
    &-2 {.m(2)}
}


// not conflicting multiple default() uses:

guard-default-multi-1 {
    .m(0)                   {case:       0}
    .m(@x) when (default()) {default-1: @x}
    .m(2)  when (default()) {default-2: @x}

    &-0 {.m(0)}
    &-1 {.m(1)}
}

guard-default-multi-2 {
    .m(1, @x)   when (default()) {default-1: @x}
    .m(2, @x)   when (default()) {default-2: @x}
    .m(@x, yes) when (default()) {default-3: @x}

    &-1 {.m(1, no)}
    &-2 {.m(2, no)}
    &-3 {.m(3, yes)}
}

guard-default-multi-3 {
    .m(red)                                    {case-1: darkred}
    .m(blue)                                   {case-2: darkblue}
    .m(@x) when (iscolor(@x)) and (default())  {default-color: @x}
    .m('foo')                                  {case-1: I am 'foo'}
    .m('bar')                                  {case-2: I am 'bar'}
    .m(@x) when (isstring(@x)) and (default()) {default-string: I am @x}

    &-blue  {.m(blue)}
    &-green {.m(green)}
    &-foo   {.m('foo')}
    &-baz   {.m('baz')}
}

guard-default-multi-4 {
    .m(@x) when (default()), not(default())    {always: @x}
    .m(@x) when (default()) and not(default()) {never:  @x}
    .m(2)                                      {case:    2}

    .m(1);
    .m(2);
}

guard-default-not-ambiguos-2 {
    .m(@x)                     {case:         1}
    .m(@x) when (default())    {default:     @x}
    .m(@x) when not(default()) {not-default: @x}

    .m(2);
}

guard-default-not-ambiguos-3 {
    .m(@x)                     {case:           1}
    .m(@x) when not(default()) {not-default-1: @x}
    .m(@x) when not(default()) {not-default-2: @x}

    .m(2);
}

// default & scope

guard-default-scopes {
    .s1() {.m(@v)                  {1: no condition}}
    .s2() {.m(@v) when (@v)        {2: when true}}
    .s3() {.m(@v) when (default()) {3: when default}}

    &-3 {
        .s2();
        .s3();
        .m(false);
    }

    &-1 {
        .s1();
        .s3();
        .m(false);
    }
}