* Add DimensionInfoPopover component

* convert DimensionInfoPopover into ts

* Refactor: move Card and Dashboard QP code into their own qp.* namespaces

* Disable extra validation for now so a million tests don't fail

* WIP

* Validate template tag :parameters in query in context of a Card

* Fixes

* Disable strict validation for now

* Test fixes [WIP]

* Make the parameter type schema a little more forgiving for now

* Tests & test fixes 

* More test fixes 

* 1. Need more tests
2. Need to actually validate stuff

* More test fixes. 

* Test fixes (again)

* Test fix 

* Some test fixes / PR feedback

* Disallow native queries with a tag widget-type of "none"

Template tags with a widget-type that is undefined, null, or "none" now
cause the query's isRunnable method to return false. Existing questions
that have this defect won't be runnable until they are resaved with a
set widget-type.

* Fix prettier error

* add snippet and card types to validation pass

* Make sure template tag map keys + `:names` agree + test fixes

* Have MBQL normalization reconcile template tags map key and :name

* Test fix 

* Fix tests for Cljs

* Fix Mongo tests.

* Allow passing :category parameters for :text/:number/:date for now.

* Dashboard subscriptions should use qp.dashboard code for executing

* Make sure Dashboard QP parameter resolution code merges in default values

* Add a test for sending a test Dashboard subscription with default params

* Prettier

* If both Dashboard and Card have default param value, prefer Card's default

* Test fix 

* More tests and more fixes 



Co-authored-by: Dalton Johnson <daltojohnso@users.noreply.github.com>

* Update 17490.cy.spec.js

Seems that we removed the finder

* Update 17490.cy.spec.js

skipping the test as it's no longer relevant

* first pass at adding parameters to gui qb

* handle refresh of qb when there are parameters

* second pass

* minor refactoring

* correctly map dashboard params to template tag params

* make click behavior question params work again

* lint fix

* run with dsahboard endpoint in query builder

* fix parameter click behavior

* fix title drill navigating to new question

* add some extra care when setting props on card

* refactor getUrlWithParameters & sprinkle comments

* fix and remove irrelevant unit tests in meta/Card

* fix metadata fetch race condition

* refactor logic

* fix click behavior

* rmv unit tests for function that no longer exists

* add Question unit tests

* add dashboardId to card serialization in qb

* add more title drill e2e tests

* rmv unneeded code in qb initialization

* fix click behavior query param problem

* add targets unit tests

* dashboards unit test + simplification of fn logic

* add cards unit test

* prevent passing of nil parameterValues to native qb

* support ts and tsx in parse-deps

* use strip flow types plugin

* remove strip flow types plugin

* Rewrite DashCardCardParameterMapper to use tippy + be functional

* add unauthed state

* make the mapper popover interactive

* make Popover and TippyPopover use same selector

* add targets unit tests

* add e2e test for this specific scenario

* kill tippyPopover util because selectors are now the same

* fix e2e tests that rely on anchor tag

* delete old component

* rmv console.log call

* select none keeps the first one selected

* make "None" and "All" lowercase

* fix select none when a query has joins

Co-authored-by: Maz Ameli <maz@metabase.com>

* Only select type information on type inference of coalesce

This previously just selected hte inferred information from the second
argument to the coalesce. For fields this would return the entire field
object which includes an id.

Later, in `source-metadata->fields` this assumes that since an id is
present, we should select `[:field id nil]`, but this confused that the
type of the coalesce column is the same as that field-id, not that we
want to select that field id.

```clojure
add-source-metadata=> (pprint
                        (mbql-source-query->metadata {:source-table 2
                                                      :joins [{:fields [[:field
                                                                         22
                                                                         {:join-alias "People - User"}]
                                                                        [:field
                                                                         15
                                                                         {:join-alias "People - User"}]]
                                                               :source-table 3
                                                               :condition [:=
                                                                           [:field 3 nil]
                                                                           [:field
                                                                            22
                                                                            {:join-alias "People - User"}]]
                                                               :alias "People - User"}]
                                                      :expressions {:coalesce [:coalesce
                                                                               [:field 3 nil]
                                                                               [:field
                                                                                22
                                                                                {:join-alias "People - User"}]]}
                                                      :aggregation [[:count]]
                                                      :breakout [[:expression "coalesce"]]}))
({:semantic_type :type/FK,
  :table_id 2,
  :coercion_strategy nil,
  :name "coalesce",                    ;; merging maintains the correct name
  :settings nil,
  :field_ref [:expression "coalesce"], ;; merging maintains the field ref
  :effective_type :type/Integer,
  :parent_id nil,
  :id 3,                               ;; the type inference selected
                                       ;; the entire field, including its id
  :display_name "coalesce",
  :fingerprint {:global {:distinct-count 929, :nil% 0.0}},
  :base_type :type/Integer}
 {:name "count",
  :display_name "Count",
  :base_type :type/BigInteger,
  :semantic_type :type/Quantity,
  :field_ref [:aggregation 0]})
nil
```

