nv-img-barcode-cmmn 1.0.2 → 1.0.3

package/gs1.js

@@ -356,6 +356,8 @@ const name_to_ai = (name)=>{
    return ai;
 }
 const ai_to_names = (ai)=>AI_TO_NAMES[ai];
+
+
 const encd_one =(name_or_ai,value)=>{
     let ai = name_to_ai(name_or_ai);
     if (!ai) {
@@ -434,6 +436,387 @@ const encd  = (...args)=>{
    }
 }
 
+const decd = (gs1_str, options = {}) => {
+    const {
+        strict = true,           // 严格模式，验证每个字段
+        useChineseKeys = true,  // 使用中文描述作为键
+        includeMeta = false,     // 包含元数据
+        parseAll = true,         // 解析所有字段，包括未知AI
+    } = options;
+    
+    // 验证输入
+    if (!gs1_str || typeof gs1_str !== 'string') {
+        return [false, '输入必须是字符串'];
+    }
+    
+    gs1_str = gs1_str.trim();
+    if (gs1_str === '') {
+        return [false, '输入字符串不能为空'];
+    }
+    
+    // 验证GS1格式
+    if (!/^(?:\(\d{2,4}\)[^()]*)+$/.test(gs1_str)) {
+        if (strict) {
+            return [false, '无效的GS1格式'];
+        }
+    }
+    
+    let result = {};
+    const errors = [];
+    const warnings = [];
+    
+    // 匹配所有字段
+    const segments = gs1_str.match(/\((\d{2,4})\)([^()]*)/g) || [];
+    
+    if (segments.length === 0) {
+        return [false, '未找到有效的GS1字段'];
+    }
+    
+    for (const segment of segments) {
+        const match = segment.match(/\((\d{2,4})\)([^()]*)/);
+        if (!match) {
+            warnings.push(`无法解析段: ${segment}`);
+            continue;
+        }
+        
+        const ai = match[1];
+        const rawValue = match[2];
+        const spec = GS1_AI_SPECS[ai];
+        
+        // 解析值
+        let parsedValue = rawValue;
+        let isValid = true;
+        let error = null;
+        
+        if (spec) {
+            // 已知字段
+            try {
+                // 根据字段类型验证长度
+                if (spec.length) {
+                    if (spec.format === 'numeric' || spec.format === 'date') {
+                        // numeric 和 date 必须是固定长度
+                        if (rawValue.length !== spec.length) {
+                            isValid = false;
+                            error = `长度应为${spec.length}位，实际为${rawValue.length}位`;
+                        }
+                    } else if (spec.format === 'alphanumeric') {
+                        // alphanumeric 只需要不超过最大长度 ✅
+                        if (rawValue.length > spec.length) {
+                            isValid = false;
+                            error = `长度不能超过${spec.length}位，实际为${rawValue.length}位`;
+                        }
+                    }
+                }
+                
+                if (spec.format === 'numeric') {
+                    // 验证是否为纯数字
+                    if (!/^\d+$/.test(rawValue)) {
+                        isValid = false;
+                        error = '数值字段必须为纯数字';
+                    } else if (spec.decimal > 0) {
+                        // 有小数位的数值
+                        const num = parseInt(rawValue, 10) / Math.pow(10, spec.decimal);
+                        parsedValue = Number(num.toFixed(spec.decimal));
+                    } else {
+                        // 整数
+                        parsedValue = parseInt(rawValue, 10);
+                        if (isNaN(parsedValue)) {
+                            isValid = false;
+                            error = '无效的整数值';
+                        }
+                    }
+                } else if (spec.format === 'date') {
+                    // 日期验证
+                    if (!/^\d{6}$/.test(rawValue)) {
+                        isValid = false;
+                        error = '日期必须是6位数字';
+                    }
+                } else if (spec.format === 'alphanumeric') {
+                    // 验证字符集
+                    if (!GS1_ALPHANUMERIC_REGEX.test(rawValue)) {
+                        warnings.push(`AI(${ai}) 包含不允许的字符`);
+                    }
+                }
+                
+                if (!isValid && strict) {
+                    errors.push(`AI(${ai}) ${spec.desc || spec.name}: ${error}`);
+                    continue;
+                }
+                
+                // 确定键名
+                let key;
+                if (useChineseKeys && spec.desc) {
+                    // 使用中文描述（清理后）
+                    key = spec.desc
+                        .replace(/\([^)]*\)/g, '')
+                        .replace('m²', '平')
+                        .replace('m³', '方')
+                        .replace('kg', '公斤')
+                        .replace('lb', '磅')
+                        .replace('L', '升')
+                        .replace(/[^a-zA-Z0-9\u4e00-\u9fa5]/g, '')
+                        .trim();
+                    
+                    if (key === '') {
+                        key = spec.name ? spec.name.toLowerCase() : ai;
+                    }
+                } else {
+                    // 使用英文名
+                    key = spec.name ? spec.name.toLowerCase() : ai;
+                }
+                
+                // 添加到结果
+                if (isValid || !strict) {
+                    result[key] = parsedValue;
+                }
+                
+                if (includeMeta) {
+                    result[`${key}_ai`] = ai;
+                    result[`${key}_raw`] = rawValue;
+                    if (!isValid) {
+                        result[`${key}_error`] = error;
+                    }
+                }
+                
+            } catch (err) {
+                const errorMsg = `AI(${ai}) 解析错误: ${err.message}`;
+                if (strict) {
+                    errors.push(errorMsg);
+                } else {
+                    warnings.push(errorMsg);
+                }
+            }
+            
+        } else if (parseAll) {
+            // 未知字段
+            result[`ai_${ai}`] = rawValue;
+            warnings.push(`未知AI代码: ${ai}`);
+        } else {
+            warnings.push(`跳过未知AI代码: ${ai}`);
+        }
+    }
+    
+    // 构建最终结果
+    if (errors.length > 0) {
+        const errorMsg = errors.join('; ');
+        if (warnings.length > 0) {
+            return [false, `${errorMsg} (警告: ${warnings.join('; ')})`];
+        }
+        return [false, errorMsg];
+    }
+    
+    if (includeMeta) {
+        const meta = {};
+        if (warnings.length > 0) {
+            meta.warnings = warnings;
+        }
+        if (Object.keys(result).length > 0) {
+            meta.fieldCount = Object.keys(result).filter(k => !k.endsWith('_ai') && !k.endsWith('_raw') && !k.endsWith('_error')).length;
+        }
+        
+        result._meta = meta;
+    } else if (warnings.length > 0) {
+        console.warn('GS1解析警告:', warnings.join('; '));
+    }
+    
+    return [true, result];
+};
+
+const rand_one = (onlyChineseName = false, onlyEnglishName = false) => {
+    // 获取所有可用的字段名
+    let availableNames = [];
+    
+    if (onlyChineseName && onlyEnglishName) {
+        // 两个都true，就返回所有
+        availableNames = Object.keys(NAME_TO_AI);
+    } else if (onlyChineseName) {
+        // 只返回中文名
+        availableNames = Object.keys(NAME_TO_AI).filter(name => {
+            return /[\u4e00-\u9fa5]/.test(name) || 
+                   ALIAS[name] && /[\u4e00-\u9fa5]/.test(Object.keys(ALIAS).find(k => ALIAS[k] === ALIAS[name]));
+        });
+    } else if (onlyEnglishName) {
+        // 只返回英文名
+        availableNames = Object.keys(NAME_TO_AI).filter(name => {
+            return /^[a-zA-Z]/.test(name) && 
+                   !/[\u4e00-\u9fa5]/.test(name) &&
+                   !/^\d+$/.test(name);
+        });
+    } else {
+        // 返回所有
+        availableNames = Object.keys(NAME_TO_AI);
+    }
+    
+    if (availableNames.length === 0) {
+        return null;
+    }
+    
+    // 随机选择一个字段
+    const randomName = availableNames[Math.floor(Math.random() * availableNames.length)];
+    const ai = NAME_TO_AI[randomName];
+    const spec = GS1_AI_SPECS[ai];
+    
+    if (!spec) {
+        return null;
+    }
+    
+    // 根据字段类型生成随机值
+    let randomValue;
+    
+    switch (spec.format) {
+        case 'numeric':
+            if (spec.decimal > 0) {
+                // 带小数的数值
+                const maxValue = Math.pow(10, spec.length - spec.decimal) - 1;
+                const integer = Math.floor(Math.random() * maxValue);
+                const decimal = Math.floor(Math.random() * Math.pow(10, spec.decimal));
+                randomValue = integer + decimal / Math.pow(10, spec.decimal);
+                
+                // 格式化为指定小数位
+                randomValue = Number(randomValue.toFixed(spec.decimal));
+            } else {
+                // 整数
+                const maxValue = Math.pow(10, spec.length) - 1;
+                randomValue = Math.floor(Math.random() * maxValue);
+            }
+            break;
+            
+        case 'date':
+            // 生成未来2年内的随机日期
+            const now = new Date();
+            const futureDate = new Date(now.getTime() + Math.random() * 2 * 365 * 24 * 60 * 60 * 1000);
+            const year = futureDate.getFullYear() % 100;
+            const month = futureDate.getMonth() + 1;
+            const day = futureDate.getDate();
+            randomValue = `${year.toString().padStart(2, '0')}${month.toString().padStart(2, '0')}${day.toString().padStart(2, '0')}`;
+            break;
+            
+        case 'alphanumeric':
+            // 随机长度（1到最大长度）
+            const length = Math.floor(Math.random() * spec.length) + 1;
+            
+            // 修正：使用安全的字符集
+            // 只使用字母、数字、连字符、下划线
+            const safeChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+            
+            randomValue = '';
+            for (let i = 0; i < length; i++) {
+                randomValue += safeChars[Math.floor(Math.random() * safeChars.length)];
+            }
+            
+            break;
+            
+        default:
+            randomValue = '';
+    }
+    
+    return {
+        name: randomName,
+        ai: ai,
+        value: randomValue,
+        spec: spec
+    };
+};
+
+const rand = (max_cnt = 5, min_cnt = 1, options = {}) => {
+   // 参数处理
+    min_cnt = min_cnt < 1 ? 1 : min_cnt;
+    max_cnt = max_cnt > min_cnt ? max_cnt : min_cnt;
+    
+    // 从选项中获取参数
+    const {
+        onlyChineseName = false,
+        onlyEnglishName = false,
+        includeCustomAI = false,
+        uniqueAI = true,
+        maxTotalLength = 48,
+        returnObject = false,  // 是否返回对象而不是字符串
+    } = options;
+    
+    // 随机生成实际数量
+    const actualCount = Math.floor(Math.random() * (max_cnt - min_cnt + 1)) + min_cnt;
+    
+    const fields = [];
+    const usedAIs = new Set();
+    let totalLength = 0;
+    
+    for (let i = 0; i < actualCount; i++) {
+        let field;
+        let attempts = 0;
+        const maxAttempts = 20;
+        
+        do {
+            field = rand_one(onlyChineseName, onlyEnglishName);
+            attempts++;
+            
+            if (!field) break;
+            
+            // 检查是否排除自定义AI
+            if (!includeCustomAI && /^9[0-9]$/.test(field.ai)) {
+                continue;
+            }
+            
+            // 检查AI是否唯一
+            if (uniqueAI && usedAIs.has(field.ai)) {
+                continue;
+            }
+            
+            // 检查总长度
+            const fieldLength = `(${field.ai})${field.value}`.length;
+            if (totalLength + fieldLength > maxTotalLength) {
+                continue;
+            }
+            
+            break;
+        } while (attempts < maxAttempts);
+        
+        if (!field || attempts >= maxAttempts) {
+            break;
+        }
+        
+        usedAIs.add(field.ai);
+        totalLength += `(${field.ai})${field.value}`.length;
+        fields.push(field);
+    }
+    
+    if (fields.length === 0) {
+        return returnObject ? { success: false, error: "未能生成任何字段" } : null;
+    }
+    
+    // 编码为GS1字符串
+    const gs1Parts = [];
+    
+    for (const field of fields) {
+        // 使用 encd 函数编码
+        const encoded = x.gs1.encd(field.name, field.value);
+        if (encoded) {
+            gs1Parts.push(encoded);
+        }
+    }
+    
+    if (gs1Parts.length === 0) {
+        return returnObject ? { 
+            success: false, 
+            error: "所有字段编码失败"
+        } : null;
+    }
+    
+    const gs1String = gs1Parts.join("");
+    
+    if (returnObject) {
+        return {
+            success: true,
+            gs1: gs1String,
+            fields: fields,
+            count: fields.length,
+            length: gs1String.length,
+            withinLengthLimit: gs1String.length <= maxTotalLength
+        };
+    }
+    
+    return gs1String;
+};
+
 module.exports = {
     get GS1_AI_SPECS() {return GS1_AI_SPECS;},
     get ALIAS()  {return ALIAS;},
@@ -449,6 +832,9 @@ module.exports = {
     encd_one,
     _encd,
     encd,
+    decd,
     list_names: ()=>FIXED_NAMES,
-    look_requirements: (name)=>GS1_AI_SPECS[name_to_ai(name)]
+    look_requirements: (name)=>GS1_AI_SPECS[name_to_ai(name)],
+    rand_one,rand,
+ 
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nv-img-barcode-cmmn",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"