@ton/appkit 0.0.1-alpha.1 → 0.0.1

package/src/utils/jetton/jetton-info.ts

@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) TonTech.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import { formatUnits } from '@ton/walletkit';
+import type { Jetton } from '@ton/walletkit';
+
+export const getJettonsSymbol = (jetton: Jetton): string | undefined => {
+    if (!jetton?.info?.symbol) {
+        return;
+    }
+
+    return jetton.info.symbol;
+};
+
+export const getJettonsName = (jetton: Jetton): string | undefined => {
+    if (!jetton?.info?.name && !jetton?.info?.symbol) {
+        return;
+    }
+
+    return jetton.info?.name || jetton.info?.symbol || '';
+};
+
+export const getJettonsImage = (jetton: Jetton): string | undefined => {
+    if (!jetton?.info?.image) {
+        return;
+    }
+
+    return (
+        jetton.info.image.url ||
+        (jetton.info.image.data ? atob(jetton.info.image.data) : undefined) ||
+        jetton.info.image.mediumUrl ||
+        jetton.info.image.largeUrl ||
+        jetton.info.image.smallUrl ||
+        ''
+    );
+};
+
+export const getFormattedJettonInfo = (jetton: Jetton) => {
+    const jettonName = getJettonsName(jetton);
+    const jettonSymbol = getJettonsSymbol(jetton);
+    const jettonImage = getJettonsImage(jetton);
+    const jettonBalance = jetton.balance || '0';
+    const jettonDecimals = jetton.decimalsNumber;
+    const formattedBalance = jettonDecimals ? formatUnits(jettonBalance, jettonDecimals) : '0';
+
+    return {
+        address: jetton.address,
+        walletAddress: jetton.walletAddress,
+        description: jetton.info?.description,
+        name: jettonName,
+        symbol: jettonSymbol,
+        image: jettonImage,
+        imageData: jetton.info?.image?.data,
+        balance: formattedBalance,
+        decimals: jettonDecimals,
+    };
+};

package/src/utils/nft/nft-info.ts

@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) TonTech.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import type { NFT } from '@ton/walletkit';
+
+import { middleEllipsis } from '../string/middle-ellipsis';
+
+export const getNftImage = (nft: NFT): string | null => {
+    if (!nft.info?.image) return null;
+
+    const { url, data, mediumUrl, smallUrl, largeUrl } = nft.info.image;
+
+    if (url) return url;
+    if (mediumUrl) return mediumUrl;
+    if (largeUrl) return largeUrl;
+    if (smallUrl) return smallUrl;
+
+    if (data) {
+        try {
+            return atob(data);
+        } catch {
+            return null;
+        }
+    }
+
+    return null;
+};
+
+export const getNftName = (nft: NFT): string => {
+    if (nft.info?.name) return nft.info.name;
+    if (nft.index) return `NFT #${nft.index}`;
+    return middleEllipsis(nft.address);
+};
+
+export const getCollectionName = (nft: NFT): string => {
+    return nft.collection?.name || 'Unknown Collection';
+};
+
+export const getNftDescription = (nft: NFT): string | null => {
+    return nft.info?.description || null;
+};
+
+export const getFormattedNftInfo = (nft: NFT) => {
+    const nftName = getNftName(nft);
+    const nftImage = getNftImage(nft);
+    const collectionName = getCollectionName(nft);
+    const nftDescription = getNftDescription(nft);
+
+    return {
+        address: nft.address,
+        collectionName,
+        name: nftName,
+        image: nftImage,
+        description: nftDescription,
+        isOnSale: nft.isOnSale,
+    };
+};

package/src/utils/object/map-values.test.ts

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) TonTech.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import { mapValues } from './map-values';
+
+describe('mapValues', () => {
+    it('should map values of object', () => {
+        const obj = { a: 1, b: 2 };
+        const result = mapValues(obj, (value) => value * 2);
+        expect(result).toEqual({ a: 2, b: 4 });
+    });
+
+    it('should provide key in callback', () => {
+        const obj = { a: 1, b: 2 };
+        const result = mapValues(obj, (value, key) => `${key}:${value}`);
+        expect(result).toEqual({ a: 'a:1', b: 'b:2' });
+    });
+
+    it('should handle empty object', () => {
+        const obj = {};
+        const result = mapValues(obj, (value) => value);
+        expect(result).toEqual({});
+    });
+
+    it('should not mutate original object', () => {
+        const obj = { a: 1 };
+        mapValues(obj, (val) => val + 1);
+        expect(obj).toEqual({ a: 1 });
+    });
+});

package/src/utils/object/map-values.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) TonTech.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+export function mapValues<T extends object, K extends keyof T, V>(
+    object: T,
+    getNewValue: (value: T[K], key: K, obj: T) => V,
+): Record<K, V> {
+    const result = {} as Record<K, V>;
+    const keys = Object.keys(object) as K[];
+
+    for (const key of keys) {
+        const value = object[key];
+
+        result[key] = getNewValue(value, key, object);
+    }
+
+    return result;
+}

