* upgrade packages, setup lint-staged

* add tsc-files

* Update QuickFilterDrill tests

* Extend QuickFilterDrill tests

* Extract `reference` method from `Field`

* Extend Column type

* Add mock column factory

* Extend QuickFilterDrill unit tests

* Extract `getFKFilter` function

* Allow drills on fields without ID

* Simplify condition for filters lookup

* Handle aggregate and expression fields

* Fix filter drills UI

* Add tests for drill availability checks

* Simplify drill availability check

* Remove not used import

* Fix test

Don't parse MB_DB_CONNECTION_URI; use javax.sql.DataSource everywhere for app DB connection sources (#19970)

* Use javax.sql.DataSource everywhere for app DB connection sources

* Sort namespaces

* Un-remove Kondo warning

* Minor tweaks to support 'postgres:' ...

* Remove ConnectionDataSource

* Add warning about PG without sslmode back

* PR feedback

* Sort namespaces

* Remove top-level calls to trs (not allowed because app DB isn't initialized yet anyway)

* Test fix  (MySQL)

* MBQL :expressions should use strings for keys

* Make some more tests ^:parallel

* Update dox

* Test fix

* Sort namespaces

Still pursuant to #18676

1. Funnel was previously not doing lato font for the bold bit because visx's text doesn't take weights, it takes styles
2. Columns can be nontrivial with respect to funnels, which was an oversight
3. For some reason the first try for fixing 2 also impinged upon values being strings for funnels, which breaks things at SVG level
4. And let's just shove in a nit for the display of trends if the previous value and current value are the same

* Remove DataSelector info popovers

* Remove DimensionList info popover

* Remove expression editor suggestion list info popover

* Remove FieldPicker info popover

* Remove DimensionListItem info popover

* Remove info popover from data selector search results

* remove TableBrowser info popover

* Remove an e2e test

* convert null value to 0 for gauge viz

* set null segment range to 0

CI was broken inasmuch as it wasn't running, so master was broken without us knowing it. Thankfully, to the best of our knowledge, it was a couple of nits. Fixes master.

Co-authored-by: Aleksandr Lesnenko <alxnddr@gmail.com>

* onDrop unneeded

* basic impl of reordering pinned items

* split cards and dashboards again

* Improve pin drop target styling

* Fix card drop target weirdness

* brand-light border --> brand

* pull out separate styled drop target component

* replace style prop usage

* reduce the z-index

* Remove prop that triggers drill functionality

* Fix clobbering of pinned list on update

* Fix card queries on every rerender

* Add pin drop zone & split drop target components

* lint fix

* fix & add a few tests

* update pin drop zone styling to match sorting

Only attempt to read values that were actually set on the client side

Add test to confirm specific combination from reported issue works

https://github.com/actions/setup-node/blob/main/docs/advanced-usage.md#caching-packages-dependencies

* Improve lifecycle of metadata

Previously we have assumed that if valid metadata is passed into the
card create and udpate, that that is valid metadata for the query. There
are a few scenarios where this can fail, but they all boil down to
editing the query after running it. Examples:

- when creating a query, come up with a query, visualize, realize you
wanted to not select all columns, edit to not select those, possibly
select a few extra, and then save. The saved metadata might only have
the columns from when you ran the query and not after you saved it.
- edit an existing query and save without rerunning. Again, adding and
removing some columns.

How it affects:
- if you remove columns, the preserved metadata can cause us to attempt
to select columns that are no longer in that question, leading to errors
for nested queries
- if you add columns, the query builder won't show the new columns until
that information is populated in the metadata by running the query.

Lifecycle now:
- should be encapsulated in `api.card/result-metadata-async`. But we
only allow metadata to remain if is is valid metadata and the query has
not been edited. If the query has been edited (and new queries always
satisfy this since the previous query will be nil) we rerun the query to
get the metadata. No more drift. However, when dealing with datasets we
will attempt to blend the existing metadata into the newly computed
metadata so that metadata edits can persevere.

Other changes:

- removed an extra indirection in the card api that made it harder to
reason about when to recompute metadata
- moved the `combine-metadata` function into a util namespace and gave
some more generic parameter names
- deleted two tests that are no longer relevant after removing the
checksum on metadata. One had to do with how we hash floats vs ints
which is no longer relevant since we aren't hashing at all (RIP
checksum) and one checked that we accepted "valid" checksum-ed
metadata.
- new test that updating a card will update its metadata by rerunning
the query
- when validating the checksum, do not call s/validate since this WILL
THROW. Instead check `(nil? (s/check ...))`.

