@nativescript/core
Version:
A JavaScript library providing an easy to use api for interacting with iOS and Android platform APIs.
169 lines • 6.98 kB
JavaScript
import { Font as FontBase, parseFontFamily, genericFontFamilies, FontWeight, FontVariationSettings } from './font-common';
import { Trace } from '../../trace';
import { SDK_VERSION } from '../../utils/constants';
import * as fs from '../../file-system';
import { ad } from '../../utils';
export * from './font-common';
const FONTS_BASE_PATH = '/fonts/';
const typefaceCache = new Map();
let appAssets;
export class Font extends FontBase {
constructor(family, size, style, weight, fontVariationSettings) {
super(family, size, style, weight, 1, fontVariationSettings);
}
withFontFamily(family) {
return new Font(family, this.fontSize, this.fontStyle, this.fontWeight, this.fontVariationSettings);
}
withFontStyle(style) {
return new Font(this.fontFamily, this.fontSize, style, this.fontWeight, this.fontVariationSettings);
}
withFontWeight(weight) {
return new Font(this.fontFamily, this.fontSize, this.fontStyle, weight, this.fontVariationSettings);
}
withFontSize(size) {
return new Font(this.fontFamily, size, this.fontStyle, this.fontWeight, this.fontVariationSettings);
}
withFontScale(scale) {
return new Font(this.fontFamily, this.fontSize, this.fontStyle, this.fontWeight, this.fontVariationSettings);
}
withFontVariationSettings(variationSettings) {
return new Font(this.fontFamily, this.fontSize, this.fontStyle, this.fontWeight, variationSettings);
}
getAndroidTypeface() {
if (!this._typeface) {
this._typeface = createTypeface(this);
}
return this._typeface;
}
getUIFont(defaultFont) {
return undefined;
}
}
Font.default = new Font(undefined, undefined);
function computeFontCacheKey(fontFamily, font) {
const sep = ':';
return [fontFamily, String(FontVariationSettings.toString(font.fontVariationSettings)).replace(/'/g, '').replace(/[\s,]/g, '_')].join(sep);
}
function loadFontFromFile(fontFamily, font) {
const cacheKey = SDK_VERSION >= 26 ? computeFontCacheKey(fontFamily, font) : fontFamily;
appAssets = appAssets || ad.getApplicationContext().getAssets();
if (!appAssets) {
return null;
}
let result = typefaceCache.get(cacheKey);
// Check for undefined explicitly as null mean we tried to load the font, but failed.
if (result === undefined) {
result = null;
let fontAssetPath;
const basePath = fs.path.join(fs.knownFolders.currentApp().path, 'fonts', fontFamily);
if (fs.File.exists(basePath + '.ttf')) {
fontAssetPath = FONTS_BASE_PATH + fontFamily + '.ttf';
}
else if (fs.File.exists(basePath + '.otf')) {
fontAssetPath = FONTS_BASE_PATH + fontFamily + '.otf';
}
else if (Trace.isEnabled()) {
Trace.write('Could not find font file for ' + fontFamily, Trace.categories.Error, Trace.messageType.error);
}
if (fontAssetPath) {
try {
fontAssetPath = fs.path.join(fs.knownFolders.currentApp().path, fontAssetPath);
if (SDK_VERSION >= 26) {
const builder = new android.graphics.Typeface.Builder(fontAssetPath);
if (builder) {
if (font.fontVariationSettings !== undefined) {
builder.setFontVariationSettings(font.fontVariationSettings?.length ? FontVariationSettings.toString(font.fontVariationSettings) : '');
}
result = builder.build();
}
else {
result = android.graphics.Typeface.createFromFile(fontAssetPath);
if (Trace.isEnabled()) {
Trace.write('Could not create builder for ' + fontFamily, Trace.categories.Error, Trace.messageType.error);
}
}
}
else {
result = android.graphics.Typeface.createFromFile(fontAssetPath);
}
}
catch (e) {
if (Trace.isEnabled()) {
Trace.write('Error loading font asset: ' + fontAssetPath, Trace.categories.Error, Trace.messageType.error);
}
}
}
typefaceCache.set(cacheKey, result);
}
return result;
}
function createTypeface(font) {
let fontStyle = 0;
if (font.isBold) {
fontStyle |= android.graphics.Typeface.BOLD;
}
if (font.isItalic) {
fontStyle |= android.graphics.Typeface.ITALIC;
}
//http://stackoverflow.com/questions/19691530/valid-values-for-androidfontfamily-and-what-they-map-to
const fontFamilies = parseFontFamily(font.fontFamily);
let result = null;
for (const fontFamily of fontFamilies) {
switch (fontFamily.toLowerCase()) {
case genericFontFamilies.serif:
result = android.graphics.Typeface.create('serif' + getFontWeightSuffix(font.fontWeight), fontStyle);
break;
case genericFontFamilies.sansSerif:
case genericFontFamilies.system:
result = android.graphics.Typeface.create('sans-serif' + getFontWeightSuffix(font.fontWeight), fontStyle);
break;
case genericFontFamilies.monospace:
result = android.graphics.Typeface.create('monospace' + getFontWeightSuffix(font.fontWeight), fontStyle);
break;
default: {
result = loadFontFromFile(fontFamily, font);
if (result && fontStyle) {
result = android.graphics.Typeface.create(result, fontStyle);
}
break;
}
}
if (result) {
// Found the font!
break;
}
}
if (!result) {
result = android.graphics.Typeface.create('sans-serif' + getFontWeightSuffix(font.fontWeight), fontStyle);
}
return result;
}
function getFontWeightSuffix(fontWeight) {
if (typeof fontWeight === 'number') {
fontWeight = (fontWeight + '');
}
switch (fontWeight) {
case FontWeight.THIN:
return SDK_VERSION >= 16 ? '-thin' : '';
case FontWeight.EXTRA_LIGHT:
case FontWeight.LIGHT:
return SDK_VERSION >= 16 ? '-light' : '';
case FontWeight.NORMAL:
case '400':
case undefined:
case null:
return '';
case FontWeight.MEDIUM:
case FontWeight.SEMI_BOLD:
return SDK_VERSION >= 21 ? '-medium' : '';
case FontWeight.BOLD:
case '700':
case FontWeight.EXTRA_BOLD:
return '';
case FontWeight.BLACK:
return SDK_VERSION >= 21 ? '-black' : '';
default:
throw new Error(`Invalid font weight: "${fontWeight}"`);
}
}
//# sourceMappingURL=font.android.js.map