Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
// $ExpectType { a: string; b: number; }
autoRecord({ a: string, b: number })(undefined);
// $ExpectType { a: string; b: number; }
autoRecord({ a: string, b: number })(undefined);
// $ExpectType { a: string; b: number; c: boolean | undefined; }
autoRecord({ a: string, b: number, c: optional(boolean) })(undefined);
// $ExpectType string
deep([], string)(undefined);
// $ExpectType string | undefined
optional(string)(undefined);
// $ExpectType string
optional(string, "default")(undefined);
// $ExpectType string | null
optional(string, null)(undefined);
// $ExpectType string
map(string, string)(undefined);
// $ExpectType string | number
either(string, number)(undefined);
// $ExpectType string | number | boolean | { readonly [key: string]: unknown; }
either(either(boolean, string), either(number, mixedDict))(undefined);
// $ExpectType string
lazy(() => string)(undefined);
// $ExpectError
boolean(undefined, []);
// $ExpectError
number(undefined, []);
// $ExpectError
string(undefined, []);
// $ExpectError
mixedArray(undefined, []);
// $ExpectError
part !== ""
? // Modifiers.
{ ...shortcut, [part]: true }
: shortcut,
{ ...EMPTY_SHORTCUT }
);
}
export type KeyboardMapping = {
shortcut: Shortcut,
action: KeyboardAction,
};
export const decodeKeyboardMapping: Decoder = autoRecord({
shortcut: decodeShortcut,
action: map(string, decodeKeyboardAction),
});
export const decodeKeyboardMappingWithModifiers: Decoder = autoRecord(
{
shortcut: map(decodeShortcut, requireModifier),
action: map(string, decodeKeyboardAction),
}
);
export type KeyboardModeBackground =
| { type: "FromHintsState" }
| { type: "PreventOverTyping", sinceTimestamp: number }
| { type: "Capture" };
export type KeyboardModeWorker =
| "Normal"
async restorePosition() {
if (!PROD) {
if (this.hasRestoredPosition) {
return;
}
this.hasRestoredPosition = true;
const recordProps = {
expandedPerfTabIds: optional(
map(array(string), ids =>
ids.filter(id => ({}.hasOwnProperty.call(this.state.perf, id)))
),
([]: Array)
),
expandedPerf: optional(boolean, false),
expandedDebug: optional(boolean, false),
scrollY: optional(number, 0),
};
const data = await browser.storage.local.get(Object.keys(recordProps));
const decoder = autoRecord(recordProps);
const { scrollY, expandedPerfTabIds, ...state } = decoder(data);
this.setState({ ...state, expandedPerfTabIds }, () => {
window.scrollTo(0, scrollY);
});
}
}
return record(field => ({
chars: field("chars", map(string, validateChars), {
default: defaults.chars,
}),
autoActivate: field("autoActivate", boolean, {
default: defaults.autoActivate,
}),
overTypingDuration: field("overTypingDuration", decodeUnsignedInt, {
default: defaults.overTypingDuration,
}),
css: field("css", string, {
default: defaults.css,
}),
logLevel: field("logLevel", map(string, decodeLogLevel), {
default: defaults.logLevel,
}),
useKeyTranslations: field("useKeyTranslations", boolean, {
default: defaults.useKeyTranslations,
break;
}
case "StringSet": {
const decoded = decodeStringSet(string)(value);
mapping[key] = {
type: "StringSet",
value: decoded,
};
changed[key] = !equalStringSets(decoded, original.value);
break;
}
case "ElementTypeSet": {
const decoded: Set = decodeStringSet(
map(string, decodeElementType)
)(value);
mapping[key] = {
type: "ElementTypeSet",
value: decoded,
};
changed[key] = !equalStringSets(
new Set(decoded),
new Set(original.value)
);
break;
}
case "SelectorString": {
const decoded = map(string, val => {
document.querySelector(val);
return val;
);
}
export type KeyboardMapping = {
shortcut: Shortcut,
action: KeyboardAction,
};
export const decodeKeyboardMapping: Decoder = autoRecord({
shortcut: decodeShortcut,
action: map(string, decodeKeyboardAction),
});
export const decodeKeyboardMappingWithModifiers: Decoder = autoRecord(
{
shortcut: map(decodeShortcut, requireModifier),
action: map(string, decodeKeyboardAction),
}
);
export type KeyboardModeBackground =
| { type: "FromHintsState" }
| { type: "PreventOverTyping", sinceTimestamp: number }
| { type: "Capture" };
export type KeyboardModeWorker =
| "Normal"
| "Hints"
| "PreventOverTyping"
| "Capture";
export type HintsMode =
return record(field => ({
chars: field("chars", map(string, validateChars), {
default: defaults.chars,
}),
autoActivate: field("autoActivate", boolean, {
default: defaults.autoActivate,
}),
overTypingDuration: field("overTypingDuration", decodeUnsignedInt, {
default: defaults.overTypingDuration,
}),
css: field("css", string, {
default: defaults.css,
}),
logLevel: field("logLevel", map(string, decodeLogLevel), {
default: defaults.logLevel,
}),
useKeyTranslations: field("useKeyTranslations", boolean, {
default: defaults.useKeyTranslations,
}),
keyTranslations: field("keyTranslations", dict(decodeKeyPair, "skip"), {
default: defaults.keyTranslations,
}),
normalKeyboardShortcuts: field(
"normalKeyboardShortcuts",
array(decodeKeyboardMappingWithModifiers, "skip"),
{ default: defaults.normalKeyboardShortcuts }
),
hintsKeyboardShortcuts: field(
"hintsKeyboardShortcuts",
array(decodeKeyboardMapping, "skip"),
default:
throw new TypeError(`Invalid ElementType: ${repr(type)}`);
}
}
export function decodeElementTypesConstants(type: string): ElementTypes {
switch (type) {
case "selectable":
return type;
default:
throw new TypeError(`Invalid ElementTypes constant: ${repr(type)}`);
}
}
export const decodeElementTypes: Decoder = either(
map(string, decodeElementTypesConstants),
array(map(string, decodeElementType))
);
export type Point = {
x: number,
y: number,
align: "left" | "right",
debug: string,
};
export type HintMeasurements = {
...Point,
maxX: number,
weight: number,
};
const decoded: Set = decodeStringSet(
map(string, decodeElementType)
)(value);
mapping[key] = {
type: "ElementTypeSet",
value: decoded,
};
changed[key] = !equalStringSets(
new Set(decoded),
new Set(original.value)
);
break;
}
case "SelectorString": {
const decoded = map(string, val => {
document.querySelector(val);
return val;
})(value);
mapping[key] = {
type: "SelectorString",
value: decoded,
};
changed[key] = decoded !== original.value;
break;
}
default:
unreachable(original.type, original);
}
} catch (error) {
errors[key] = error.message;