ansuko 1.3.0 → 1.3.2

package/README.ja.md

@@ -128,6 +128,10 @@ const diff = _.changes(
   updated, 
   ['name', 'email', 'profile.bio']
 )
+
+// try-catch不要のエラーハンドリング
+const result = _.swallow(() => riskyOperation())  // エラー時はundefined
+const items = _.swallowMap([1, 2, 3], item => processItem(item), true)  // エラーを除外
 ```
 
 ### プラグインの使用
@@ -209,6 +213,8 @@ extended.toPointGeoJson([139.7, 35.6])
 - **`hasOr`** - パスの存在確認、なければデフォルトを返す（深いパス & Promise対応）
 - **`equalsOr`** - Promise対応の比較とフォールバック、直感的なnil処理
 - **`changes`** - DB更新用のオブジェクト差分追跡（`profile.tags[1]` のような深いパス & 除外モード対応）
+- **`swallow`** - エラー時にundefinedを返す関数実行（同期/非同期対応）
+- **`swallowMap`** - エラーをundefinedとして扱う配列map（compactモードでエラー除外可）
 
 ### 型変換と検証
 
@@ -331,7 +337,7 @@ npm run build
 
 ## 開発
 
-Seraによって開発され、ドキュメント、コードレビュー、技術的な議論でClaude（Anthropic）の支援を受けました。
+テストとドキュメントが苦手なので、壁打ちとドキュメントにClaudeを使ってます。
 
 ## ライセンス
 

package/README.md

@@ -102,6 +102,8 @@ const value = _.equalsOr(a, b, defaultValue)  // null == undefined
 - **`hasOr`** - Check if paths exist, return default if missing (supports deep paths & Promises)
 - **`equalsOr`** - Compare and fallback with intuitive nil handling (Promises supported)
 - **`changes`** - Track object differences for DB updates (supports deep paths like `profile.tags[1]` & excludes mode)
+- **`swallow`** - Execute function and return undefined on error (sync/async)
+- **`swallowMap`** - Map over array, treating errors as undefined (with optional compact mode)
 
 ### Type Conversion & Validation
 
@@ -203,6 +205,10 @@ const diff = _.changes(
   updated, 
   ['name', 'email', 'profile.bio']
 )
+
+// Error handling without try-catch
+const result = _.swallow(() => riskyOperation())  // undefined on error
+const items = _.swallowMap([1, 2, 3], item => processItem(item), true)  // filter errors
 ```
 
 ### Using Plugins

package/README.zh.md

@@ -101,6 +101,8 @@ const value = _.equalsOr(a, b, defaultValue)  // null == undefined
 - **`hasOr`** - 检查路径是否存在，如果缺失则返回默认值（支持深度路径和 Promise）
 - **`equalsOr`** - 比较并后备，具有直观的 nil 处理（支持 Promise）
 - **`changes`** - 跟踪对象差异用于数据库更新（支持深度路径如 `profile.tags[1]` 和排除模式）
+- **`swallow`** - 执行函数，出错时返回 undefined（同步/异步支持）
+- **`swallowMap`** - 映射数组，将错误视为 undefined（可选紧凑模式过滤错误）
 
 ### 类型转换与验证
 
@@ -202,6 +204,10 @@ const diff = _.changes(
   updated, 
   ['name', 'email', 'profile.bio']
 )
