@mobileaction/action-kit 1.54.5 → 1.55.0-beta.0

package/dist/index.d.ts

@@ -128,5 +128,6 @@ export { default as MaUpload } from './components/upload/index.vue';
 export * from './components/upload/types';
 export { default as MaWatchlistButton } from './components/watchlist-button/index.vue';
 export { useActionKitConfig } from './composables/config';
+export { maCountry } from './lib/country/country';
 export { ActionKitConfig } from './services/config';
 export { SelectOptGroup as MaSelectOptGroup } from 'ant-design-vue';

package/dist/lib/country/country.d.ts

@@ -0,0 +1,126 @@
+interface Language {
+    code: string;
+    name: string;
+    flag: string;
+}
+interface CountryData {
+    name: string;
+    alpha2: string;
+    alpha3: string;
+    officialLanguageCode: string;
+    flag: string;
+    countryCallingCodes: string[];
+    currencies: string[];
+    languages: Language[];
+}
+interface CountryOption {
+    name: string;
+    code: string;
+    flag: string;
+}
+type SortType = 'asc' | 'desc';
+type CountryCodeArray = CountryData['alpha2'][];
+interface SortOptions {
+    topCountryCodes?: CountryCodeArray;
+    sortBy?: SortType;
+    countries?: CountryCodeArray | CountryData[];
+}
+interface CountryOptionsParams extends SortOptions {
+    countries: CountryCodeArray | CountryData[];
+}
+declare class Country {
+    private static readonly countriesData;
+    /**
+     * Find a country by its country code (alpha2 or alpha3)
+     * @param {string} code - Country code (alpha2 or alpha3)
+     * @returns {CountryData | undefined} Immutable country object
+     */
+    findCountryByCountryCode(code: string): CountryData | undefined;
+    /**
+     * Find countries by a list of country codes
+     * @param {string[]} countryCodeList - Array of country codes
+     * @returns {CountryData[]} Array of immutable country objects
+     */
+    findCountriesByCountryCodeList(countryCodeList: string[]): CountryData[];
+    /**
+     * Generic method to get a country property by country code
+     * @param {K} property - Property name to retrieve
+     * @param {string} code - Country code
+     * @returns {CountryData[K] | undefined} Property value
+     */
+    getCountryBy<K extends keyof CountryData>(property: K, code: string): CountryData[K] | undefined;
+    /**
+     * Get country name by country code
+     * @param {string} code - Country code
+     * @returns {string} Country name or code if not found
+     */
+    getCountryNameByCountryCode(code: string): string;
+    /**
+     * Find a country by any language code (not just official)
+     * @param {string} languageCode - Language code
+     * @returns {CountryData | undefined} Immutable country object
+     */
+    findCountryByLanguageCode(languageCode: string): CountryData | undefined;
+    /**
+     * Get country code by language code
+     * @param {string} languageCode - Language code
+     * @returns {string | undefined} Alpha2 country code
+     */
+    getCountryCodeByLanguageCode(languageCode: string): string | undefined;
+    /**
+     * Get all countries
+     * @returns {CountryData[]} Array of immutable country objects
+     */
+    getAllCountryList(): CountryData[];
+    /**
+     * Get sorted countries with optional top countries
+     * @param {SortOptions} options - Sorting options
+     * @returns {CountryData[]} Sorted array of country objects
+     */
+    getSortedCountries(options?: SortOptions): CountryData[];
+    /**
+     * Get sorted country codes
+     * @param {SortOptions} options - Same as getSortedCountries
+     * @returns {string[]} Array of alpha2 country codes
+     */
+    getSortedCountryCodes(options?: SortOptions): string[];
+    /**
+     * Find a Language object by language code.
+     * Iterates through all countries and their languages.
+     * @param {string} languageCode - Language code (e.g. 'en')
+     * @returns {Language | undefined} Immutable language object
+     */
+    findLanguageByLanguageCode(languageCode: string): Language | undefined;
+    /**
+     * Get the language name for a given country code.
+     * @param {string} countryCode - Country alpha2 or alpha3 code
+     * @returns {string} Language name or fallback value
+     */
+    findLanguageNameByCountryCode(countryCode: string): string;
+    /**
+     * Get official language code by country code
+     * @param {string} code - Country code
+     * @returns {string | undefined} Language code
+     */
+    getOfficialLanguageCodeByCountryCode(code: string): string | undefined;
+    /**
+     * Get country options for select components (sorted)
+     * @param {CountryOptionsParams | CountryData[] | CountryCodeArray} params - Countries with optional sort options
+     * @returns {CountryOption[]} Array of option objects
+     */
+    getCountryOptions(params: CountryOptionsParams | CountryData[] | CountryCodeArray): CountryOption[];
+    /**
+     * Get flag icon URL
+     * @param {string} alpha2 - Country code
+     * @param {'1x1' | '4x3'} ratio - Flag ratio
+     * @returns {string} Flag icon URL
+     */
+    getFlagIconUrl(alpha2: string, ratio?: '1x1' | '4x3'): string;
+    /**
+     * Get globe icon URL
+     * @returns {string} Globe icon URL
+     */
+    getGlobeIconUrl(): string;
+}
+export declare const maCountry: Country;
+export {};

package/dist/lib/country/country.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{map-mvbmSF8c.js → map-DyPIWJVE.js}

@@ -1,4 +1,4 @@
-import { g as tr } from "./index-DQXup9Ri.js";
+import { g as tr } from "./index-B06mhYjm.js";
 function ir(ne, Ze) {
   for (var S = 0; S < Ze.length; S++) {
     const Y = Ze[S];

package/dist/{offline-exporting-CM7bfwyx.js → offline-exporting-B9cJVsV3.js}

@@ -1,4 +1,4 @@
-import { g as it } from "./index-DQXup9Ri.js";
+import { g as it } from "./index-B06mhYjm.js";
 function lt(O, B) {
   for (var m = 0; m < B.length; m++) {
     const x = B[m];

package/dist/{stock-B02QGeJS.js → stock-CvtA8L-u.js}

@@ -1,4 +1,4 @@
-import { g as fa } from "./index-DQXup9Ri.js";
+import { g as fa } from "./index-B06mhYjm.js";
 function ma(Dt, ee) {
   for (var H = 0; H < ee.length; H++) {
     const et = ee[H];