updating to only select the type information:

```clojure
add-source-metadata=> (pprint
                        (mbql-source-query->metadata {:source-table 2
                                                      :joins [{:fields [[:field
                                                                         22
                                                                         {:join-alias "People - User"}]
                                                                        [:field
                                                                         15
                                                                         {:join-alias "People - User"}]]
                                                               :source-table 3
                                                               :condition [:=
                                                                           [:field 3 nil]
                                                                           [:field
                                                                            22
                                                                            {:join-alias "People - User"}]]
                                                               :alias "People - User"}]
                                                      :expressions {:coalesce [:coalesce
                                                                               [:field 3 nil]
                                                                               [:field
                                                                                22
                                                                                {:join-alias "People - User"}]]}
                                                      :aggregation [[:count]]
                                                      :breakout [[:expression "coalesce"]]}))
({:name "coalesce",
  :display_name "coalesce",
  :base_type :type/Integer,
  :effective_type :type/Integer,  ;; no more field information beyond
                                  ;; the types
  :coercion_strategy nil,
  :semantic_type :type/FK,
  :field_ref [:expression "coalesce"]}
 {:name "count",
  :display_name "Count",
  :base_type :type/BigInteger,
  :semantic_type :type/Quantity,
  :field_ref [:aggregation 0]})
```

* Update question in repro now that it doesn't fail on the backend

previously this question would actually fail on the backend and
independently the frontend would go into a stack overflow killing the
page. Fixing the bug actually broke the test as it asserted that the
query would break and look for the error message. Now that the query
returns assert we can find the name of the question "test question"

* Correct same bug for case

When inferring type for a case, we were returning the type information
for the first field we could find in the case statement. And that
information included the field id. We always merge the current column's
name on top of that to remove the analyzed field's name and other
things, but the field-id would remain. `source-metadata->fields` in
add_implicit_clauses will add a field reference if it finds a field id.

Before, the following was returned

```clojure
({:description "The date and time an order was submitted."
  :semantic_type :type/CreationTimestamp
  :table_id 2
  :coercion_strategy nil
  :unit :month
  :name "CREATED_AT"
  :settings nil
  :source :breakout
  :field_ref [:field
              4
              {:temporal-unit :month}]
  :effective_type :type/DateTime
  :parent_id nil
  :id 4
  :visibility_type :normal
  :display_name "Created At"
  :fingerprint {:global {:distinct-count 9998
                         :nil% 0.0}
                :type {:type/DateTime {:earliest "2016-04-30T18:56:13.352Z"
                                       :latest "2020-04-19T14:07:15.657Z"}}}
  :base_type :type/DateTime}
 {:description "The raw, pre-tax cost of the order. Note that this might be different in the future from the product price due to promotions, credits, etc."
  :semantic_type :type/Quantity
  :table_id 2
  :coercion_strategy nil
  :name "distinct case"
  :settings nil
  :source :aggregation
  :field_ref [:aggregation 0]
  :effective_type :type/Float
  :parent_id nil
  :id 6
  :visibility_type :normal
  :display_name "distinct case"
  :fingerprint {:global {:distinct-count 340
                         :nil% 0.0}
                :type {:type/Number {:min 15.691943673970439
                                     :q1 49.74894519060184
                                     :q3 105.42965746993103
                                     :max 148.22900526552291
                                     :sd 32.53705013056317
                                     :avg 77.01295465356547}}}
  :base_type :type/BigInteger})
```

The important bit above is that the metadata for the "distinct case" has
the correct field_ref but also has a field id.

After, we now return the following metadata:
```clojure
({:description "The date and time an order was submitted."
  :semantic_type :type/CreationTimestamp
  :table_id 2
  :coercion_strategy nil
  :unit :month
  :name "CREATED_AT"
  :settings nil
  :source :fields
  :field_ref [:field
              4
              {:temporal-unit :default}]
  :effective_type :type/DateTime
  :parent_id nil
  :id 4
  :visibility_type :normal
  :display_name "Created At"
  :fingerprint {:global {:distinct-count 9998
                         :nil% 0.0}
                :type {:type/DateTime {:earliest "2016-04-30T18:56:13.352Z"
                                       :latest "2020-04-19T14:07:15.657Z"}}}
  :base_type :type/DateTime}
 {:base_type :type/BigInteger
  :effective_type :type/Float
  :coercion_strategy nil
  :semantic_type :type/Quantity
  :name "distinct case"
  :display_name "distinct case"
  :source :fields
  :field_ref [:field
              "distinct case"
              {:base-type :type/BigInteger}]}
 {:semantic_type :type/Quantity
  :coercion_strategy nil
  :name "cc"
  :expression_name "cc"
  :source :fields
  :field_ref [:expression "cc"]
  :effective_type :type/Float
  :display_name "cc"
  :base_type :type/Float})
```

* Add tests looking for full field analysis without id