package/src/utils/predicate/is-string.test.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) TonTech.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import { isString } from './is-string';
+
+describe('isString', () => {
+    it('should return true for strings', () => {
+        expect(isString('hello')).toBe(true);
+        expect(isString('')).toBe(true);
+        expect(isString(String('hello'))).toBe(true);
+    });
+
+    it('should return false for non-strings', () => {
+        expect(isString(123)).toBe(false);
+        expect(isString(true)).toBe(false);
+        expect(isString({})).toBe(false);
+        expect(isString([])).toBe(false);
+        expect(isString(null)).toBe(false);
+        expect(isString(undefined)).toBe(false);
+        expect(isString(Symbol('sym'))).toBe(false);
+    });
+});

package/src/utils/predicate/is-string.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) TonTech.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+export function isString(value: unknown): value is string {
+    return typeof value === 'string';
+}

package/src/utils/promise/cancel-promise.test.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) TonTech.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import { cancelPromise } from './cancel-promise';
+
+describe('cancelPromise', () => {
+    it('should resolve if promise resolves before timeout', async () => {
+        const promise = new Promise((resolve) => setTimeout(() => resolve('success'), 10));
+        await expect(cancelPromise(promise, 50)).resolves.toBe('success');
+    });
+
+    it('should reject if promise times out', async () => {
+        const promise = new Promise((resolve) => setTimeout(() => resolve('success'), 50));
+        await expect(cancelPromise(promise, 10)).rejects.toThrow('Execution timed out - 10ms');
+    });
+
+    it('should propagate rejection from original promise', async () => {
+        const promise = new Promise((_, reject) => setTimeout(() => reject(new Error('failure')), 10));
+        await expect(cancelPromise(promise, 50)).rejects.toThrow('failure');
+    });
+});

package/src/utils/promise/cancel-promise.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) TonTech.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+export const cancelPromise = <T>(promise: T, timeoutMs: number): Promise<T> => {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => {
+            setTimeout(() => reject(new Error(`Execution timed out - ${timeoutMs}ms`)), timeoutMs);
+        }) as T,
+    ]);
+};

package/src/utils/promise/sleep.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) TonTech.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+export const sleep = (ms: number): Promise<void> => {
+    return new Promise((res) => {
+        setTimeout(res, ms);
+    });
+};

package/src/utils/query/filter-query-options.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) TonTech.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import type { Compute } from '../../types/utils';
+
+export function filterQueryOptions<type extends object>(options: type): Compute<Omit<type, 'query'>> {
+    const { query, ...rest } = options as unknown as { query: unknown };
+
+    return rest as Compute<Omit<type, 'query'>>;
+}

package/src/utils/string/middle-ellipsis.test.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) TonTech.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import { middleEllipsis } from './middle-ellipsis';
+
+describe('middleEllipsis', () => {
+    it('should truncate string in the middle', () => {
+        const str = '1234567890abcdef';
+        const result = middleEllipsis(str, 4, 4);
+        expect(result).toBe('1234...cdef');
+    });
+
+    it('should use default values (5, 5)', () => {
+        const str = '123456789012345';
+        const result = middleEllipsis(str);
+        expect(result).toBe('12345...12345');
+    });
+
+    it('should handle short strings gracefully', () => {
+        expect(middleEllipsis('abc')).toBe('abc');
+    });
+
+    it('should handle uneven split', () => {
+        expect(middleEllipsis('abcdefgh', 2, 3)).toBe('ab...fgh');
+    });
+});

package/src/utils/string/middle-ellipsis.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) TonTech.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+export const middleEllipsis = (value: string, left = 5, right = 5) => {
+    if (value.length <= left + right) {
+        return value;
+    }
+
+    return `${value.slice(0, left)}...${value.slice(-right)}`;
+};

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+    "compilerOptions": {
+        "target": "es2020",
+        "outDir": "dist",
+        "module": "ESNext",
+        "baseUrl": "./",
+        "moduleResolution": "bundler",
+        "declaration": true,
+        "declarationDir": "dist",
+        "esModuleInterop": true,
+        "forceConsistentCasingInFileNames": true,
+        "strict": true,
+        "noImplicitAny": true,
+        "skipLibCheck": true,
+        "declarationMap": true
+    },
+    "exclude": [
+        "**/*.spec.ts",
+        "**/*.fixture.ts",
+        "**/*.config.ts",
+        "node_modules",
+        "coverage",
+        ".stryker-tmp",
+        "dist"
+    ],
+    "include": [
+        "src/**/*"
+    ]
+}

package/tsup.config.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) TonTech.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import { defineConfig } from 'tsup';
+
+import * as packageJson from './package.json';
+
+export default defineConfig({
+    entry: ['src/**/*.ts', '!src/**/*.test.ts', '!src/**/__tests__/**'],
+    format: ['esm', 'cjs'],
+    bundle: false,
+    dts: false,
+    clean: true,
+    outDir: 'dist',
+    platform: 'browser',
+    target: 'es2020',
+    sourcemap: true,
+    minify: false,
+    define: {
+        'process.env': '{}',
+        TON_APPKIT_VERSION: JSON.stringify(packageJson.version),
+    },
+});

package/vitest.config.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) TonTech.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import { defineConfig } from 'vitest/config';
+import type { ViteUserConfig } from 'vitest/config';
+
+const config: ViteUserConfig = defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+        include: ['src/**/*.spec.ts', 'src/**/*.test.ts'],
+        exclude: ['node_modules', 'dist', 'build', 'coverage', '**/*.config.ts', '**/*.config.js'],
+    },
+});
+
+export default config;

package/index.js

@@ -1 +0,0 @@
-// @ton/appkit — placeholder, package under development