@tamer4lynx/tamer-icons 0.0.1

package/android/src/main/kotlin/com/nanofuxion/tamericons/IconCodepoints.kt

@@ -0,0 +1,60 @@
+package com.nanofuxion.tamericons
+
+import java.io.BufferedReader
+import java.io.InputStreamReader
+
+object IconCodepoints {
+
+    val FONTAWESOME: Map<String, Char> = mapOf(
+        "search" to '\uf002',
+        "home" to '\uf015',
+        "bars" to '\uf0c9',
+        "arrow-left" to '\uf060',
+        "xmark" to '\uf00d',
+        "close" to '\uf00d',
+        "plus" to '\uf067',
+        "minus" to '\uf068',
+        "cog" to '\uf013',
+        "user" to '\uf007',
+        "heart" to '\uf004',
+        "share" to '\uf064',
+        "trash" to '\uf1f8',
+        "pen" to '\uf304',
+        "check" to '\uf00c',
+        "info" to '\uf129',
+        "exclamation-triangle" to '\uf071',
+        "circle-xmark" to '\uf057',
+    )
+
+    @Volatile
+    private var materialCache: Map<String, Int>? = null
+
+    fun getMaterial(assets: android.content.res.AssetManager): Map<String, Int> {
+        return materialCache ?: synchronized(this) {
+            materialCache ?: loadMaterialFromAssets(assets).also { materialCache = it }
+        }
+    }
+
+    private fun loadMaterialFromAssets(assets: android.content.res.AssetManager): Map<String, Int> {
+        return try {
+            assets.open("fonts/material-codepoints.txt").use { stream ->
+                BufferedReader(InputStreamReader(stream)).use { reader ->
+                    buildMap {
+                        reader.lineSequence().forEach { line ->
+                            val space = line.indexOf(' ')
+                            if (space > 0) {
+                                val name = line.substring(0, space)
+                                val hex = line.substring(space + 1).trim()
+                                if (hex.all { it in '0'..'9' || it in 'a'..'f' || it in 'A'..'F' }) {
+                                    put(name, hex.toInt(16))
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            emptyMap()
+        }
+    }
+}

package/android/src/main/kotlin/com/nanofuxion/tamericons/IconDrawable.kt

@@ -0,0 +1,92 @@
+package com.nanofuxion.tamericons
+
+import android.content.res.ColorStateList
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.graphics.drawable.Drawable
+import android.graphics.Typeface
+
+/**
+ * Drawable that renders a single icon font character, scaled and centered in bounds.
+ * Color handling follows Android-Iconics: color is stored in a ColorStateList and
+ * applied to the paint in draw() so the icon color is not overridden by framework tint.
+ */
+class IconDrawable(
+    private val typeface: Typeface,
+    private val codepoint: Int,
+    color: Int,
+    private val sizePx: Int
+) : Drawable() {
+
+    private var colorList: ColorStateList = ColorStateList.valueOf(color)
+
+    private val paint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        style = Paint.Style.FILL
+        textAlign = Paint.Align.LEFT
+        this.typeface = this@IconDrawable.typeface
+    }
+
+    private val path = Path()
+    private val pathBounds = RectF()
+
+    private val charSequence: CharSequence
+        get() = if (codepoint <= 0xFFFF) Character.toString(codepoint.toChar())
+        else String(Character.toChars(codepoint))
+
+    init {
+        setBounds(0, 0, sizePx, sizePx)
+    }
+
+    fun setColor(value: Int) {
+        if (colorList.defaultColor != value) {
+            colorList = ColorStateList.valueOf(value)
+            invalidateSelf()
+        }
+    }
+
+    override fun draw(canvas: Canvas) {
+        if (codepoint == 0) return
+        paint.color = colorList.getColorForState(state, colorList.defaultColor)
+        paint.colorFilter = null
+        val b = bounds
+        if (b.width() <= 0 || b.height() <= 0) return
+
+        val seq = charSequence
+        path.reset()
+        var textSize = b.height().toFloat()
+        paint.textSize = textSize
+        paint.getTextPath(seq.toString(), 0, seq.length, 0f, 0f, path)
+        path.computeBounds(pathBounds, true)
+
+        val pathW = pathBounds.width().coerceAtLeast(1f)
+        val pathH = pathBounds.height().coerceAtLeast(1f)
+        val scaleW = b.width() / pathW
+        val scaleH = b.height() / pathH
+        val scale = minOf(scaleW, scaleH).coerceAtMost(1f)
+        textSize *= scale
+        paint.textSize = textSize
+        path.reset()
+        paint.getTextPath(seq.toString(), 0, seq.length, 0f, 0f, path)
+        path.computeBounds(pathBounds, true)
+
+        val offsetX = b.left + (b.width() - pathBounds.width()) / 2 - pathBounds.left
+        val offsetY = b.top + (b.height() - pathBounds.height()) / 2 - pathBounds.top
+        path.offset(offsetX, offsetY)
+        canvas.drawPath(path, paint)
+    }
+
+    override fun setAlpha(alpha: Int) {
+        paint.alpha = alpha
+    }
+
+    override fun setColorFilter(colorFilter: android.graphics.ColorFilter?) {
+    }
+
+    @Deprecated("Deprecated in Java")
+    override fun getOpacity(): Int = android.graphics.PixelFormat.TRANSLUCENT
+
+    override fun getIntrinsicWidth(): Int = sizePx
+    override fun getIntrinsicHeight(): Int = sizePx
+}

package/android/src/main/kotlin/com/nanofuxion/tamericons/IconElement.kt

@@ -0,0 +1,162 @@
+package com.nanofuxion.tamericons
+
+import android.content.Context
+import android.graphics.Color
+import android.graphics.Typeface
+import android.util.Log
+import android.util.TypedValue
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import android.widget.ImageView
+import com.lynx.react.bridge.Dynamic
+import com.lynx.react.bridge.ReadableType
+import com.lynx.tasm.behavior.LynxContext
+import com.lynx.tasm.behavior.LynxProp
+import com.lynx.tasm.behavior.ui.LynxUI
+
+class IconElement(context: LynxContext) : LynxUI<FrameLayout>(context) {
+
+    private var iconSet = "material"
+    private var iconName = ""
+    private var iconColor = Color.BLACK
+    private var iconSizeSp = 24f
+
+    private lateinit var imageView: ImageView
+
+    override fun createView(context: Context): FrameLayout {
+        Log.d("TamerIcon", "createView called")
+        val container = FrameLayout(context).apply {
+            clipChildren = false
+            clipToPadding = false
+        }
+        imageView = ImageView(context).apply {
+            scaleType = ImageView.ScaleType.CENTER_INSIDE
+            setColorFilter(null)
+            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
+                imageTintList = null
+            }
+        }
+        container.addView(imageView, FrameLayout.LayoutParams(
+            ViewGroup.LayoutParams.MATCH_PARENT,
+            ViewGroup.LayoutParams.MATCH_PARENT
+        ))
+        return container
+    }
+
+    private fun getTypeface(): Typeface? {
+        return try {
+            val assetPath = when (iconSet) {
+                "fontawesome", "fa" -> "fonts/fa-solid-900.ttf"
+                else -> "fonts/MaterialSymbolsOutlined.ttf"
+            }
+            Typeface.createFromAsset(lynxContext.context.assets, assetPath)
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    private fun resolveCodepoint(): Int {
+        return when (iconSet) {
+            "fontawesome", "fa" -> {
+                val key = iconName.removePrefix("fa-").replace("_", "-")
+                (IconCodepoints.FONTAWESOME[key] ?: IconCodepoints.FONTAWESOME[iconName])?.code ?: 0
+            }
+            else -> {
+                val map = IconCodepoints.getMaterial(lynxContext.context.assets)
+                map[iconName]
+                    ?: map[iconName.replace("_", "-")]
+                    ?: map[iconName.replace("-", "_")]
+                    ?: 0
+            }
+        }
+    }
+
+    private fun applyIcon() {
+        if (!::imageView.isInitialized) return
+        val typeface = getTypeface()
+        if (typeface == null) {
+            Log.w("TamerIcon", "typeface null for set=$iconSet icon=$iconName")
+            return
+        }
+        val codepoint = resolveCodepoint()
+        if (codepoint == 0) {
+            Log.w("TamerIcon", "codepoint=0 for icon=$iconName set=$iconSet")
+        }
+        val sizePx = TypedValue.applyDimension(
+            TypedValue.COMPLEX_UNIT_SP,
+            iconSizeSp,
+            imageView.context.resources.displayMetrics
+        ).toInt().coerceAtLeast(1)
+        val drawable = IconDrawable(typeface, codepoint, iconColor, sizePx)
+        imageView.setImageDrawable(drawable)
+        imageView.clearColorFilter()
+    }
+
+    @LynxProp(name = "icon")
+    fun setIcon(value: String) {
+        iconName = value
+        applyIcon()
+    }
+
+    @LynxProp(name = "set")
+    fun setIconSet(value: String) {
+        iconSet = value.lowercase()
+        applyIcon()
+    }
+
+    @LynxProp(name = "iconColor")
+    fun setIconColor(value: Dynamic) {
+        applyColorFromDynamic(value)
+    }
+
+    private fun applyColorFromDynamic(value: Dynamic) {
+        if (value.type == ReadableType.Null) return
+        iconColor = when (value.type) {
+            ReadableType.Number -> (value.asDouble().toLong() and 0xFFFFFFFFL).toInt()
+            ReadableType.String -> parseColorString(value.asString())
+            else -> return
+        }
+        if (::imageView.isInitialized) {
+            (imageView.drawable as? IconDrawable)?.setColor(iconColor)
+                ?: applyIcon()
+        }
+    }
+
+    private fun expandHex(hex: String): String =
+        if (hex.length == 3) hex.map { "$it$it" }.joinToString("") else hex
+
+    private fun parseColorString(value: String): Int = try {
+        when {
+            value.startsWith("#") -> Color.parseColor("#${expandHex(value.removePrefix("#"))}")
+            value.startsWith("rgb") -> parseRgb(value)
+            else -> Color.parseColor(value)
+        }
+    } catch (_: Exception) {
+        Color.BLACK
+    }
+
+    @LynxProp(name = "size")
+    fun setSize(value: Double) {
+        iconSizeSp = value.toFloat()
+        applyIcon()
+    }
+
+    private fun parseRgb(value: String): Int {
+        val parts = value.replace(Regex("[^0-9,.]"), "").split(",")
+        val nums = parts.map { it.toFloatOrNull() ?: 0f }
+        return when (nums.size) {
+            3 -> Color.rgb(nums[0].toInt(), nums[1].toInt(), nums[2].toInt())
+            4 -> Color.argb((nums[3] * 255).toInt(), nums[0].toInt(), nums[1].toInt(), nums[2].toInt())
+            else -> Color.BLACK
+        }
+    }
+
+    override fun onLayoutUpdated() {
+        super.onLayoutUpdated()
+        val paddingTop = mPaddingTop + mBorderTopWidth
+        val paddingBottom = mPaddingBottom + mBorderBottomWidth
+        val paddingLeft = mPaddingLeft + mBorderLeftWidth
+        val paddingRight = mPaddingRight + mBorderRightWidth
+        mView.setPadding(paddingLeft, paddingTop, paddingRight, paddingBottom)
+    }
+}

package/dist/fontawesome-codepoints.d.ts

@@ -0,0 +1,2 @@
+export declare const FONTAWESOME_CODEPOINTS: Record<string, string>;
+//# sourceMappingURL=fontawesome-codepoints.d.ts.map

package/dist/fontawesome-codepoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fontawesome-codepoints.d.ts","sourceRoot":"","sources":["../src/fontawesome-codepoints.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAmBzD,CAAA"}

package/dist/fontawesome-codepoints.js

@@ -0,0 +1,20 @@
+export const FONTAWESOME_CODEPOINTS = {
+    search: '\uf002',
+    home: '\uf015',
+    bars: '\uf0c9',
+    'arrow-left': '\uf060',
+    xmark: '\uf00d',
+    close: '\uf00d',
+    plus: '\uf067',
+    minus: '\uf068',
+    cog: '\uf013',
+    user: '\uf007',
+    heart: '\uf004',
+    share: '\uf064',
+    trash: '\uf1f8',
+    pen: '\uf304',
+    check: '\uf00c',
+    info: '\uf129',
+    'exclamation-triangle': '\uf071',
+    'circle-xmark': '\uf057',
+};

package/dist/fonts.css

@@ -0,0 +1,13 @@
+@font-face {
+  font-family: 'Material Symbols Outlined';
+  src: url('../fonts/MaterialSymbolsOutlined.ttf') format('truetype');
+  font-weight: 100 700;
+  font-style: normal;
+}
+
+@font-face {
+  font-family: 'Font Awesome 6 Free';
+  src: url('../fonts/fa-solid-900.ttf') format('truetype');
+  font-weight: 900;
+  font-style: normal;
+}

package/dist/fonts.d.ts

@@ -0,0 +1,7 @@
+export declare const MATERIAL_SYMBOLS_URL = "https://github.com/google/material-design-icons/raw/refs/heads/master/variablefont/MaterialSymbolsOutlined%5BFILL%2CGRAD%2Copsz%2Cwght%5D.ttf";
+export declare const MATERIAL_SYMBOLS_FAMILY = "Material Symbols Outlined";
+export declare const MATERIAL_ICONS_URL = "https://github.com/google/material-design-icons/raw/refs/heads/master/variablefont/MaterialSymbolsOutlined%5BFILL%2CGRAD%2Copsz%2Cwght%5D.ttf";
+export declare const MATERIAL_ICONS_FAMILY = "Material Symbols Outlined";
+export declare const FONTAWESOME_SOLID_URL = "https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.1/webfonts/fa-solid-900.ttf";
+export declare const FONTAWESOME_SOLID_FAMILY = "Font Awesome 6 Free";
+//# sourceMappingURL=fonts.d.ts.map

package/dist/fonts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fonts.d.ts","sourceRoot":"","sources":["../src/fonts.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,kJACgH,CAAA;AACjJ,eAAO,MAAM,uBAAuB,8BAA8B,CAAA;AAElE,eAAO,MAAM,kBAAkB,kJAAuB,CAAA;AACtD,eAAO,MAAM,qBAAqB,8BAA0B,CAAA;AAE5D,eAAO,MAAM,qBAAqB,wFACqD,CAAA;AACvF,eAAO,MAAM,wBAAwB,wBAAwB,CAAA"}

package/dist/fonts.js

@@ -0,0 +1,6 @@
+export const MATERIAL_SYMBOLS_URL = 'https://github.com/google/material-design-icons/raw/refs/heads/master/variablefont/MaterialSymbolsOutlined%5BFILL%2CGRAD%2Copsz%2Cwght%5D.ttf';
+export const MATERIAL_SYMBOLS_FAMILY = 'Material Symbols Outlined';
+export const MATERIAL_ICONS_URL = MATERIAL_SYMBOLS_URL;
+export const MATERIAL_ICONS_FAMILY = MATERIAL_SYMBOLS_FAMILY;
+export const FONTAWESOME_SOLID_URL = 'https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.1/webfonts/fa-solid-900.ttf';
+export const FONTAWESOME_SOLID_FAMILY = 'Font Awesome 6 Free';

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import type { ViewProps } from '@lynx-js/types';
+export { MATERIAL_ICONS_URL, FONTAWESOME_SOLID_URL } from './fonts';
+export { MATERIAL_CODEPOINTS } from './material-codepoints';
+export interface TfontProps {
+    src: string;
+    family: string;
+    weight?: number;
+    style?: ViewProps['style'];
+}
+export type IconSet = 'material' | 'fontawesome' | 'fa';
+export interface IconProps extends ViewProps {
+    name: string;
+    set?: IconSet;
+    size?: number;
+    color?: string;
+}
+export declare function Tfont(props: TfontProps): null;
+export declare function Icon(props: IconProps): any;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE/C,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAE3D,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAA;CAC3B;AAED,MAAM,MAAM,OAAO,GAAG,UAAU,GAAG,aAAa,GAAG,IAAI,CAAA;AAEvD,MAAM,WAAW,SAAU,SAAQ,SAAS;IAC1C,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAID,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,QAGtC;AAED,wBAAgB,IAAI,CAAC,KAAK,EAAE,SAAS,OAgBpC"}

package/dist/index.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "@lynx-js/react/jsx-runtime";
+export { MATERIAL_ICONS_URL, FONTAWESOME_SOLID_URL } from './fonts';
+export { MATERIAL_CODEPOINTS } from './material-codepoints';
+const px = (value) => `${Math.round(value)}px`;
+export function Tfont(props) {
+    void props;
+    return null;
+}
+export function Icon(props) {
+    const { name, set = 'material', size = 24, color, style, ...rest } = props;
+    return (_jsx("icon", { icon: name, set: set, size: size, iconColor: color, style: {
+            width: px(size),
+            height: px(size),
+            ...style,
+        }, ...rest }));
+}

package/dist/material-codepoints.d.ts

@@ -0,0 +1,2 @@
+export declare const MATERIAL_CODEPOINTS: Record<string, string>;
+//# sourceMappingURL=material-codepoints.d.ts.map

package/dist/material-codepoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"material-codepoints.d.ts","sourceRoot":"","sources":["../src/material-codepoints.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAuDtD,CAAA"}

package/dist/material-codepoints.js

@@ -0,0 +1,56 @@
+export const MATERIAL_CODEPOINTS = {
+    // Navigation
+    home: '\ue9b2',
+    menu: '\ue5d2',
+    arrow_back: '\ue5c4',
+    arrow_back_ios: '\ue5e0',
+    arrow_forward: '\ue5c8',
+    chevron_left: '\ue5cb',
+    chevron_right: '\ue5cc',
+    expand_less: '\ue5ce',
+    expand_more: '\ue5cf',
+    close: '\ue5cd',
+    more_vert: '\ue5d4',
+    more_horiz: '\ue5d3',
+    // Actions
+    add: '\ue145',
+    check: '\ue5ca',
+    delete: '\ue92e',
+    edit: '\uf097',
+    search: '\ue8b6',
+    share: '\ue80d',
+    send: '\ue163',
+    download: '\uf090',
+    upload: '\uf09b',
+    refresh: '\ue5d5',
+    // Status / Info
+    info: '\ue88e',
+    warning: '\uf083',
+    error: '\uf8b6',
+    help: '\ue887',
+    // Social / Profile
+    person: '\uf0d3',
+    people: '\uea21',
+    favorite: '\ue87e',
+    star: '\uf8d7',
+    // Content
+    settings: '\ue8b8',
+    notifications: '\ue7f4',
+    link: '\ue250',
+    history: '\ue8b3',
+    // Network / Connectivity
+    wifi: '\ue63e',
+    wifi_find: '\ueb31',
+    bluetooth: '\ue1a7',
+    // Misc
+    lock: '\ue897',
+    lock_open: '\ue898',
+    visibility: '\ue8f4',
+    visibility_off: '\ue8f5',
+    calendar_today: '\ue935',
+    schedule: '\ue8b5',
+    location_on: '\ue0c8',
+    phone: '\ue0cd',
+    email: '\ue0be',
+    camera: '\ue3af',
+};

package/dist/plugin.d.ts

@@ -0,0 +1,3 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+export declare function pluginTamerIcons(): RsbuildPlugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAqClD,wBAAgB,gBAAgB,IAAI,aAAa,CAUhD"}

package/dist/plugin.js

@@ -0,0 +1,43 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { MATERIAL_ICONS_URL, FONTAWESOME_SOLID_URL } from './fonts';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+async function fetchToBuffer(url) {
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`Failed to fetch ${url}: ${res.status}`);
+    const arr = await res.arrayBuffer();
+    return Buffer.from(arr);
+}
+async function ensureFonts(pkgDir) {
+    const fontsDir = path.join(pkgDir, 'fonts');
+    fs.mkdirSync(fontsDir, { recursive: true });
+    const materialPath = path.join(fontsDir, 'MaterialSymbolsOutlined.ttf');
+    const faPath = path.join(fontsDir, 'fa-solid-900.ttf');
+    const cacheDir = path.join(pkgDir, '.cache', 'tamer-icons');
+    fs.mkdirSync(cacheDir, { recursive: true });
+    const materialCache = path.join(cacheDir, 'MaterialSymbolsOutlined.ttf');
+    const faCache = path.join(cacheDir, 'fa-solid-900.ttf');
+    if (!fs.existsSync(materialCache)) {
+        const buf = await fetchToBuffer(MATERIAL_ICONS_URL);
+        fs.writeFileSync(materialCache, buf);
+    }
+    fs.copyFileSync(materialCache, materialPath);
+    if (!fs.existsSync(faCache)) {
+        const buf = await fetchToBuffer(FONTAWESOME_SOLID_URL);
+        fs.writeFileSync(faCache, buf);
+    }
+    fs.copyFileSync(faCache, faPath);
+}
+export function pluginTamerIcons() {
+    return {
+        name: 'tamer-icons',
+        async setup(api) {
+            const pkgDir = path.resolve(__dirname, '..');
+            if (fs.existsSync(path.join(pkgDir, 'package.json'))) {
+                await ensureFonts(pkgDir);
+            }
+        },
+    };
+}

package/dist/tamer.config.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    pluginTamerIcons: import("@rsbuild/core").RsbuildPlugin;
+};
+export default _default;
+//# sourceMappingURL=tamer.config.d.ts.map

package/dist/tamer.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tamer.config.d.ts","sourceRoot":"","sources":["../src/tamer.config.ts"],"names":[],"mappings":";;;AAEA,wBAEC"}

package/dist/tamer.config.js

@@ -0,0 +1,4 @@
+import { pluginTamerIcons } from './plugin';
+export default {
+    pluginTamerIcons: pluginTamerIcons(),
+};

package/ios/tamericons/tamericons/Classes/TamerIconElement.h

@@ -0,0 +1,10 @@
+#import <Lynx/LynxUI.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface TamerIconElement : LynxUI<UIView *>
++ (void)registerFonts;
+@end
+
+NS_ASSUME_NONNULL_END