+
+// 无需 try-catch 的错误处理
+const result = _.swallow(() => riskyOperation())  // 出错时为 undefined
+const items = _.swallowMap([1, 2, 3], item => processItem(item), true)  // 过滤错误
 ```
 
 ### 使用插件

package/dist/index.d.ts

@@ -22,6 +22,18 @@ type MaybePromise<T> = T | Promise<T>;
 type MaybeFunction<T> = T | (() => MaybePromise<T>);
 declare const valueOr: <T, E>(value: MaybeFunction<MaybePromise<T | null | undefined>>, els?: E | (() => MaybePromise<E>)) => MaybePromise<T | E | undefined | null>;
 declare const emptyOr: <T, E>(value: MaybeFunction<MaybePromise<T | null | undefined>>, els?: E | ((val: T | null | undefined) => MaybePromise<E>)) => MaybePromise<T | E | undefined | null>;
+/**
+ * Ensures that all given paths exist on the resolved value; otherwise returns a default.
+ * Supports functions and Promises.
+ * @param value - Object or thunk
+ * @param paths - Paths to check
+ * @param els - Default value or thunk receiving the resolved value
+ * @returns Value or default
+ * @example await hasOr(fetchUser(), ['profile.name','id'], null)
+ * @example hasOr({a:{b:1}}, 'a.b', {}) // returns original object
+ * @category Promise Utilities
+ */
+declare const hasOr: <T, E>(value: MaybeFunction<MaybePromise<T | null | undefined>>, paths: string | string[], els?: E | ((val: T | null | undefined) => MaybePromise<E>)) => MaybePromise<T | E | undefined | null>;
 /**
  * Checks emptiness with intuitive rules: numbers and booleans are NOT empty.
  * @param value - Value to check
@@ -206,40 +218,329 @@ export type ChangesOptions = {
 };
 type ChangesAfterCallback<T> = (value: T) => any | Promise<any>;
 type ChangesAfterFinallyCallback<T> = (value: T, res: any) => any | Promise<any>;
-export interface AnsukoType extends Omit<_.LoDashStatic, "castArray" | "isEmpty" | "toNumber"> {
+export interface AnsukoType {
     extend: typeof extend;
     isValidStr: typeof isValidStr;
     valueOr: typeof valueOr;
     emptyOr: typeof emptyOr;
-    isEmpty: typeof isEmpty;
-    toNumber: typeof toNumber;
+    hasOr: typeof hasOr;
     toBool: typeof toBool;
     boolIf: typeof boolIf;
     waited: typeof waited;
     equalsOr: typeof equalsOr;
     parseJSON: typeof parseJSON;
     jsonStringify: typeof jsonStringify;
-    castArray: typeof castArray;
     changes: typeof changes;
     swallow: typeof swallow;
     swallowMap: typeof swallowMap;
-    size: typeof _.size;
-    isNil: typeof _.isNil;
+    arrayDepth: typeof arrayDepth;
+    isEmpty: typeof isEmpty;
+    toNumber: typeof toNumber;
+    castArray: typeof castArray;
+    isEmptyOrg: typeof _.isEmpty;
+    toNumberOrg: typeof _.toNumber;
+    castArrayOrg: typeof _.castArray;
+    add: typeof _.add;
+    after: typeof _.after;
+    ary: typeof _.ary;
+    assign: typeof _.assign;
+    assignIn: typeof _.assignIn;
+    assignInWith: typeof _.assignInWith;
+    assignWith: typeof _.assignWith;
+    at: typeof _.at;
+    attempt: typeof _.attempt;
+    before: typeof _.before;
+    bind: typeof _.bind;
+    bindAll: typeof _.bindAll;
+    bindKey: typeof _.bindKey;
+    camelCase: typeof _.camelCase;
+    capitalize: typeof _.capitalize;
+    ceil: typeof _.ceil;
+    chain: typeof _.chain;
+    chunk: typeof _.chunk;
+    clamp: typeof _.clamp;
+    clone: typeof _.clone;
+    cloneDeep: typeof _.cloneDeep;
+    cloneDeepWith: typeof _.cloneDeepWith;
+    cloneWith: typeof _.cloneWith;
+    compact: typeof _.compact;
+    concat: typeof _.concat;
+    cond: typeof _.cond;
+    conforms: typeof _.conforms;
+    conformsTo: typeof _.conformsTo;
+    constant: typeof _.constant;
+    countBy: typeof _.countBy;
+    create: typeof _.create;
+    curry: typeof _.curry;
+    curryRight: typeof _.curryRight;
     debounce: typeof _.debounce;
-    isEqual: typeof _.isEqual;
+    deburr: typeof _.deburr;
+    defaultTo: typeof _.defaultTo;
+    defaults: typeof _.defaults;
+    defaultsDeep: typeof _.defaultsDeep;
+    defer: typeof _.defer;
+    delay: typeof _.delay;
+    difference: typeof _.difference;
+    differenceBy: typeof _.differenceBy;
+    differenceWith: typeof _.differenceWith;
+    divide: typeof _.divide;
+    drop: typeof _.drop;
+    dropRight: typeof _.dropRight;
+    dropRightWhile: typeof _.dropRightWhile;
+    dropWhile: typeof _.dropWhile;
+    each: typeof _.each;
+    eachRight: typeof _.eachRight;
+    endsWith: typeof _.endsWith;
+    entries: typeof _.entries;
+    entriesIn: typeof _.entriesIn;
+    eq: typeof _.eq;
+    escape: typeof _.escape;
+    escapeRegExp: typeof _.escapeRegExp;
+    every: typeof _.every;
+    extendWith: typeof _.extendWith;
+    fill: typeof _.fill;
+    filter: typeof _.filter;
+    find: typeof _.find;
+    findIndex: typeof _.findIndex;
+    findKey: typeof _.findKey;
+    findLast: typeof _.findLast;
+    findLastIndex: typeof _.findLastIndex;
+    findLastKey: typeof _.findLastKey;
+    first: typeof _.first;
+    flatMap: typeof _.flatMap;
+    flatMapDeep: typeof _.flatMapDeep;
+    flatMapDepth: typeof _.flatMapDepth;
+    flatten: typeof _.flatten;
+    flattenDeep: typeof _.flattenDeep;
+    flattenDepth: typeof _.flattenDepth;
+    flip: typeof _.flip;
+    floor: typeof _.floor;
+    flow: typeof _.flow;
+    flowRight: typeof _.flowRight;
+    forEach: typeof _.forEach;
+    forEachRight: typeof _.forEachRight;
+    forIn: typeof _.forIn;
+    forInRight: typeof _.forInRight;
+    forOwn: typeof _.forOwn;
+    forOwnRight: typeof _.forOwnRight;
+    fromPairs: typeof _.fromPairs;
+    functions: typeof _.functions;
+    functionsIn: typeof _.functionsIn;
+    get: typeof _.get;
+    groupBy: typeof _.groupBy;
+    gt: typeof _.gt;
+    gte: typeof _.gte;
+    has: typeof _.has;
+    hasIn: typeof _.hasIn;
+    head: typeof _.head;
+    identity: typeof _.identity;
+    inRange: typeof _.inRange;
+    includes: typeof _.includes;
+    indexOf: typeof _.indexOf;
+    initial: typeof _.initial;
+    intersection: typeof _.intersection;
+    intersectionBy: typeof _.intersectionBy;
+    intersectionWith: typeof _.intersectionWith;
+    invert: typeof _.invert;
+    invertBy: typeof _.invertBy;
+    invoke: typeof _.invoke;
+    invokeMap: typeof _.invokeMap;
+    isArguments: typeof _.isArguments;
+    isArray: typeof _.isArray;
+    isArrayBuffer: typeof _.isArrayBuffer;
+    isArrayLike: typeof _.isArrayLike;
+    isArrayLikeObject: typeof _.isArrayLikeObject;
     isBoolean: typeof _.isBoolean;
+    isBuffer: typeof _.isBuffer;
+    isDate: typeof _.isDate;
+    isElement: typeof _.isElement;
+    isEqual: typeof _.isEqual;
+    isEqualWith: typeof _.isEqualWith;
+    isError: typeof _.isError;
+    isFinite: typeof _.isFinite;
+    isFunction: typeof _.isFunction;
+    isInteger: typeof _.isInteger;
+    isLength: typeof _.isLength;
+    isMap: typeof _.isMap;
+    isMatch: typeof _.isMatch;
+    isMatchWith: typeof _.isMatchWith;
+    isNaN: typeof _.isNaN;
+    isNative: typeof _.isNative;
+    isNil: typeof _.isNil;
+    isNull: typeof _.isNull;
+    isNumber: typeof _.isNumber;
+    isObject: typeof _.isObject;
+    isObjectLike: typeof _.isObjectLike;
+    isPlainObject: typeof _.isPlainObject;
+    isRegExp: typeof _.isRegExp;
+    isSafeInteger: typeof _.isSafeInteger;
+    isSet: typeof _.isSet;
     isString: typeof _.isString;
-    first: typeof _.first;
+    isSymbol: typeof _.isSymbol;
+    isTypedArray: typeof _.isTypedArray;
+    isUndefined: typeof _.isUndefined;
+    isWeakMap: typeof _.isWeakMap;
+    isWeakSet: typeof _.isWeakSet;
+    iteratee: typeof _.iteratee;
+    join: typeof _.join;
+    kebabCase: typeof _.kebabCase;
+    keyBy: typeof _.keyBy;
+    keys: typeof _.keys;
+    keysIn: typeof _.keysIn;
     last: typeof _.last;
+    lastIndexOf: typeof _.lastIndexOf;
+    lowerCase: typeof _.lowerCase;
+    lowerFirst: typeof _.lowerFirst;
+    lt: typeof _.lt;
+    lte: typeof _.lte;
+    map: typeof _.map;
+    mapKeys: typeof _.mapKeys;
+    mapValues: typeof _.mapValues;
+    matches: typeof _.matches;
+    matchesProperty: typeof _.matchesProperty;
+    max: typeof _.max;
+    maxBy: typeof _.maxBy;
+    mean: typeof _.mean;
+    meanBy: typeof _.meanBy;
+    memoize: typeof _.memoize;
+    merge: typeof _.merge;
+    mergeWith: typeof _.mergeWith;
+    method: typeof _.method;
+    methodOf: typeof _.methodOf;
+    min: typeof _.min;
+    minBy: typeof _.minBy;
+    mixin: typeof _.mixin;
+    multiply: typeof _.multiply;
+    negate: typeof _.negate;
+    noConflict: typeof _.noConflict;
+    noop: typeof _.noop;
+    now: typeof _.now;
+    nth: typeof _.nth;
+    nthArg: typeof _.nthArg;
+    omit: typeof _.omit;
+    omitBy: typeof _.omitBy;
+    once: typeof _.once;
+    orderBy: typeof _.orderBy;
+    over: typeof _.over;
+    overArgs: typeof _.overArgs;
+    overEvery: typeof _.overEvery;
+    overSome: typeof _.overSome;
+    pad: typeof _.pad;
+    padEnd: typeof _.padEnd;
+    padStart: typeof _.padStart;
+    parseInt: typeof _.parseInt;
+    partial: typeof _.partial;
+    partialRight: typeof _.partialRight;
+    partition: typeof _.partition;
+    pick: typeof _.pick;
+    pickBy: typeof _.pickBy;
+    property: typeof _.property;
+    propertyOf: typeof _.propertyOf;
+    pull: typeof _.pull;
+    pullAll: typeof _.pullAll;
+    pullAllBy: typeof _.pullAllBy;
+    pullAllWith: typeof _.pullAllWith;
+    pullAt: typeof _.pullAt;
+    random: typeof _.random;
+    range: typeof _.range;
+    rangeRight: typeof _.rangeRight;
+    rearg: typeof _.rearg;
+    reduce: typeof _.reduce;
+    reduceRight: typeof _.reduceRight;
+    reject: typeof _.reject;
+    remove: typeof _.remove;
+    repeat: typeof _.repeat;
+    replace: typeof _.replace;
+    rest: typeof _.rest;
+    result: typeof _.result;
+    reverse: typeof _.reverse;
+    round: typeof _.round;
+    runInContext: typeof _.runInContext;
+    sample: typeof _.sample;
+    sampleSize: typeof _.sampleSize;
+    set: typeof _.set;
+    setWith: typeof _.setWith;
+    shuffle: typeof _.shuffle;
+    size: typeof _.size;
+    slice: typeof _.slice;
+    snakeCase: typeof _.snakeCase;
+    some: typeof _.some;
+    sortBy: typeof _.sortBy;
+    sortedIndex: typeof _.sortedIndex;
+    sortedIndexBy: typeof _.sortedIndexBy;
+    sortedIndexOf: typeof _.sortedIndexOf;
+    sortedLastIndex: typeof _.sortedLastIndex;
+    sortedLastIndexBy: typeof _.sortedLastIndexBy;
+    sortedLastIndexOf: typeof _.sortedLastIndexOf;
+    sortedUniq: typeof _.sortedUniq;
+    sortedUniqBy: typeof _.sortedUniqBy;
+    split: typeof _.split;
+    spread: typeof _.spread;
+    startCase: typeof _.startCase;
+    startsWith: typeof _.startsWith;
+    stubArray: typeof _.stubArray;
+    stubFalse: typeof _.stubFalse;
+    stubObject: typeof _.stubObject;
+    stubString: typeof _.stubString;
+    stubTrue: typeof _.stubTrue;
+    subtract: typeof _.subtract;
+    sum: typeof _.sum;
+    sumBy: typeof _.sumBy;
+    tail: typeof _.tail;
+    take: typeof _.take;
+    takeRight: typeof _.takeRight;
+    takeRightWhile: typeof _.takeRightWhile;
+    takeWhile: typeof _.takeWhile;
+    tap: typeof _.tap;
+    template: typeof _.template;
+    throttle: typeof _.throttle;
+    thru: typeof _.thru;
+    times: typeof _.times;
+    toArray: typeof _.toArray;
+    toFinite: typeof _.toFinite;
+    toInteger: typeof _.toInteger;
+    toLength: typeof _.toLength;
+    toLower: typeof _.toLower;
+    toPairs: typeof _.toPairs;
+    toPairsIn: typeof _.toPairsIn;
+    toPath: typeof _.toPath;
+    toPlainObject: typeof _.toPlainObject;
+    toSafeInteger: typeof _.toSafeInteger;
+    toString: typeof _.toString;
+    toUpper: typeof _.toUpper;
+    transform: typeof _.transform;
+    trim: typeof _.trim;
+    trimEnd: typeof _.trimEnd;
+    trimStart: typeof _.trimStart;
+    truncate: typeof _.truncate;
+    unary: typeof _.unary;
+    unescape: typeof _.unescape;
+    union: typeof _.union;
+    unionBy: typeof _.unionBy;
+    unionWith: typeof _.unionWith;
     uniq: typeof _.uniq;
-    has: typeof _.has;
-    keys: typeof _.keys;
+    uniqBy: typeof _.uniqBy;
+    uniqWith: typeof _.uniqWith;
+    uniqueId: typeof _.uniqueId;
+    unset: typeof _.unset;
+    unzip: typeof _.unzip;
+    unzipWith: typeof _.unzipWith;
+    update: typeof _.update;
+    updateWith: typeof _.updateWith;
+    upperCase: typeof _.upperCase;
+    upperFirst: typeof _.upperFirst;
     values: typeof _.values;
-    some: typeof _.some;
-    arrayDepth: typeof arrayDepth;
-    isEmptyOrg: typeof _.isEmpty;
-    toNumberOrg: typeof _.toNumber;
-    castArrayOrg: typeof _.castArray;
+    valuesIn: typeof _.valuesIn;
+    without: typeof _.without;
+    words: typeof _.words;
+    wrap: typeof _.wrap;
+    xor: typeof _.xor;
+    xorBy: typeof _.xorBy;
+    xorWith: typeof _.xorWith;
+    zip: typeof _.zip;
+    zipObject: typeof _.zipObject;
+    zipObjectDeep: typeof _.zipObjectDeep;
+    zipWith: typeof _.zipWith;
 }
 declare const _default: AnsukoType;
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ansuko",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "A modern JavaScript/TypeScript utility library that extends lodash with practical, intuitive behaviors. Fixes lodash quirks, adds Promise support, Japanese text processing, and GeoJSON utilities.",
   "keywords": [
     "lodash",