* Normalize query before comparing for changes

When comparing db vs api-sent query, need to normalize otherwise they
will always be different and our optimization will never kick in

* Fix ns

* Cleanup after ourselves

* Move `combine-metadata` util functions to a better namespace

* Allow for no query in api/card/:id patch

Cypress tests would do a

```javascript
  describe("simple mode", () => {
    beforeEach(() => {
      cy.request("PUT", "/api/card/1", {
        name: "Orders Model",
        dataset: true,
      });
    });
```

The metadata testing stuff would always use the query from the PUT to
check whether to dump or retain the metadata. In these instances, it
would dump the metadata and then i guess ask the qp for the metadata for
a nil query. Similar scenario if anyone uses the API to update
descriptions, etc.

The method is PUT not PATCH, but in the saving function we have

```clojure
(u/select-keys-when
 card-updates
 :present #{:collection_id :collection_position :description :cache_ttl :dataset}
 :non-nil #{:dataset_query :display :name :visualization_settings
            :archived :enable_embedding :embedding_params
            :result_metadata})
```

So we kinda have a PATCH anyways.

* Normalize metadata before blending

* Ensure api blends metadata correctly

When blending the metadata, need to update the field_ref to keyword the
original. Otherwise we are attempting to match up the field with ref
["field" "subtotal"] against [:field "subtotal"] and they don't match.

* Normalize metadata from api correctly

if you just call normalize/normalize it doesn't know not to change
`:field_ref` -> `:field-ref` so it gets out of whack. Need to pass it
the function appropriate for that level.

Also add a test that you can update _just_ the metadata. This actually
already worked for a subtle reason, and that is possibly buggy. The
reasoning is that the result_metadata is clobbered conditionally now
instead of unconditionally. If the async metadata stuff returns nil it
won't clobber and then whatever was sent over the wire goes in.

* Ensure previous metadata is there

When updating the query of a dataset, handle the case where just the
query is sent, and not the whole card. If the client didn't send the
previous metadata, we did not look it up in the database

* Card api always uses metadata from `result-metadata-async`

Originally this did

    (assoc card-data :result_metadata (a/<! result-metadata-chan))

But I changed that so it only optionally did so when that channel had
information. The problem with this is that if there was :result_metadata
on the original request but the channel returned nil for some reason,
whatever was in the request was going in the db. This includes invalid
metadata, non-json strings, what ever. Obviously bad.

But we need to handle PATCHs where clients don't send metadata or they
_ONLY_ send metadata and no query, etc. So this always uses the results
of `result-metadata-async` so it can go through that logic and we always
clobber.

And remember that if we only update the result_metadata when it is
non-nil (`update-card-async!`). The end result is that switching from a
PATCH model where you expect the full object to a PUT where things can
be optional has lots of footguns. Some examples:
- only updating the query
- updating the query along with edits to the metadata on a card (throw
the metadata away)
- updating the query along with edits on a dataset (save the metadata
but blend it into the fresh computation of the query's metadata)
- updating the query but not sending along the metadata. Need to grab
from the db and blend in.
- Sending invalid metadata, changing the description. We want to toss
away the metadata but save the description.

* support stacked area static viz series

* fix x-ticks overflow

* fix types

* add specs, fix area static charts

* run eslint on typescript files

* fix errors

* bump timeout

* change model icon from waffle to building block

* update models education illustration

* docs - running development branch instructions

* reorganized content into existing pages

* Jeff edits

Co-authored-by: Jeff Bruemmer <jeff@metabase.com>

* remove gh command, minor edits

* reorganizing step numbers

Co-authored-by: Jeff Bruemmer <jeff@metabase.com>

Thanks for the review/approvals.

Adds an endpoint to the cards which are basically materially like dashboard/:id/copy, only it's for card/:id/copy - POST to it, get a copy of that entity.

Move filters over into a separate bar below the header and move the filter button over to the right side of the header

* redo tweaks from 19853 that got clobbered in the rebase

* smaller text size for collections list items

* make unpinned items list more compact