Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 | 94x 94x 94x 94x 94x 94x 94x 11x 94x 12x 94x 37x 94x 28x 94x 18x 94x 11x 94x 123x 109x 14x 109x 94x 94x 94x 94x 94x 94x 94x 94x 94x 94x 23x 23x 100x 100x 53x 53x 53x 23x 94x 29x 27x 4x 23x 23x 94x 65x 65x 57x 8x 8x 94x 333x 121x 212x 212x 175x 175x 115x 115x 115x 6x 109x 4x 105x 97x 97x 83x 59x 85x 83x | /**
* @module Utils
*/
import * as MH from "@lisn/globals/minification-helpers";
import { LisnUsageError } from "@lisn/globals/errors";
import { settings } from "@lisn/globals/settings";
import {
DeviceSpec,
Device,
AspectRatioSpec,
AspectRatio,
} from "@lisn/globals/types";
import { sortedKeysByVal } from "@lisn/utils/math";
import { validateStrList } from "@lisn/utils/validation";
import {
BitSpace,
newBitSpaces,
createBitSpace,
} from "@lisn/modules/bit-spaces";
/**
* Returns true if the given string is a valid device name.
*
* @category Validation
*/
export const isValidDevice = (device: string): device is Device =>
ORDERED_DEVICES.has(device);
/**
* Returns true if the given string is a valid aspect ratio name.
*
* @category Validation
*/
export const isValidAspectRatio = (
aspectRatio: string,
): aspectRatio is AspectRatio => ORDERED_ASPECTR.has(aspectRatio);
/**
* Returns true if the given string is a valid device specification (including
* `"min <Device>"`, etc).
*
* Returns false for "", although if you passed "" in
* {@link Watchers/LayoutWatcher.OnLayoutOptions | OnLayoutOptions} it would
* accept it as specifying _all_ devices.
*
* @category Validation
*/
export const isValidDeviceList = (
device: string | string[],
): device is DeviceSpec | Device[] =>
isValidForType(S_DEVICES, device, ORDERED_DEVICES);
/**
* Returns true if the given string is a valid aspect ratio specification
* (including `"min <AspectRatio>"`, etc).
*
* Returns false for "", although if you passed "" in
* {@link Watchers/LayoutWatcher.OnLayoutOptions | OnLayoutOptions} it would
* accept it as specifying _all_ aspect ratios.
*
* @category Validation
*/
export const isValidAspectRatioList = (
aspectR: string | string[],
): aspectR is AspectRatioSpec | AspectRatio[] =>
isValidForType(S_ASPECTRS_CAMEL, aspectR, ORDERED_ASPECTR);
/**
* Returns a list of {@link Device}s that are not covered by the given device
* specification. See
* {@link Watchers/LayoutWatcher.OnLayoutOptions | OnLayoutOptions} for accepted
* formats.
*
* Returns an empty for "" or for a specification that includes all devices.
*
* @category Layout
*/
export const getOtherDevices = (device: DeviceSpec | Device[]): Device[] =>
getOtherLayouts(S_DEVICES, device, ORDERED_DEVICES);
/**
* Returns a list of {@link AspectRatio}s that are not covered by the given
* aspect ratio specification. See
* {@link Watchers/LayoutWatcher.OnLayoutOptions | OnLayoutOptions} for accepted
* formats.
*
* Returns an empty for "" or for a specification that includes all aspect
* ratios.
*
* @category Layout
*/
export const getOtherAspectRatios = (
aspectR: AspectRatioSpec | AspectRatio[],
): AspectRatio[] => getOtherLayouts(S_ASPECTRS_CAMEL, aspectR, ORDERED_ASPECTR);
/**
* @ignore
* @internal
*/
export const getLayoutBitmask = (options?: {
devices?: DeviceSpec | Device[];
aspectRatios?: AspectRatioSpec | AspectRatio[];
}): number => {
let layoutBitmask =
getBitmaskFromSpec(S_DEVICES, options?.devices, ORDERED_DEVICES) |
getBitmaskFromSpec(
S_ASPECTRS_CAMEL,
options?.aspectRatios,
ORDERED_ASPECTR,
);
if (!layoutBitmask) {
layoutBitmask = ORDERED_DEVICES.bitmask | ORDERED_ASPECTR.bitmask; // default: all
}
return layoutBitmask;
};
// In ascending order by width.
const ORDERED_DEVICE_NAMES = sortedKeysByVal(settings.deviceBreakpoints);
const ORDERED_ASPECTR_NAMES = sortedKeysByVal(settings.aspectRatioBreakpoints);
const bitSpaces = newBitSpaces();
/**
* @ignore
* @internal
*/
export const ORDERED_DEVICES = createBitSpace(
bitSpaces,
...ORDERED_DEVICE_NAMES,
);
/**
* @ignore
* @internal
*/
export const ORDERED_ASPECTR = createBitSpace(
bitSpaces,
...ORDERED_ASPECTR_NAMES,
);
/**
* @ignore
* @internal
*/
export const NUM_LAYOUTS =
MH.lengthOf(ORDERED_DEVICE_NAMES) + MH.lengthOf(ORDERED_ASPECTR_NAMES);
// --------------------
const S_DEVICES = "devices";
const S_ASPECTRS_CAMEL = "aspectRatios";
// Don't use capture groups for old browser support
const LAYOUT_RANGE_REGEX = RegExp(
"^ *(?:" +
"([a-z-]+) +to +([a-z-]+)|" +
"min +([a-z-]+)|" +
"max +([a-z-]+)" +
") *$",
);
const getLayoutsFromBitmask = <T extends Device | AspectRatio>(
keyName: string,
bitmask: number,
bitSpace: BitSpace<T>,
): T[] => {
const layouts: T[] = [];
for (let bit = bitSpace.start; bit <= bitSpace.end; bit++) {
const value = 1 << bit;
if (bitmask & value) {
const name = bitSpace.nameOf(value);
if (name) {
layouts.push(name);
}
}
}
return layouts;
};
const getOtherLayouts = <T extends Device | AspectRatio>(
keyName: string,
spec: string | string[],
bitSpace: BitSpace<T>,
): T[] => {
const bitmask = getBitmaskFromSpec(keyName, spec, bitSpace);
if (!bitmask) {
return [];
}
const oppositeBitmask = bitSpace.bitmask & ~bitmask;
return getLayoutsFromBitmask(keyName, oppositeBitmask, bitSpace);
};
const isValidForType = <T extends Device | AspectRatio>(
keyName: string,
spec: string | string[],
bitSpace: BitSpace<T>,
): boolean => {
try {
const bitmask = getBitmaskFromSpec(keyName, spec, bitSpace);
return bitmask !== 0;
} catch (err) {
if (MH.isInstanceOf(err, LisnUsageError)) {
return false;
}
throw err;
}
};
const getBitmaskFromSpec = <T extends Device | AspectRatio>(
keyName: string,
spec: string | string[] | undefined | null,
bitSpace: BitSpace<T>,
): number => {
if (MH.isEmpty(spec)) {
return 0;
}
const singleKeyName = keyName.slice(0, -1);
if (MH.isString(spec)) {
const rangeMatch = spec.match(LAYOUT_RANGE_REGEX);
if (rangeMatch) {
const minLayout = rangeMatch[1] || rangeMatch[3];
const maxLayout = rangeMatch[2] || rangeMatch[4];
if (minLayout !== undefined && !bitSpace.has(minLayout)) {
throw MH.usageError(`Unknown ${singleKeyName} '${minLayout}'`);
}
if (maxLayout !== undefined && !bitSpace.has(maxLayout)) {
throw MH.usageError(`Unknown ${singleKeyName} '${maxLayout}'`);
}
return bitSpace.bitmaskFor(minLayout, maxLayout);
}
}
let bitmask = 0;
const layouts = validateStrList(keyName, spec, bitSpace.has);
if (layouts) {
for (const lt of layouts) {
bitmask |= bitSpace.bit[lt];
}
}
return bitmask;
};
|