diff --git a/src/lib/_imports/components/bootstrap.container.css b/src/lib/_imports/components/bootstrap.container.css index 97a3a3bcb..f32c8024d 100644 --- a/src/lib/_imports/components/bootstrap.container.css +++ b/src/lib/_imports/components/bootstrap.container.css @@ -7,7 +7,7 @@ Add to Bootstrap styles. See: Styleguide Components.Bootstrap.Grid */ -@import url("_imports/tools/media-queries.css"); +@import url("../tools/media-queries.css"); @media (--x-wide-and-above) { .container { max-width: var(--global-max-width--x-wide); } diff --git a/src/lib/_imports/components/bootstrap.form.css b/src/lib/_imports/components/bootstrap.form.css new file mode 100644 index 000000000..88516d77a --- /dev/null +++ b/src/lib/_imports/components/bootstrap.form.css @@ -0,0 +1,21 @@ +/* +Form (Bootstrap) +Override Bootstrap styles. See: +- [ReactStrap Forms](https://reactstrap.github.io/components/form/) +- [Bootstrap Forms](https://getbootstrap.com/docs/4.4/components/forms/) +Styleguide Components.Bootstrap.Form +*/ +@import url('../settings/border.css'); + +.form-control { + border: var(--global-border--normal); + border-radius: 0; +} +input.form-control, +textarea.form-control { + /* FAQ: Vertical padding reduced by 1px each to near input height of design * 1.2 */ + padding: 6px 12px; /* 6px 10px design * 1.2 design-to-app ratio */ +} +.input-group-prepend { + z-index: 1; /* so child button border is above sibling input border */ +} diff --git a/src/lib/_imports/components/bootstrap.modal.css b/src/lib/_imports/components/bootstrap.modal.css new file mode 100644 index 000000000..9633455cf --- /dev/null +++ b/src/lib/_imports/components/bootstrap.modal.css @@ -0,0 +1,74 @@ +/* TODO: Migrate any other should-be-global Portal modal styles to here */ +/* FP-344: Consider a Modal component and a CSS module */ +/* +Modal (Bootstrap) + +Override Bootstrap styles. See: + +- [ReactStrap Forms](https://reactstrap.github.io/components/modals/) +- [Bootstrap Forms](https://getbootstrap.com/docs/4.4/components/modal/) + +Styleguide Components.Bootstrap.Modal +*/ +@import url('../tools/x-truncate.css'); + +.modal-content, +.modal-header, +.modal-body, +.modal-footer { + border-radius: 0; +} +.modal-content, +.modal-header, +.modal-body { + border: none; +} +.modal-footer { + border-left: none; + border-right: none; + border-bottom: none; +} + +.modal-header { + background-color: var(--global-color-primary--x-light); + padding: 1.35rem 1.75rem; /* (18px 23.5px design * 1.2 design-to-app ratio) */ +} +.modal-title { + color: var(--global-color-primary--xx-dark); + font-weight: normal; + font-size: 1.2rem; /* 16px design * 1.2 design-to-app ratio */ + + @extend .x-truncate--one-line; +} + +/* To darken close button */ +.modal-header .close { + color: var(--global-color-primary--x-dark); + opacity: 1; +} +/* FAQ: The specificity matches Bootstrap */ +.modal-header .close:not(:disabled):not(.disabled):focus, +.modal-header .close:not(:disabled):not(.disabled):hover { + color: var(--global-color-primary--xx-dark); + opacity: 1; +} + +/* To render modal close button icon as a Cortal icon */ +/* CAVEAT: Pass `charCode=""` to `` */ +.modal-header .close span { + /* To mimic `.icon` styles without `@extend` or `composes` (unavailable) */ + /* HACK: Copied (and reduced and edited) from `src/styles/trumps/icon...` */ + font-size: 1.5rem; /* bigger to match header text font height (like design) */ + font-family: Cortal-Icons !important; +} + +.modal-header.has-MuiTabs { + flex-direction: row; + position: relative; + height: 63.5px; + border-bottom: 1px solid #afafaf; + padding: 5px; +} +.modal-header.has-MuiTabs .close { + transform: translate(-25%, 25%); +} diff --git a/src/lib/_imports/components/bootstrap.pagination.css b/src/lib/_imports/components/bootstrap.pagination.css index 788cbb635..235d5955c 100644 --- a/src/lib/_imports/components/bootstrap.pagination.css +++ b/src/lib/_imports/components/bootstrap.pagination.css @@ -7,7 +7,7 @@ Style Bootstrap pagination. See: Styleguide Components.Bootstrap.Pagination */ -@import url("_imports/components/c-page.css"); +@import url("../components/c-page.css"); diff --git a/src/lib/_imports/components/c-button.css b/src/lib/_imports/components/c-button.css index 15599750f..f0bbb5f98 100644 --- a/src/lib/_imports/components/c-button.css +++ b/src/lib/_imports/components/c-button.css @@ -1,4 +1,4 @@ -@import url("_imports/tools/x-truncate.css"); +@import url("../tools/x-truncate.css"); @@ -235,6 +235,13 @@ /* Modifiers: Sizes */ +.c-button:not( + .c-button--width-short, + .c-button--width-medium, + .c-button--width-long, + .c-button--size-small, + .c-button--as-link +), .c-button--width-short { width: var(--min-width); } @@ -256,6 +263,10 @@ /* Elements */ +.c-button > * { + vertical-align: middle; +} + .c-button__icon--before { margin-right: 0.5em; } diff --git a/src/lib/_imports/components/c-button/c-button.hbs b/src/lib/_imports/components/c-button/c-button.hbs index 443ab8a6d..cac55e23d 100644 --- a/src/lib/_imports/components/c-button/c-button.hbs +++ b/src/lib/_imports/components/c-button/c-button.hbs @@ -41,12 +41,14 @@
Icons
-
{{/if}} diff --git a/src/lib/_imports/components/c-callout.css b/src/lib/_imports/components/c-callout.css index a8654ae0e..fd5f3245f 100644 --- a/src/lib/_imports/components/c-callout.css +++ b/src/lib/_imports/components/c-callout.css @@ -7,8 +7,8 @@ Markup: c-callout.html Styleguide Components.Callout */ -@import url("_imports/tools/media-queries.css"); -@import url("_imports/tools/x-article-link.css"); +@import url("../tools/media-queries.css"); +@import url("../tools/x-article-link.css"); diff --git a/src/lib/_imports/components/c-card.css b/src/lib/_imports/components/c-card.css index 6b6d4228c..a0e64f951 100644 --- a/src/lib/_imports/components/c-card.css +++ b/src/lib/_imports/components/c-card.css @@ -11,7 +11,7 @@ Markup: c-card.html Styleguide Components.Card */ -@import url("_imports/tools/x-article-link.css"); +@import url("../tools/x-article-link.css"); /* Modifiers */ diff --git a/src/lib/_imports/components/c-data-list.css b/src/lib/_imports/components/c-data-list.css index 9a197d2d2..9e2c34055 100644 --- a/src/lib/_imports/components/c-data-list.css +++ b/src/lib/_imports/components/c-data-list.css @@ -29,7 +29,7 @@ Markup: c-data-list.html Styleguide Components.DataList */ -@import url("_imports/tools/x-truncate.css"); +@import url("../tools/x-truncate.css"); diff --git a/src/lib/_imports/components/c-nav.css b/src/lib/_imports/components/c-nav.css index 5e25ff030..f8a057157 100644 --- a/src/lib/_imports/components/c-nav.css +++ b/src/lib/_imports/components/c-nav.css @@ -17,7 +17,7 @@ Markup: c-nav.html Styleguide Components.Nav */ -@import url("_imports/tools/media-queries.css"); +@import url("../tools/media-queries.css"); diff --git a/src/lib/_imports/components/c-see-all-link.css b/src/lib/_imports/components/c-see-all-link.css index f6cec9d72..7710d0f7d 100644 --- a/src/lib/_imports/components/c-see-all-link.css +++ b/src/lib/_imports/components/c-see-all-link.css @@ -11,7 +11,7 @@ Markup: Styleguide Components.SeeAllLink */ -@import url("_imports/tools/x-truncate.css"); +@import url("../tools/x-truncate.css"); diff --git a/src/lib/_imports/components/c-show-more.css b/src/lib/_imports/components/c-show-more.css index 09a47df41..c28c1cb43 100644 --- a/src/lib/_imports/components/c-show-more.css +++ b/src/lib/_imports/components/c-show-more.css @@ -11,7 +11,7 @@ A CSS-only way to support a "Show More…" feature. It requires a container and Styleguide: Components.ShowMore */ -@import url("_imports/tools/x-truncate.css"); +@import url("../tools/x-truncate.css"); /* Truncation */ diff --git a/src/lib/_imports/components/cortal.icon.css b/src/lib/_imports/components/cortal.icon.css new file mode 100644 index 000000000..8a571805d --- /dev/null +++ b/src/lib/_imports/components/cortal.icon.css @@ -0,0 +1,79 @@ +/* +Container (Bootstrap) + +Provide Cortal Icon styles. See: + +- [Cortal Icons (Confluence)](https://confluence.tacc.utexas.edu/x/MCAFDg) + +Styleguide Components.Cortal.Icon +*/ +@import url('./cortal.icon.font.css'); + + + +/* IMPORTANT: Do not add support for icons that neglect `.icon` class */ +/* FAQ: Users should build their icons to spec */ + + + +/* Aliases */ +/* SEE: https://github.com/TACC/Core-Portal/blob/22405ca/client/src/styles/trumps/icon.css#L57 */ + +/* CAVEAT: Urgent use only; always prefer official icon names */ + + + +/* Overrides */ + +/* To overwrite `cortal.icon.fonts.css` icon sizes */ +/* SEE: https://confluence.tacc.utexas.edu/x/dgB_CQ */ +/* CAVEAT: Assumes 1rem = 10px */ +/* relative units */ +.icon-sm { + font-size: 1.8rem; +} +.icon-md { + font-size: 2.4rem; +} +.icon-lg { + font-size: 6.4rem; +} +/* absolute units */ +.icon-18 { + font-size: 18px; +} +.icon-24 { + font-size: 24px; +} +.icon-64 { + font-size: 64px; +} +.icon-16, +.icon-32 { font-size: unset /* to disallow unsupported font sizes */ } + + + +/* Placeholders */ +/* FAQ: Some icons do not exist, but can be faked (with caveats) */ + +/* To create a small "chevron" */ +/* CAVEAT: Use `--color` to set color */ +[class*='icon-nav-'] { + border: solid var(--color, var(--global-color-primary--xx-dark)); + border-width: 0 0.25em 0.25em 0; + font-size: 8px; + /* display: inline-block; */ /* let `.icon`'s `display: inline-flex;` do it */ + /* padding: var(--size); */ /* let `.icon`'s equal `width` & `height` do it */ +} +.icon-nav-up { + transform: rotate(-135deg); +} +.icon-nav-left { + transform: rotate(135deg); +} +.icon-nav-down { + transform: rotate(45deg); +} +.icon-nav-right { + transform: rotate(-45deg); +} \ No newline at end of file diff --git a/src/lib/_imports/components/cortal.icon.font.css b/src/lib/_imports/components/cortal.icon.font.css new file mode 100644 index 000000000..d3448b2fb --- /dev/null +++ b/src/lib/_imports/components/cortal.icon.font.css @@ -0,0 +1,464 @@ +/*-------------------------------- +cortal Web Font +Generated using nucleoapp.com +-------------------------------- */ +@font-face { + font-family: 'cortal'; + src: url(data:font/opentype;charset=utf-8;base64,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); + src: url(data:font/x-font-woff;charset=utf-8;base64,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) format('woff'), + url(data:font/truetype;charset=utf-8;base64,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) format('truetype'); + font-weight: normal; + font-style: normal; + } + /*------------------------ + base class definition + -------------------------*/ + .icon { + display: inline-block; + font: normal normal normal 1em/1 'cortal'; + color: inherit; + flex-shrink: 0; + speak: none; + text-transform: none; + /* Better Font Rendering */ + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; + } + /*------------------------ + change icon size + -------------------------*/ + /* relative units */ + .icon-sm { + font-size: 0.8em; + } + .icon-lg { + font-size: 1.2em; + } + /* absolute units */ + .icon-16 { + font-size: 16px; + } + .icon-32 { + font-size: 32px; + } + + /*------------------------ + spinning icons + -------------------------*/ + .icon-is-spinning { + animation: icon-spin 1s infinite linear; + } + @keyframes icon-spin { + 0% { + transform: rotate(0deg); + } + 100% { + transform: rotate(360deg); + } + } + /*------------------------ + rotated/flipped icons + -------------------------*/ + .icon-rotate-90 { + transform: rotate(90deg); + } + .icon-rotate-180 { + transform: rotate(180deg); + } + .icon-rotate-270 { + transform: rotate(270deg); + } + .icon-flip-y { + transform: scaleY(-1); + } + .icon-flip-x { + transform: scaleX(-1); + } + /*------------------------ + icons + -------------------------*/ + + .icon-add-file::before { + content: "\ea02"; + } + + .icon-alert::before { + content: "\ea03"; + } + + .icon-approved-allocations::before { + content: "\ea04"; + } + + .icon-allocations::before { + content: "\ea05"; + } + + .icon-applications::before { + content: "\ea06"; + } + + .icon-approved-boxed-reverse::before { + content: "\ea07"; + } + + .icon-approved-boxed::before { + content: "\ea08"; + } + + .icon-approved-reverse::before { + content: "\ea09"; + } + + .icon-approved::before { + content: "\ea0a"; + } + + .icon-add::before { + content: "\ea0b"; + } + + .icon-boxed::before { + content: "\ea0c"; + } + + .icon-browser::before { + content: "\ea0d"; + } + + .icon-bulb::before { + content: "\ea0e"; + } + + .icon-burger::before { + content: "\ea0f"; + } + + .icon-calendar::before { + content: "\ea10"; + } + + .icon-close-boxed::before { + content: "\ea11"; + } + + .icon-close::before { + content: "\ea12"; + } + + .icon-code::before { + content: "\ea13"; + } + + .icon-compass::before { + content: "\ea14"; + } + + .icon-contract::before { + content: "\ea15"; + } + + .icon-conversation::before { + content: "\ea16"; + } + + .icon-copy::before { + content: "\ea17"; + } + + .icon-coversation-wait::before { + content: "\ea18"; + } + + .icon-dashboard::before { + content: "\ea19"; + } + + .icon-data-files::before { + content: "\ea1a"; + } + + .icon-data-processing::before { + content: "\ea1b"; + } + + .icon-denied-reverse::before { + content: "\ea1c"; + } + + .icon-denied::before { + content: "\ea1d"; + } + + .icon-dna::before { + content: "\ea1e"; + } + + .icon-document::before { + content: "\ea1f"; + } + + .icon-download::before { + content: "\ea20"; + } + + .icon-edit-document::before { + content: "\ea21"; + } + + .icon-exit::before { + content: "\ea22"; + } + + .icon-down-arrow::before { + content: "\ea23"; + } + + .icon-expand::before { + content: "\ea24"; + } + + .icon-file::before { + content: "\ea25"; + } + + .icon-folder::before { + content: "\ea26"; + } + + .icon-gear::before { + content: "\ea27"; + } + + .icon-globe::before { + content: "\ea28"; + } + + .icon-history-reverse::before { + content: "\ea29"; + } + + .icon-history::before { + content: "\ea2a"; + } + + .icon-image::before { + content: "\ea2b"; + } + + .icon-jobs-history::before { + content: "\ea2c"; + } + + .icon-jobs::before { + content: "\ea2d"; + } + + .icon-jupyter::before { + content: "\ea2e"; + } + + .icon-link::before { + content: "\ea2f"; + } + + .icon-lock::before { + content: "\ea30"; + } + + .icon-matlab::before { + content: "\ea31"; + } + + .icon-monitor::before { + content: "\ea32"; + } + + .icon-move::before { + content: "\ea33"; + } + + .icon-multiple-coversation::before { + content: "\ea34"; + } + + .icon-my-data::before { + content: "\ea35"; + } + + .icon-namd::before { + content: "\ea36"; + } + + .icon-new-browser::before { + content: "\ea37"; + } + + .icon-no-alert::before { + content: "\ea38"; + } + + .icon-pending::before { + content: "\ea39"; + } + + .icon-pie-graph-open::before { + content: "\ea3a"; + } + + .icon-pie-graph-reverse::before { + content: "\ea3b"; + } + + .icon-pie-graph::before { + content: "\ea3c"; + } + + .icon-project::before { + content: "\ea3d"; + } + + .icon-proposal-approved::before { + content: "\ea3e"; + } + + .icon-proposal-denied::before { + content: "\ea3f"; + } + + .icon-proposal-pending::before { + content: "\ea40"; + } + + .icon-publications::before { + content: "\ea41"; + } + + .icon-push-left::before { + content: "\ea42"; + } + + .icon-push-right::before { + content: "\ea43"; + } + + .icon-refresh::before { + content: "\ea44"; + } + + .icon-rename::before { + content: "\ea45"; + } + + .icon-reverse-order::before { + content: "\ea46"; + } + + .icon-rotate-ccw::before { + content: "\ea47"; + } + + .icon-rotate-cw::before { + content: "\ea48"; + } + + .icon-rstudio::before { + content: "\ea49"; + } + + .icon-save::before { + content: "\ea4a"; + } + + .icon-script::before { + content: "\ea4b"; + } + + .icon-search-folder::before { + content: "\ea4c"; + } + + .icon-search::before { + content: "\ea4d"; + } + + .icon-share::before { + content: "\ea4e"; + } + + .icon-sillouette::before { + content: "\ea4f"; + } + + .icon-simulation-reverse::before { + content: "\ea50"; + } + + .icon-simulation::before { + content: "\ea51"; + } + + .icon-subtract-file::before { + content: "\ea52"; + } + + .icon-toolbox::before { + content: "\ea53"; + } + + .icon-trash::before { + content: "\ea54"; + } + + .icon-trophy::before { + content: "\ea55"; + } + + .icon-unlock::before { + content: "\ea56"; + } + + .icon-upload::before { + content: "\ea57"; + } + + .icon-user-reverse::before { + content: "\ea58"; + } + + .icon-user::before { + content: "\ea59"; + } + + .icon-visualization::before { + content: "\ea5a"; + } + + .icon-zoom-in::before { + content: "\ea5b"; + } + + .icon-zoom-out::before { + content: "\ea5c"; + } + + .icon-bar-graph::before { + content: "\ea5d"; + } + + .icon-add-folder::before { + content: "\ea5e"; + } + + .icon-add-project::before { + content: "\ea5f"; + } + + .icon-extract::before { + content: "\ea60"; + } + + .icon-compress::before { + content: "\ea61"; + } + \ No newline at end of file diff --git a/src/lib/_imports/components/cortal.icon.font.md b/src/lib/_imports/components/cortal.icon.font.md new file mode 100644 index 000000000..990e1d050 --- /dev/null +++ b/src/lib/_imports/components/cortal.icon.font.md @@ -0,0 +1,3 @@ +# Cortal Icon Font + +The file `cortal.icon.font.css` comes from raw CSS provided by latest version of [TACC's "Cortal" icon font](https://confluence.tacc.utexas.edu/x/MCAFDg). diff --git a/src/lib/_imports/objects/o-fixed-header-table.css b/src/lib/_imports/objects/o-fixed-header-table.css new file mode 100644 index 000000000..c5b8d305a --- /dev/null +++ b/src/lib/_imports/objects/o-fixed-header-table.css @@ -0,0 +1,33 @@ +/* +Fixed Header Table + +A table with a header that does not move, and a body that scrolls. + +Markup: + + + + + + + + + + + + + + + +
ABC
ABC
+ +Styleguide Objects.FixedHeaderTable +*/ +/* SEE: https://css-tricks.com/position-sticky-and-table-headers/ */ +.o-fixed-header-table th { + position: sticky; + top: 0; + + z-index: 1; /* so table content (e.g. button)¹ does not scroll over */ + /* ¹ table content with a `position` value other than static */ +} diff --git a/src/lib/_imports/objects/o-grid.css b/src/lib/_imports/objects/o-grid.css index e2139f904..be1629ec7 100644 --- a/src/lib/_imports/objects/o-grid.css +++ b/src/lib/_imports/objects/o-grid.css @@ -15,8 +15,8 @@ Markup: o-grid.html Styleguide Objects.Grid */ -@import url("_imports/tools/media-queries.css"); -@import url("_imports/tools/x-grid.css"); +@import url("../tools/media-queries.css"); +@import url("../tools/x-grid.css"); diff --git a/src/lib/_imports/objects/o-offset-content.css b/src/lib/_imports/objects/o-offset-content.css index f9ce110de..5efbe36d6 100644 --- a/src/lib/_imports/objects/o-offset-content.css +++ b/src/lib/_imports/objects/o-offset-content.css @@ -5,7 +5,7 @@ Content that should be offset from the flow of text within which it is placed. Styleguide Objects.OffsetContent */ -@import url("_imports/tools/media-queries.css"); +@import url("../tools/media-queries.css"); diff --git a/src/lib/_imports/objects/o-section.css b/src/lib/_imports/objects/o-section.css index 055e2603b..417788709 100644 --- a/src/lib/_imports/objects/o-section.css +++ b/src/lib/_imports/objects/o-section.css @@ -32,9 +32,9 @@ Markup: o-section.html Styleguide Objects.Section */ -@import url("_imports/tools/media-queries.css"); -@import url("_imports/tools/x-layout.css"); -@import url("_imports/tools/x-fake-border.css"); +@import url("../tools/media-queries.css"); +@import url("../tools/x-layout.css"); +@import url("../tools/x-fake-border.css"); diff --git a/src/lib/_imports/settings/font.css b/src/lib/_imports/settings/font.css index 9e6dc1279..ff9e422dc 100644 --- a/src/lib/_imports/settings/font.css +++ b/src/lib/_imports/settings/font.css @@ -20,6 +20,13 @@ Styleguide Settings.CustomProperties.Font */ :root { + /* Family */ + /* NOTE: Clients are expected to overwrite these values via their CSS */ + --global-font-family--sans: sans-serif; + --global-font-family--serif: serif; + --global-font-family--mono: monospace; + + /* Size */ /* SEE: https://confluence.tacc.utexas.edu/x/nh4FDg */ /* CAVEAT: These font sizes assume root font is 10px or an equivalent value */ diff --git a/src/lib/_imports/tools/x-layout.css b/src/lib/_imports/tools/x-layout.css index 58018f1ef..e6945cb4d 100644 --- a/src/lib/_imports/tools/x-layout.css +++ b/src/lib/_imports/tools/x-layout.css @@ -11,7 +11,7 @@ Styles that allow re-usable layouts. Styleguide Tools.ExtendsAndMixins.Layout */ -@import url("_imports/tools/media-queries.css"); +@import url("../tools/media-queries.css"); diff --git a/src/lib/_imports/trumps/s-article-list.css b/src/lib/_imports/trumps/s-article-list.css index b1237bc2e..b7140c3eb 100644 --- a/src/lib/_imports/trumps/s-article-list.css +++ b/src/lib/_imports/trumps/s-article-list.css @@ -7,9 +7,9 @@ Markup: s-article-list.html Styleguide Trumps.Scopes.ArticleList */ -@import url("_imports/tools/x-truncate.css"); -@import url("_imports/tools/x-layout.css"); -@import url("_imports/tools/x-article-link.css"); +@import url("../tools/x-truncate.css"); +@import url("../tools/x-layout.css"); +@import url("../tools/x-article-link.css"); diff --git a/src/lib/_imports/trumps/s-article-preview.css b/src/lib/_imports/trumps/s-article-preview.css index cbe36e415..544fe436c 100644 --- a/src/lib/_imports/trumps/s-article-preview.css +++ b/src/lib/_imports/trumps/s-article-preview.css @@ -7,8 +7,8 @@ Markup: s-article-preview.html Styleguide Trumps.Scopes.ArticlePreview */ -@import url("_imports/tools/x-truncate.css"); -@import url("_imports/tools/x-article-link.css"); +@import url("../tools/x-truncate.css"); +@import url("../tools/x-article-link.css"); diff --git a/src/lib/_imports/trumps/s-breadcrumbs.css b/src/lib/_imports/trumps/s-breadcrumbs.css index a85f0ac69..b388cd8c2 100644 --- a/src/lib/_imports/trumps/s-breadcrumbs.css +++ b/src/lib/_imports/trumps/s-breadcrumbs.css @@ -25,7 +25,7 @@ Markup: Styleguide Trumps.Scopes.Breadcrumbs */ -@import url("_imports/tools/x-truncate.css"); +@import url("../tools/x-truncate.css"); diff --git a/src/lib/_imports/trumps/s-system-specs.css b/src/lib/_imports/trumps/s-system-specs.css index 15b25cf1f..6d2a044ca 100644 --- a/src/lib/_imports/trumps/s-system-specs.css +++ b/src/lib/_imports/trumps/s-system-specs.css @@ -8,7 +8,7 @@ Styles for System Specifications content which assumes external code: Styleguide Trumps.Scopes.SystemSpecs */ -@import url("_imports/tools/media-queries.css"); +@import url("../tools/media-queries.css");