505 lines
14 KiB
JavaScript
505 lines
14 KiB
JavaScript
import { H as u, d as w, s as k, r as v, C as f, l as V, a as b } from "./string_utils-B4bsIQ5w.mjs";
|
|
/**
|
|
* @license
|
|
* Copyright 2021 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
class C {
|
|
/**
|
|
* Blend the design color's HCT hue towards the key color's HCT
|
|
* hue, in a way that leaves the original color recognizable and
|
|
* recognizably shifted towards the key color.
|
|
*
|
|
* @param designColor ARGB representation of an arbitrary color.
|
|
* @param sourceColor ARGB representation of the main theme color.
|
|
* @return The design color with a hue shifted towards the
|
|
* system's color, a slightly warmer/cooler variant of the design
|
|
* color's hue.
|
|
*/
|
|
static harmonize(r, t) {
|
|
const e = u.fromInt(r), n = u.fromInt(t), a = w(e.hue, n.hue), o = Math.min(a * 0.5, 15), c = k(e.hue + o * v(e.hue, n.hue));
|
|
return u.from(c, e.chroma, e.tone).toInt();
|
|
}
|
|
/**
|
|
* Blends hue from one color into another. The chroma and tone of
|
|
* the original color are maintained.
|
|
*
|
|
* @param from ARGB representation of color
|
|
* @param to ARGB representation of color
|
|
* @param amount how much blending to perform; 0.0 >= and <= 1.0
|
|
* @return from, with a hue blended towards to. Chroma and tone
|
|
* are constant.
|
|
*/
|
|
static hctHue(r, t, e) {
|
|
const n = C.cam16Ucs(r, t, e), a = f.fromInt(n), o = f.fromInt(r);
|
|
return u.from(a.hue, o.chroma, V(r)).toInt();
|
|
}
|
|
/**
|
|
* Blend in CAM16-UCS space.
|
|
*
|
|
* @param from ARGB representation of color
|
|
* @param to ARGB representation of color
|
|
* @param amount how much blending to perform; 0.0 >= and <= 1.0
|
|
* @return from, blended towards to. Hue, chroma, and tone will
|
|
* change.
|
|
*/
|
|
static cam16Ucs(r, t, e) {
|
|
const n = f.fromInt(r), a = f.fromInt(t), o = n.jstar, c = n.astar, p = n.bstar, d = a.jstar, y = a.astar, l = a.bstar, g = o + (d - o) * e, S = c + (y - c) * e, H = p + (l - p) * e;
|
|
return f.fromUcs(g, S, H).toInt();
|
|
}
|
|
}
|
|
/**
|
|
* @license
|
|
* Copyright 2021 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
class i {
|
|
/**
|
|
* @param argb ARGB representation of a color
|
|
* @return Tones matching that color's hue and chroma.
|
|
*/
|
|
static fromInt(r) {
|
|
const t = u.fromInt(r);
|
|
return i.fromHct(t);
|
|
}
|
|
/**
|
|
* @param hct Hct
|
|
* @return Tones matching that color's hue and chroma.
|
|
*/
|
|
static fromHct(r) {
|
|
return new i(r.hue, r.chroma, r);
|
|
}
|
|
/**
|
|
* @param hue HCT hue
|
|
* @param chroma HCT chroma
|
|
* @return Tones matching hue and chroma.
|
|
*/
|
|
static fromHueAndChroma(r, t) {
|
|
const e = new A(r, t).create();
|
|
return new i(r, t, e);
|
|
}
|
|
constructor(r, t, e) {
|
|
this.hue = r, this.chroma = t, this.keyColor = e, this.cache = /* @__PURE__ */ new Map();
|
|
}
|
|
/**
|
|
* @param tone HCT tone, measured from 0 to 100.
|
|
* @return ARGB representation of a color with that tone.
|
|
*/
|
|
tone(r) {
|
|
let t = this.cache.get(r);
|
|
return t === void 0 && (t = u.from(this.hue, this.chroma, r).toInt(), this.cache.set(r, t)), t;
|
|
}
|
|
/**
|
|
* @param tone HCT tone.
|
|
* @return HCT representation of a color with that tone.
|
|
*/
|
|
getHct(r) {
|
|
return u.fromInt(this.tone(r));
|
|
}
|
|
}
|
|
class A {
|
|
constructor(r, t) {
|
|
this.hue = r, this.requestedChroma = t, this.chromaCache = /* @__PURE__ */ new Map(), this.maxChromaValue = 200;
|
|
}
|
|
/**
|
|
* Creates a key color from a [hue] and a [chroma].
|
|
* The key color is the first tone, starting from T50, matching the given hue
|
|
* and chroma.
|
|
*
|
|
* @return Key color [Hct]
|
|
*/
|
|
create() {
|
|
let n = 0, a = 100;
|
|
for (; n < a; ) {
|
|
const o = Math.floor((n + a) / 2), c = this.maxChroma(o) < this.maxChroma(o + 1);
|
|
if (this.maxChroma(o) >= this.requestedChroma - 0.01)
|
|
if (Math.abs(n - 50) < Math.abs(a - 50))
|
|
a = o;
|
|
else {
|
|
if (n === o)
|
|
return u.from(this.hue, this.requestedChroma, n);
|
|
n = o;
|
|
}
|
|
else
|
|
c ? n = o + 1 : a = o;
|
|
}
|
|
return u.from(this.hue, this.requestedChroma, n);
|
|
}
|
|
// Find the maximum chroma for a given tone
|
|
maxChroma(r) {
|
|
if (this.chromaCache.has(r))
|
|
return this.chromaCache.get(r);
|
|
const t = u.from(this.hue, this.maxChromaValue, r).chroma;
|
|
return this.chromaCache.set(r, t), t;
|
|
}
|
|
}
|
|
/**
|
|
* @license
|
|
* Copyright 2021 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
class s {
|
|
/**
|
|
* @param argb ARGB representation of a color
|
|
*/
|
|
static of(r) {
|
|
return new s(r, !1);
|
|
}
|
|
/**
|
|
* @param argb ARGB representation of a color
|
|
*/
|
|
static contentOf(r) {
|
|
return new s(r, !0);
|
|
}
|
|
/**
|
|
* Create a [CorePalette] from a set of colors
|
|
*/
|
|
static fromColors(r) {
|
|
return s.createPaletteFromColors(!1, r);
|
|
}
|
|
/**
|
|
* Create a content [CorePalette] from a set of colors
|
|
*/
|
|
static contentFromColors(r) {
|
|
return s.createPaletteFromColors(!0, r);
|
|
}
|
|
static createPaletteFromColors(r, t) {
|
|
const e = new s(t.primary, r);
|
|
if (t.secondary) {
|
|
const n = new s(t.secondary, r);
|
|
e.a2 = n.a1;
|
|
}
|
|
if (t.tertiary) {
|
|
const n = new s(t.tertiary, r);
|
|
e.a3 = n.a1;
|
|
}
|
|
if (t.error) {
|
|
const n = new s(t.error, r);
|
|
e.error = n.a1;
|
|
}
|
|
if (t.neutral) {
|
|
const n = new s(t.neutral, r);
|
|
e.n1 = n.n1;
|
|
}
|
|
if (t.neutralVariant) {
|
|
const n = new s(t.neutralVariant, r);
|
|
e.n2 = n.n2;
|
|
}
|
|
return e;
|
|
}
|
|
constructor(r, t) {
|
|
const e = u.fromInt(r), n = e.hue, a = e.chroma;
|
|
t ? (this.a1 = i.fromHueAndChroma(n, a), this.a2 = i.fromHueAndChroma(n, a / 3), this.a3 = i.fromHueAndChroma(n + 60, a / 2), this.n1 = i.fromHueAndChroma(n, Math.min(a / 12, 4)), this.n2 = i.fromHueAndChroma(n, Math.min(a / 6, 8))) : (this.a1 = i.fromHueAndChroma(n, Math.max(48, a)), this.a2 = i.fromHueAndChroma(n, 16), this.a3 = i.fromHueAndChroma(n + 60, 24), this.n1 = i.fromHueAndChroma(n, 4), this.n2 = i.fromHueAndChroma(n, 8)), this.error = i.fromHueAndChroma(25, 84);
|
|
}
|
|
}
|
|
/**
|
|
* @license
|
|
* Copyright 2021 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
class m {
|
|
get primary() {
|
|
return this.props.primary;
|
|
}
|
|
get onPrimary() {
|
|
return this.props.onPrimary;
|
|
}
|
|
get primaryContainer() {
|
|
return this.props.primaryContainer;
|
|
}
|
|
get onPrimaryContainer() {
|
|
return this.props.onPrimaryContainer;
|
|
}
|
|
get secondary() {
|
|
return this.props.secondary;
|
|
}
|
|
get onSecondary() {
|
|
return this.props.onSecondary;
|
|
}
|
|
get secondaryContainer() {
|
|
return this.props.secondaryContainer;
|
|
}
|
|
get onSecondaryContainer() {
|
|
return this.props.onSecondaryContainer;
|
|
}
|
|
get tertiary() {
|
|
return this.props.tertiary;
|
|
}
|
|
get onTertiary() {
|
|
return this.props.onTertiary;
|
|
}
|
|
get tertiaryContainer() {
|
|
return this.props.tertiaryContainer;
|
|
}
|
|
get onTertiaryContainer() {
|
|
return this.props.onTertiaryContainer;
|
|
}
|
|
get error() {
|
|
return this.props.error;
|
|
}
|
|
get onError() {
|
|
return this.props.onError;
|
|
}
|
|
get errorContainer() {
|
|
return this.props.errorContainer;
|
|
}
|
|
get onErrorContainer() {
|
|
return this.props.onErrorContainer;
|
|
}
|
|
get background() {
|
|
return this.props.background;
|
|
}
|
|
get onBackground() {
|
|
return this.props.onBackground;
|
|
}
|
|
get surface() {
|
|
return this.props.surface;
|
|
}
|
|
get onSurface() {
|
|
return this.props.onSurface;
|
|
}
|
|
get surfaceVariant() {
|
|
return this.props.surfaceVariant;
|
|
}
|
|
get onSurfaceVariant() {
|
|
return this.props.onSurfaceVariant;
|
|
}
|
|
get outline() {
|
|
return this.props.outline;
|
|
}
|
|
get outlineVariant() {
|
|
return this.props.outlineVariant;
|
|
}
|
|
get shadow() {
|
|
return this.props.shadow;
|
|
}
|
|
get scrim() {
|
|
return this.props.scrim;
|
|
}
|
|
get inverseSurface() {
|
|
return this.props.inverseSurface;
|
|
}
|
|
get inverseOnSurface() {
|
|
return this.props.inverseOnSurface;
|
|
}
|
|
get inversePrimary() {
|
|
return this.props.inversePrimary;
|
|
}
|
|
/**
|
|
* @param argb ARGB representation of a color.
|
|
* @return Light Material color scheme, based on the color's hue.
|
|
*/
|
|
static light(r) {
|
|
return m.lightFromCorePalette(s.of(r));
|
|
}
|
|
/**
|
|
* @param argb ARGB representation of a color.
|
|
* @return Dark Material color scheme, based on the color's hue.
|
|
*/
|
|
static dark(r) {
|
|
return m.darkFromCorePalette(s.of(r));
|
|
}
|
|
/**
|
|
* @param argb ARGB representation of a color.
|
|
* @return Light Material content color scheme, based on the color's hue.
|
|
*/
|
|
static lightContent(r) {
|
|
return m.lightFromCorePalette(s.contentOf(r));
|
|
}
|
|
/**
|
|
* @param argb ARGB representation of a color.
|
|
* @return Dark Material content color scheme, based on the color's hue.
|
|
*/
|
|
static darkContent(r) {
|
|
return m.darkFromCorePalette(s.contentOf(r));
|
|
}
|
|
/**
|
|
* Light scheme from core palette
|
|
*/
|
|
static lightFromCorePalette(r) {
|
|
return new m({
|
|
primary: r.a1.tone(40),
|
|
onPrimary: r.a1.tone(100),
|
|
primaryContainer: r.a1.tone(90),
|
|
onPrimaryContainer: r.a1.tone(10),
|
|
secondary: r.a2.tone(40),
|
|
onSecondary: r.a2.tone(100),
|
|
secondaryContainer: r.a2.tone(90),
|
|
onSecondaryContainer: r.a2.tone(10),
|
|
tertiary: r.a3.tone(40),
|
|
onTertiary: r.a3.tone(100),
|
|
tertiaryContainer: r.a3.tone(90),
|
|
onTertiaryContainer: r.a3.tone(10),
|
|
error: r.error.tone(40),
|
|
onError: r.error.tone(100),
|
|
errorContainer: r.error.tone(90),
|
|
onErrorContainer: r.error.tone(10),
|
|
background: r.n1.tone(99),
|
|
onBackground: r.n1.tone(10),
|
|
surface: r.n1.tone(99),
|
|
onSurface: r.n1.tone(10),
|
|
surfaceVariant: r.n2.tone(90),
|
|
onSurfaceVariant: r.n2.tone(30),
|
|
outline: r.n2.tone(50),
|
|
outlineVariant: r.n2.tone(80),
|
|
shadow: r.n1.tone(0),
|
|
scrim: r.n1.tone(0),
|
|
inverseSurface: r.n1.tone(20),
|
|
inverseOnSurface: r.n1.tone(95),
|
|
inversePrimary: r.a1.tone(80)
|
|
});
|
|
}
|
|
/**
|
|
* Dark scheme from core palette
|
|
*/
|
|
static darkFromCorePalette(r) {
|
|
return new m({
|
|
primary: r.a1.tone(80),
|
|
onPrimary: r.a1.tone(20),
|
|
primaryContainer: r.a1.tone(30),
|
|
onPrimaryContainer: r.a1.tone(90),
|
|
secondary: r.a2.tone(80),
|
|
onSecondary: r.a2.tone(20),
|
|
secondaryContainer: r.a2.tone(30),
|
|
onSecondaryContainer: r.a2.tone(90),
|
|
tertiary: r.a3.tone(80),
|
|
onTertiary: r.a3.tone(20),
|
|
tertiaryContainer: r.a3.tone(30),
|
|
onTertiaryContainer: r.a3.tone(90),
|
|
error: r.error.tone(80),
|
|
onError: r.error.tone(20),
|
|
errorContainer: r.error.tone(30),
|
|
onErrorContainer: r.error.tone(80),
|
|
background: r.n1.tone(10),
|
|
onBackground: r.n1.tone(90),
|
|
surface: r.n1.tone(10),
|
|
onSurface: r.n1.tone(90),
|
|
surfaceVariant: r.n2.tone(30),
|
|
onSurfaceVariant: r.n2.tone(80),
|
|
outline: r.n2.tone(60),
|
|
outlineVariant: r.n2.tone(30),
|
|
shadow: r.n1.tone(0),
|
|
scrim: r.n1.tone(0),
|
|
inverseSurface: r.n1.tone(90),
|
|
inverseOnSurface: r.n1.tone(20),
|
|
inversePrimary: r.a1.tone(40)
|
|
});
|
|
}
|
|
constructor(r) {
|
|
this.props = r;
|
|
}
|
|
toJSON() {
|
|
return {
|
|
...this.props
|
|
};
|
|
}
|
|
}
|
|
/**
|
|
* @license
|
|
* Copyright 2021 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
function I(h, r = []) {
|
|
const t = s.of(h);
|
|
return {
|
|
source: h,
|
|
schemes: {
|
|
light: m.light(h),
|
|
dark: m.dark(h)
|
|
},
|
|
palettes: {
|
|
primary: t.a1,
|
|
secondary: t.a2,
|
|
tertiary: t.a3,
|
|
neutral: t.n1,
|
|
neutralVariant: t.n2,
|
|
error: t.error
|
|
},
|
|
customColors: r.map((e) => F(h, e))
|
|
};
|
|
}
|
|
function F(h, r) {
|
|
let t = r.value;
|
|
const e = t, n = h;
|
|
r.blend && (t = C.harmonize(e, n));
|
|
const o = s.of(t).a1;
|
|
return {
|
|
color: r,
|
|
value: t,
|
|
light: {
|
|
color: o.tone(40),
|
|
onColor: o.tone(100),
|
|
colorContainer: o.tone(90),
|
|
onColorContainer: o.tone(10)
|
|
},
|
|
dark: {
|
|
color: o.tone(80),
|
|
onColor: o.tone(20),
|
|
colorContainer: o.tone(30),
|
|
onColorContainer: o.tone(90)
|
|
}
|
|
};
|
|
}
|
|
function P(h) {
|
|
const r = b(h);
|
|
return I(r);
|
|
}
|
|
export {
|
|
P as createTheme
|
|
};
|