@salsita-ai/common 0.0.0-stage → 0.49.0-develop.d4bea2382c

package/CHANGELOG.md

@@ -0,0 +1,278 @@
+# Change Log
+
+All notable changes to the @salsita-ai/common package will be documented in this file.
+
+## [0.48.0]
+
+change!: remove the unused process-local `AsyncCache` utility (CON-2556, CON-2685)
+
+**Migration:** replace `AsyncCache` with a caller-owned cache appropriate for the application's runtime. Server applications should use shared storage when cache entries must remain coherent across instances.
+
+change!(common): filter console logs below info by default
+
+`initConsoleLogger` now omits debug and verbose messages unless its `level` option is `debug`. Console calls also omit trailing `undefined` arguments.
+
+Migration: pass `initConsoleLogger({ level: 'debug' })` to preserve the previous always-on debug and verbose output.
+
+fix: require explicitly pinned state reads when composing memoized selectors
+
+chore: build and type-check with the TypeScript 7 native compiler
+
+chore: resolve all pnpm audit findings (CON-2655)
+
+Bump @babel/core to 7.29.7, clearing the sourceMappingURL arbitrary-file-read advisory for consumers installing this package, as part of bringing `pnpm audit` to zero findings workspace-wide.
+
+feat: add `canonicalStringify`, a key-sorted deterministic JSON serializer for stable hashing (CON-2755)
+
+## [0.47.0]
+
+- Empty
+
+## [0.46.0]
+
+- Empty
+
+## [0.45.0]
+
+### 2026-06-01 commit dd378335f PR #1582
+
+chore: bump @lingui/core 4.11.3 → 5.9.5
+
+See `@salsita-ai/platform-project-sdk` changelog for the lingui 4 → 5 migration guide.
+
+### 2026-06-01 commit eba73549e PR #1581
+
+chore: bump @swc/core 1.4.2 → 1.7.28, @swc/cli 0.3.10 → 0.7.10
+
+### 2026-06-01 commit fabe5ce58 PR #1580
+
+chore: bump typescript 5.7.2 → 5.9.3, `@types/eslint` 8.56.5 → 9.6.1
+
+### 2026-06-01 commit 868ced09c PR #1572
+
+chore: drop unused chokidar dep; bump prettier 3.2.{2,5} → 3.8.3 (deps + peerDeps)
+
+### 2026-06-01 commit fdd0ae84c PR #1570
+
+chore: dep updates
+
+- `envalid` 8.0.0 → 8.1.1 (deps + peerDeps)
+- `rxjs` 7.8.1 → 7.8.2 (deps + peerDeps)
+- `dotenv` 16.4.1 → 17.4.2; added `quiet: true` to `config()` in `env/index.ts` to silence v17's new injection logs
+- `lodash-es` 4.17.21 → 4.18.1 (CVE-2026-4800, CVE-2026-2950, CVE-2025-13465)
+
+## [0.44.0]
+
+- Empty
+
+## [0.43.0]
+
+- Empty
+
+## [0.42.0]
+
+- Empty
+
+## [0.41.0]
+
+- Empty
+
+## [0.40.0]
+
+- Empty
+
+## [0.39.0]
+
+- Empty
+
+## [0.38.0]
+
+- Empty
+
+## [0.37.0]
+
+- Empty
+
+## [0.36.0]
+
+- Empty
+
+## [0.35.0]
+
+- fix: `readConfigRecursive` no longer logs warning when PNPM workspace file is not found
+
+## [0.34.0]
+
+- Empty
+
+## [0.33.0]
+
+- Empty
+
+## [0.32.0]
+
+- feat: Add `tryOrDefault` utility function for safe function execution with fallback value
+
+## [0.31.0]
+
+- fix: `readConfigRecursive` (recursive .env file resolving) logs warning instead of an error when PNPM workspace file is not found
+
+## [0.30.0]
+
+- Empty
+
+## [0.29.0]
+
+- change!: Remove `resolveLocalizableString` in favor of `resolveLocalizable`
+- feat: Introduce `MultilingualString` as another variant of `Localizable` which uses a hash of language code and translation - mainly useful for data coming from the admin portal
+
+- feat: `memoOnce` added for singleton factories and "trigger once" effects
+
+- feat: `ObservableWithLastValue` type moved here from `@salsita-ai/platform-project-sdk/react`
+
+- feat: `toObservableWithLastValue` added - use it to create an observable suited for eager reading from any observable,
+  when you know the initial value
+
+## [0.28.0]
+
+- Empty
+
+## [0.27.0]
+
+- Empty
+
+## [0.26.0]
+
+- Empty
+
+## [0.25.0]
+
+- Empty
+
+## [0.24.0]
+
+- Empty
+
+## [0.23.0]
+
+- Empty
+
+## [0.22.0] (2025-1-29)
+
+- Empty
+
+## [0.21.0] (2025-1-22)
+
+- Empty
+
+## [0.20.0] (2025-1-15)
+
+- Empty
+
+## [0.19.0] (2025-1-8)
+
+- Empty
+
+## [0.18.2] (2025-1-7)
+
+- Empty
+
+## [0.18.1] (2025-1-7)
+
+- Empty
+
+## [0.18.0] (2025-1-7)
+
+- change!: Migrated from utils to common - now includes /env, /prettier, /eslint, /utils
+
+To migrate rename the imports to the new paths
+
+## [0.17.0] (2024-12-18)
+
+- Empty
+
+## [0.16.0] (2024-11-26)
+
+- Empty
+
+## [0.15.0] (2024-11-19)
+
+- Empty
+
+## [0.14.0] (2024-11-15)
+
+- feat: `initConsoleLogger` moved to this package from `react-sdk`
+
+## [0.13.0] (2024-11-7)
+
+- Empty
+
+## [0.12.0] (2024-11-5)
+
+- Empty
+
+## [0.11.0] (2024-10-25)
+
+- feat: Added basic types and helpers for localizable strings: `Localizable`, `isMessageDescriptor`, `resolveLocalizable`
+
+## [0.10.0] (2024-10-22)
+
+- Empty
+
+## [0.9.0] (2024-10-16)
+
+- Empty
+
+## [0.8.0] (2024-10-10)
+
+- Empty
+
+## [0.7.0] (2024-10-9)
+
+- Empty
+
+## [0.6.0] (2024-10-2)
+
+- Empty
+
+## [0.5.0] (2024-9-27)
+
+### Bug Fixes
+
+- None
+
+### Features
+
+- None
+
+## [0.4.0] (2024-9-23)
+
+### Bug Fixes
+
+- None
+
+### Features
+
+- Providing .d.ts files for the published build
+
+## [0.3.0] (2024-9-20)
+
+### Bug Fixes
+
+- None
+
+### Features
+
+- Adding appendToGlobalContext() to Logger interface
+
+## 0.2.0 (2024-9-4)
+
+Initial testing release
+
+## 0.1.0 (2024-9-3)
+
+Initial testing release
+
+## 0.0.1 (2024-8-12)
+
+Initial testing release

package/LICENSE

@@ -0,0 +1,61 @@
+Salsita SDK License
+
+Copyright (c) 2026 Salsita s.r.o. All rights reserved.
+
+This software and its associated documentation (the "Software") are
+proprietary to Salsita s.r.o., Štefánikova 18/25, 150 00 Prague 5,
+Czech Republic, Company ID 272 04 201 ("Salsita"). The Software is
+licensed, not sold. By installing, copying or using the Software you
+agree to this license and to the Salsita SDK Terms at
+https://salsita.ai/terms (the "Terms"). If you do not agree,
+do not use the Software.
+
+1. License grant
+Subject to this license and the Terms, Salsita grants you a limited,
+non-exclusive, non-transferable, non-sublicensable, revocable license to:
+  (a) install and use the Software to develop, test and evaluate
+      applications built for the Salsita platform; and
+  (b) use the Software in production, and distribute it in compiled form
+      as part of such applications, only while you hold an active
+      Salsita account in good standing.
+
+2. Restrictions
+Except as expressly permitted above or by applicable law, you may not:
+  (a) redistribute, sublicense, sell, rent or lease the Software, or make
+      it available to third parties as a standalone product;
+  (b) modify, translate or create derivative works of the Software;
+  (c) reverse engineer, decompile or disassemble the Software, or attempt
+      to derive its source code;
+  (d) use the Software with, or to build, a product or service that
+      competes with or replaces the Salsita platform;
+  (e) remove or alter any copyright, trademark or licence notice.
+
+3. Ownership
+Salsita and its licensors retain all right, title and interest in the
+Software, including all intellectual property rights. No rights are
+granted except those expressly stated in this license.
+
+4. Third-party components
+The Software may include third-party components distributed under their
+own licences. Those licences govern your use of those components.
+
+5. Termination
+This license ends automatically if you breach it or if your account is
+closed. On termination you must stop using the Software and delete all
+copies in your possession. Sections 2, 3, 6 and 7 survive termination.
+
+6. Disclaimer of warranty
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+
+7. Limitation of liability
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, SALSITA SHALL NOT BE LIABLE FOR
+ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL OR PUNITIVE DAMAGES, OR
+FOR ANY LOSS OF PROFITS, REVENUE OR DATA, ARISING OUT OF OR RELATED TO
+THE SOFTWARE, WHETHER IN CONTRACT, TORT OR OTHERWISE.
+
+8. Terms
+The Terms supplement this license. If the Terms and this license
+conflict, the Terms prevail. If you have a separate signed agreement
+with Salsita covering the Software, that agreement prevails over both.

package/README.md

@@ -1,3 +1,35 @@
-# Temporary Holding Version
+# @salsita-ai/common
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Shared utilities of the Salsita SDK: small runtime and type helpers, validated environment loading, and the ESLint and Prettier configurations that generated projects use.
+
+A project on the application-spec pipeline does not install this package itself: `@salsita-ai/sdk` depends on it and re-exports every entry point, so the project imports it through the SDK. Projects in the legacy format still declare it directly and import it by its own name; both paths resolve to the same code.
+
+```ts
+import { createEnvReader } from '@salsita-ai/sdk/common/env'
+import { Branded } from '@salsita-ai/sdk/common/utils'
+```
+
+## Entry points
+
+There is no package-root export. Import from one of the paths declared in `package.json`.
+
+| Entry point | Contents                                                                                                                                                                           |
+| ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `utils`     | General-purpose helpers for browser and Node: branded types, assertions, equality and nullish checks, cache and selector helpers, localization shapes, color parsing, Zod helpers. |
+| `env`       | `createEnvReader`, which loads environment variables into an `envalid` specification.                                                                                              |
+| `eslint`    | Shared flat ESLint configurations: `eslintrc`, `eslintrcReactWithStoryBook`, and the optional `devLinguiEslintrcRules`.                                                            |
+| `prettier`  | `prettierrc`, the shared Prettier configuration with its import-order plugin setup.                                                                                                |
+
+### Environment loading
+
+`createEnvReader` reads variables with this precedence, highest first:
+
+1. Variables already present in `process.env`.
+2. `.env.generated`, written by the CLI with deployment values.
+3. `.env`, the developer's own values and credentials.
+
+It searches the current package and the pnpm workspace root, expands variable references after merging, and validates the result with the supplied `envalid` specs. A value in `.env` therefore never overrides a process or generated deployment value. The consuming project owns its `.env.example`; this package has no environment variables of its own.
+
+## Licence
+
+Proprietary software of Salsita s.r.o., published under the Salsita SDK License (the `LICENSE` file in this package) and the terms at https://salsita.ai/terms. The published package contains minified code without source maps.

package/dist/env/index.d.ts

@@ -0,0 +1,14 @@
+import type { CleanOptions, CleanedEnv } from 'envalid';
+/**
+ * Create a function that reads and parses the environment variables.
+ *
+ * The variables are read from
+ * - the process environment,
+ * - `.env.generated` file
+ * - and `.env` file
+ *
+ * in this order of precedence.
+ *
+ * The function parses the variable based on the provided `envalid` specs and options
+ */
+export declare const createEnvReader: <S>(specs: S, options?: CleanOptions<S>) => () => CleanedEnv<S>;

package/dist/env/index.js

@@ -0,0 +1 @@
+import{config as r}from"dotenv";import{expand as e}from"dotenv-expand";import{cleanEnv as o}from"envalid";import{findUpSync as t,pathExistsSync as n}from"find-up";import{dirname as p,resolve as s}from"node:path";let d=(e,o)=>{let d=process.cwd(),a=[d],i=t("pnpm-workspace.yaml",{stopAt:"../../.."});if(i){let r=p(i);r!==d&&a.unshift(r)}return a.reduce((t,p)=>{let d=s(p,o);if(!n(d))return t;let a=r({processEnv:e,path:d,quiet:!0});return a.error&&(console.error("DotEnv error:",a.error),t.error=t.error??a.error),Object.assign(t.parsed,a.parsed),t},{error:void 0,parsed:{}})};export const createEnvReader=(r,t={})=>()=>{let n={...process.env},p=d(n,".env.generated"),s=d(n,".env");return e({...s,parsed:{...s.parsed,...p.parsed},ignoreProcessEnv:!0}),o(n,r,t)};

package/dist/eslint/index.d.ts

@@ -0,0 +1,13 @@
+import type { Linter } from 'eslint';
+export declare const eslintrc: Linter.Config[];
+export declare const eslintrcReactWithStoryBook: Linter.Config[];
+/**
+ * This is good for finding out potential undiscovered translatable locales, but is too strict and
+ * too badly configurable to be used as a permanent rule.
+ *
+ * @example
+ * import { devLinguiEslintrcRules, eslintrc } from '@salsita-ai/sdk/common/eslint'
+
+   export default [...eslintrc, ...devLinguiEslintrcRules]
+ */
+export declare const devLinguiEslintrcRules: Linter.Config[];

package/dist/eslint/index.js

@@ -0,0 +1 @@
+import e from"@eslint/js";import r from"eslint-plugin-import";import t from"eslint-plugin-lingui";import s from"eslint-plugin-lodash";import o from"eslint-plugin-react";import i from"eslint-plugin-react-hooks";import n from"eslint-plugin-storybook";import l from"eslint-plugin-unused-imports";import p from"globals";import c from"typescript-eslint";let a=[{ignores:["**/*.cjs","**/dist/**","**/.phoenix/**"]},e.configs.recommended,...c.configs.recommended,{plugins:{"react-hooks":i,lodash:s,"unused-imports":l,lingui:t,import:r},languageOptions:{globals:{...p.browser,...p.node},parserOptions:{project:["./tsconfig.json"]}},rules:{"react-hooks/exhaustive-deps":["error",{additionalHooks:"(\\*\\.)?(useStoreSelector|useRenderedSelector|useStoreSelector$|useRenderedSelector$)"}],"react-hooks/rules-of-hooks":"error","import/order":["error",{groups:[["builtin","external"],"internal"],"newlines-between":"always-and-inside-groups"}],"lodash/import-scope":["error","method"],"unused-imports/no-unused-imports":"error","@typescript-eslint/consistent-type-definitions":["off"]}},{files:["**/*.tsx"],plugins:{react:o},rules:{"react/jsx-curly-brace-presence":["error",{props:"never",children:"never"}]}},{files:["**/*.ts","**/*.tsx"],rules:{"@typescript-eslint/no-explicit-any":"off","@typescript-eslint/no-empty-object-type":"off","@typescript-eslint/ban-ts-comment":["error",{"ts-expect-error":"allow-with-description","ts-ignore":"allow-with-description","ts-nocheck":!0,"ts-check":!1,minimumDescriptionLength:10}],"@typescript-eslint/consistent-type-assertions":["error",{assertionStyle:"as",objectLiteralTypeAssertions:"allow"}],"@typescript-eslint/consistent-type-exports":["error",{fixMixedExportsWithInlineTypeSpecifier:!1}],"@typescript-eslint/consistent-type-imports":["error",{prefer:"type-imports",fixStyle:"separate-type-imports"}],"@typescript-eslint/explicit-function-return-type":"off","@typescript-eslint/method-signature-style":"off","@typescript-eslint/no-misused-promises":["error",{checksVoidReturn:!1}],"@typescript-eslint/no-non-null-assertion":"off","@typescript-eslint/no-unnecessary-type-assertion":"off","@typescript-eslint/no-unused-vars":["error",{args:"after-used",argsIgnorePattern:"^_",caughtErrors:"none",ignoreRestSiblings:!0,vars:"all",varsIgnorePattern:"^_"}],"@typescript-eslint/no-useless-constructor":"error","@typescript-eslint/prefer-nullish-coalescing":["error",{ignoreConditionalTests:!0,ignoreMixedLogicalExpressions:!0,ignoreIfStatements:!0}],"@typescript-eslint/promise-function-async":"off","@typescript-eslint/restrict-template-expressions":"off","@typescript-eslint/return-await":["error","in-try-catch"],"comma-dangle":"off","import/no-duplicates":"error","import/order":"error","max-params":"off","no-console":["error",{allow:["error","debug"]}],"no-constant-condition":["error",{checkLoops:!1}],"no-unused-vars":"off","@typescript-eslint/no-unused-expressions":["error",{allowShortCircuit:!0,allowTernary:!0,allowTaggedTemplates:!0}],"lingui/no-expression-in-message":"off","prefer-const":"error","spaced-comment":["error","always",{markers:["/"]}],"lingui/t-call-in-function":2,"lingui/no-single-variables-to-translate":2,"lingui/no-single-tag-to-translate":2,"lingui/no-trans-inside-trans":2}},{files:["**/*.spec.ts","**/*.spec.tsx"],rules:{"@typescript-eslint/dot-notation":"off","@typescript-eslint/no-floating-promises":"off"}}];export const eslintrc=[...a];export const eslintrcReactWithStoryBook=[...a,...n.configs["flat/recommended"]];export const devLinguiEslintrcRules=[{files:["**/*.tsx"],ignores:["**/*.stories.tsx"],rules:{"lingui/no-unlocalized-strings":["error",{ignoreAttribute:["style","sx","onClick"],ignoreFunction:["styled","useMediaQuery","Error","sendMessage","useThemeProps","matchMedia","msg"],ignoreProperty:["gridTemplate","miscellaneousSlot","slot","reactiveMotionDiv","container","styled","useMediaQuery","Error","sendMessage","msg","i18n.load"]}]}}];

package/dist/prettier/index.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from 'prettier';
+export declare const prettierrc: Config;

package/dist/prettier/index.js

@@ -0,0 +1 @@
+import{createRequire as r}from"node:module";let t=r(import.meta.url);export const prettierrc={arrowParens:"avoid",importOrder:["^@salsita-ai/(.*)$","^#package/(.*)$","^[./]"],importOrderSeparation:!0,importOrderSortSpecifiers:!0,plugins:[t.resolve("@trivago/prettier-plugin-sort-imports")],printWidth:120,semi:!1,singleQuote:!0,tabWidth:2,trailingComma:"es5",useTabs:!1};

package/dist/utils/assert-existence.d.ts

@@ -0,0 +1,8 @@
+export declare class AssertionError extends Error {
+}
+/**
+ * Utility for typechecking of always defined value. Throws error if this condition is not met.
+ * Use this in situations where you always know the value is defined, but TSC can not tell that.
+ * Use with caution, in most cases you can solve the issue with union types.
+ */
+export declare const assertExistence: <Value>(value: Value | undefined | null, message?: string) => Value;

package/dist/utils/assert-existence.js

@@ -0,0 +1 @@
+export class AssertionError extends Error{}export const assertExistence=(r,e="Assertion failed, value is undefined or null")=>{if(null==r)throw new AssertionError(e);return r};

package/dist/utils/branded-types.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Using class prevents spreads, it enforces consistent usage of the type factory.
+ */
+export declare class Brand<T extends string> {
+    private readonly __brand;
+}
+export type Branded<K extends string, T> = Readonly<T> & Brand<K>;
+export type WithBrand<T> = T & Brand<never>;
+/**
+ * Utility for nominal typing. Use this to define domain types to fulfill invariants
+ * and prevent accidental mixing of types.
+ */
+export declare function Branded<T>(value: T): WithBrand<T>;

package/dist/utils/branded-types.js

@@ -0,0 +1 @@
+export class Brand{__brand}export function Branded(r){return r}

package/dist/utils/canonical-stringify.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Deterministic JSON serializer with sorted object keys at every level.
+ *
+ * `JSON.stringify` follows insertion order, so the same data could serialize differently after
+ * object spread, `Object.assign`, or a differently ordered YAML source. Sorting keys makes the
+ * output, and any hash derived from it, depend only on the data itself.
+ *
+ * Intended for JSON-like values: primitives, arrays, and plain objects.
+ */
+export declare const canonicalStringify: (value: unknown) => string;

package/dist/utils/canonical-stringify.js

@@ -0,0 +1 @@
+export const canonicalStringify=i=>null==i||"boolean"==typeof i||"number"==typeof i||"string"==typeof i?JSON.stringify(i):Array.isArray(i)?"["+i.map(canonicalStringify).join(",")+"]":"object"!=typeof i||null===i||Array.isArray(i)?JSON.stringify(i):"{"+Object.keys(i).sort().map(n=>JSON.stringify(n)+":"+canonicalStringify(i[n])).join(",")+"}";

package/dist/utils/colors.d.ts

@@ -0,0 +1,9 @@
+export type RalColor = `ral-${number}`;
+export type HexColor = `#${string}`;
+export type SimpleColor = 'white' | 'black' | 'red' | 'green' | 'blue' | 'yellow' | 'cyan' | 'magenta';
+export type Color = RalColor | HexColor | SimpleColor;
+export declare const isHexColor: (value: string) => value is HexColor;
+export declare const isRalColor: (value: string) => value is RalColor;
+export declare const isColor: (value: string) => value is Color;
+export declare const isSimpleColor: (value: string) => value is SimpleColor;
+export declare const simpleColorToHex: (color: SimpleColor) => "#000000" | "#0000ff" | "#00ff00" | "#00ffff" | "#ff0000" | "#ff00ff" | "#ffff00" | "#ffffff";

package/dist/utils/colors.js

@@ -0,0 +1 @@
+let e=/^#[0-9a-fA-F]{6}$/;export const isHexColor=f=>e.test(f);let f=/^ral-[0-9]+$/;export const isRalColor=e=>f.test(e);export const isColor=o=>e.test(o)||f.test(o)||isSimpleColor(o);export const isSimpleColor=e=>["white","black","red","green","blue","yellow","cyan","magenta"].includes(e);let o={white:"#ffffff",black:"#000000",red:"#ff0000",green:"#00ff00",blue:"#0000ff",yellow:"#ffff00",cyan:"#00ffff",magenta:"#ff00ff"};export const simpleColorToHex=e=>o[e];

package/dist/utils/composite-key-map.d.ts

@@ -0,0 +1,42 @@
+type MapConstructors<K extends any[]> = {
+    [INDEX in keyof K]: new () => MapLike<K[INDEX], unknown>;
+};
+interface MapLike<K, V> {
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+}
+/**
+ * Map-like structure that allows using composite keys.
+ *
+ * Under the hood, it uses a nested map structure - one level for each key in the composite key.
+ * Any of the levels can be represented by either a `WeakMap` or a `Map`. This makes
+ * it very useful for various caches with composite keys.
+ *
+ * **Example:**
+ * ```ts
+ * // define types of the keys and the underlying implementation for each level
+ * const map = new CompositeKeyMap<MyObject, string, MyOtherObject>([WeakMap, Map, WeakMap])
+ *
+ * // set a value
+ * map.set([myObject, 'abc', myOtherObject], 'value')
+ *
+ * // get a value
+ * const value = map.get([myObject, 'abc', myOtherObject])
+ *
+ * // check if a value exists
+ * const hasValue = map.has([myObject, 'abc', myOtherObject])
+ * ```
+ *
+ * Deletion is currently not supported, but can be implemented relatively easily.
+ */
+export declare class CompositeKeyMap<K extends any[], V> {
+    private readonly mapConstructors;
+    private readonly map;
+    constructor(mapConstructors: MapConstructors<K>);
+    private getLeafMap;
+    get(keys: K): V | undefined;
+    has(keys: K): boolean;
+    set(keys: K, value: V): this;
+}
+export {};

package/dist/utils/composite-key-map.js

@@ -0,0 +1 @@
+export class CompositeKeyMap{mapConstructors;map;constructor(t){this.mapConstructors=t;let e=t[0];this.map=new e}getLeafMap(t){return t.slice(0,-1).reduce((t,e)=>{if(void 0!==t)return t.get(e)},this.map)}get(t){let e=this.getLeafMap(t);return e?.get(t[t.length-1])}has(t){let e=this.getLeafMap(t);return e?.has(t[t.length-1])??!1}set(t,e){return t.slice(0,-1).reduce((t,e,s)=>{let r=t.get(e);if(void 0===r)r=new this.mapConstructors[s+1],t.set(e,r);else if(!(r instanceof WeakMap)&&!(r instanceof Map))throw Error(`Key ${e} is not a WeakMap or Map`);return r},this.map).set(t[t.length-1],e),this}}

package/dist/utils/console-logger.d.ts

@@ -0,0 +1,6 @@
+import { type LogLevel, type Logger } from './logger.js';
+/** Options controlling the console logger's initial filtering behavior. */
+export interface ConsoleLoggerOptions {
+    readonly level?: LogLevel;
+}
+export declare const initConsoleLogger: (options?: ConsoleLoggerOptions) => Logger;

package/dist/utils/console-logger.js

@@ -0,0 +1 @@
+import{isLogLevelEnabled as o}from"./logger.js";let e=(o,e,r)=>r?[o,e,r]:e?[o,e]:[o];export const initConsoleLogger=(r={})=>{let n=r.level??"info";return{info:(r,l,g)=>{o("info",n)&&console.log(...e(r,l,g))},error:(r,l,g)=>{o("error",n)&&console.error(...e(r,l,g))},warn:(r,l,g)=>{o("warn",n)&&console.warn(...e(r,l,g))},debug:(r,l,g)=>{o("debug",n)&&console.debug(...e(r,l,g))},verbose:(r,l,g)=>{o("debug",n)&&console.debug(...e(r,l,g))},appendToGlobalContext:()=>{}}};

package/dist/utils/create-selector.d.ts

@@ -0,0 +1,65 @@
+import type { Logger } from './logger.js';
+/**
+ * A function that takes a state and returns data derived from that state.
+ *
+ * Selectors are pure functions of the state and are composable — a selector can be used
+ * as an input of another selector created with `createSelector`, forming an explicit
+ * dependency graph where each node only recomputes when its own inputs change.
+ */
+declare const SELECTOR: unique symbol;
+export type Selector<STATE = any, RESULT = unknown> = ((state: STATE, ctx?: SelectorContext) => RESULT) & {
+    readonly [SELECTOR]: true;
+};
+export interface SelectorContext {
+    readonly logger: Logger;
+}
+/**
+ * An array of input selectors.
+ */
+export type SelectorArray<STATE = any> = readonly Selector<STATE>[];
+/**
+ * The callable shape of `createSelector`, mirroring reselect's `CreateSelectorFunction`
+ * (array-form signature only). `STATE` is `any` for the default instance and pinned by
+ * {@link CreateSelectorFunction.withTypes} — prefer the pinned form, it is what types the
+ * state parameter of selectors created by {@link CreateSelectorFunction.leaf}.
+ */
+export interface CreateSelectorFunction<STATE = any> {
+    /**
+     * Creates a memoized selector from a tuple of input selectors and a `combine` function.
+     *
+     * The inputs are typed as a reverse mapped tuple over the `combine` arguments — TS
+     * infers `ARGS` from whichever side is concrete first: a named `combine` function's
+     * parameters, or the input selectors' return types. This sidesteps the inference-order
+     * trap where a named combiner processed before the context-sensitive input lambdas
+     * fixes the input tuple to its constraint.
+     *
+     * @param inputs the input selectors; their results become the `combine` arguments
+     * @param combine computes the result from the input results
+     */
+    <ARGS extends readonly unknown[], RESULT>(inputs: {
+        readonly [INDEX in keyof ARGS]: Selector<STATE, ARGS[INDEX]>;
+    }, combine: (...args: ARGS) => RESULT): Selector<STATE, RESULT>;
+    /**
+     * Brands a pure state read so it can be composed as a selector input.
+     */
+    leaf<RESULT>(read: (state: STATE) => RESULT): Selector<STATE, RESULT>;
+    /**
+     * Creates a "pre-typed" version of {@link createSelector} with the state type
+     * predefined — input selectors then get their state parameter contextually typed, so
+     * `state => state.field` needs no annotation. Same as reselect's
+     * `createSelector.withTypes<RootState>()`.
+     *
+     * *Usage example:*
+     * ```ts
+     * const createAppSelector = createSelector.withTypes<AppState>()
+     *
+     * const selectVisibleTodos = createAppSelector(
+     *   [createAppSelector.leaf(state => state.todos), createAppSelector.leaf(state => state.filter)],
+     *   (todos, filter) => todos.filter(todo => matches(todo, filter))
+     * )
+     * ```
+     */
+    withTypes<OVERRIDE_STATE extends STATE>(): CreateSelectorFunction<OVERRIDE_STATE>;
+}
+export declare const createSelector: CreateSelectorFunction;
+export {};

package/dist/utils/create-selector.js

@@ -0,0 +1 @@
+import{isEqualArray as e}from"./is-equal-array.js";export const createSelector=Object.assign((r,t)=>{let l=null;return s=>{if(l&&l.state===s)return l.result;let a=r.map(e=>e(s));if(l&&e(l.args,a))return(l={state:s,args:a,result:l.result}).result;let u=t(...a);return l={state:s,args:a,result:u},u}},{leaf:e=>e,withTypes:()=>createSelector});

package/dist/utils/deep-partial.d.ts

@@ -0,0 +1,3 @@
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;

package/dist/utils/deep-partial.js

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

package/dist/utils/empty.d.ts

@@ -0,0 +1 @@
+export type Empty = Record<string, unknown>;

package/dist/utils/empty.js

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

package/dist/utils/extended-json-schema.d.ts

@@ -0,0 +1,15 @@
+import type { JSONSchema7 } from 'json-schema';
+export type ExtendedJsonSchema = JSONSchema7 & {
+    /**
+     * TypeScript type to be used in generated code instead of a type inferred from the schema.
+     */
+    tsType?: string;
+    /**
+     * Modules to import for the `tsType` to be a valid type expression.
+     */
+    import?: Array<{
+        module: string;
+        member: string;
+        doNotImportInto?: string[];
+    }>;
+};

package/dist/utils/extended-json-schema.js

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

package/dist/utils/index.d.ts

@@ -0,0 +1,30 @@
+export { isArray } from './is-array.js';
+export { isNonNullish } from './is-non-nullish.js';
+export { isShallowEqual } from './is-shallow-equal.js';
+export { isEqualArray } from './is-equal-array.js';
+export { isEqualNullish } from './is-equal-nullish.js';
+export { canonicalStringify } from './canonical-stringify.js';
+export type { OmitNever, OmitEmpty } from './omit.js';
+export { getStickyCache, createCacheToken, type StickyCache, type CacheToken } from './sticky-cache.js';
+export { type UnionToIntersection } from './union-to-intersection.js';
+export { type Color, type HexColor, type RalColor, isColor, isSimpleColor, isHexColor, isRalColor, simpleColorToHex, } from './colors.js';
+export { type ValueOf } from './value-of.js';
+export { Brand, Branded, type WithBrand } from './branded-types.js';
+export { type Empty } from './empty.js';
+export { assertExistence, AssertionError } from './assert-existence.js';
+export { usingType, usingNullishType, usingOptionalType } from './zod-types.js';
+export { type Logger, type LogLevel, isLogLevelEnabled } from './logger.js';
+export { initConsoleLogger, type ConsoleLoggerOptions } from './console-logger.js';
+export { isNonEmptyString } from './is-non-empty-string.js';
+export type { WithOptional } from './with-optional.js';
+export type { WithRequired } from './with-required.js';
+export { type Localizable, isMessageDescriptor, isMultilingualString, resolveLocalizable, type MultilingualString, MessageDescriptorSchema, EnhancedMessageDescriptorSchema, MultilingualStringSchema, LocalizableSchema, EnhancedLocalizableSchema, } from './localizable.js';
+export { type DeepPartial } from './deep-partial.js';
+export { InfoError } from './info-error.js';
+export { CompositeKeyMap } from './composite-key-map.js';
+export { memoOnce } from './memo-once.js';
+export { type ObservableWithLastValue, toObservableWithLastValue } from './observable-with-last-value.js';
+export { type ObjectWithKey, ObjectWithKeySchema } from './object-with-key.js';
+export { type ExtendedJsonSchema } from './extended-json-schema.js';
+export { tryOrDefault } from './try-or-default.js';
+export * from './create-selector.js';

package/dist/utils/index.js

@@ -0,0 +1 @@
+export{isArray}from"./is-array.js";export{isNonNullish}from"./is-non-nullish.js";export{isShallowEqual}from"./is-shallow-equal.js";export{isEqualArray}from"./is-equal-array.js";export{isEqualNullish}from"./is-equal-nullish.js";export{canonicalStringify}from"./canonical-stringify.js";export{getStickyCache,createCacheToken}from"./sticky-cache.js";export{isColor,isSimpleColor,isHexColor,isRalColor,simpleColorToHex}from"./colors.js";export{Brand,Branded}from"./branded-types.js";export{assertExistence,AssertionError}from"./assert-existence.js";export{usingType,usingNullishType,usingOptionalType}from"./zod-types.js";export{isLogLevelEnabled}from"./logger.js";export{initConsoleLogger}from"./console-logger.js";export{isNonEmptyString}from"./is-non-empty-string.js";export{isMessageDescriptor,isMultilingualString,resolveLocalizable,MessageDescriptorSchema,EnhancedMessageDescriptorSchema,MultilingualStringSchema,LocalizableSchema,EnhancedLocalizableSchema}from"./localizable.js";export{InfoError}from"./info-error.js";export{CompositeKeyMap}from"./composite-key-map.js";export{memoOnce}from"./memo-once.js";export{toObservableWithLastValue}from"./observable-with-last-value.js";export{ObjectWithKeySchema}from"./object-with-key.js";export{tryOrDefault}from"./try-or-default.js";export*from"./create-selector.js";

package/dist/utils/info-error.d.ts

@@ -0,0 +1,9 @@
+/**
+ * InfoError should serve as an Error class replacement
+ * for cases when you want to throw an error,
+ * but you don't want to report it as an actual aplication error.
+ */
+export declare class InfoError extends Error {
+    static name: string;
+    name: string;
+}

package/dist/utils/info-error.js

@@ -0,0 +1 @@
+export class InfoError extends Error{static name="InfoError";name="InfoError"}

package/dist/utils/is-array.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A variant of `Array.isArray` which also works on readonly arrays.
+ */
+export declare function isArray<T>(arg: readonly T[] | any): arg is readonly any[];
+/**
+ * A variant of `Array.isArray` which also works on readonly arrays.
+ */
+export declare function isArray<T>(arg: T[] | any): arg is any[];

package/dist/utils/is-array.js

@@ -0,0 +1 @@
+export function isArray(r){return Array.isArray(r)}

package/dist/utils/is-equal-array.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Check if two arrays are equal - i.e. same length and same elements in the same order.
+ *
+ * Provide a custom `isEqualElement` function to compare individual elements, defaults to `Object.is`.
+ */
+export declare function isEqualArray<T>(arrayA: T[] | readonly T[], arrayB: T[] | readonly T[], isEqualElement?: (a: T, b: T) => boolean): boolean;

package/dist/utils/is-equal-array.js

@@ -0,0 +1 @@
+export function isEqualArray(e,r,t=Object.is){return e===r||!!e&&!!r&&e.length===r.length&&e.every((e,n)=>t(e,r[n]))}

package/dist/utils/is-equal-nullish.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A convenience helper that allows to compare two values for equality, even if they are `null` or `undefined`.
+ *
+ * The provided `isEqualNonNullish` function is guaranteed to receive two non-nullish values.
+ */
+export declare const isEqualNullish: <T>(a: T, b: T, isEqualNonNullish: (a: NonNullable<T>, b: NonNullable<T>) => boolean) => boolean;

package/dist/utils/is-equal-nullish.js

@@ -0,0 +1 @@
+export const isEqualNullish=(l,u,n)=>l===u||null!=l&&null!=u&&n(l,u);

package/dist/utils/is-non-empty-string.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Type-guard for checking if values is at least 1 character long string.
+ *
+ * @param value value for checking
+ */
+export declare function isNonEmptyString(value: unknown): value is string;

package/dist/utils/is-non-empty-string.js

@@ -0,0 +1 @@
+export function isNonEmptyString(t){return"string"==typeof t&&t.length>0}

package/dist/utils/is-non-nullish.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A convenience type-guard for narrowing down array types through `.filter()`.
+ *
+ * @param value value that could eventually be `null` or `undefined`
+ */
+export declare function isNonNullish<T>(value: T): value is Exclude<T, null | undefined>;

package/dist/utils/is-non-nullish.js

@@ -0,0 +1 @@
+export function isNonNullish(n){return null!=n}

package/dist/utils/is-shallow-equal.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Check if two objects are **SHALLOW** equal - i.e. same keys and same values.
+ *
+ * Provide a custom `isEqualMember` function to compare individual members, defaults to `Object.is`.
+ *
+ * If the provided objects are arrays, the `isEqualArray` function is used to compare them.
+ */
+export declare function isShallowEqual<T>(objectA: T, objectB: T, isEqualMember?: (a: T[keyof T], b: T[keyof T]) => boolean): boolean;

package/dist/utils/is-shallow-equal.js

@@ -0,0 +1 @@
+import{isEqualArray as r}from"./is-equal-array.js";export function isShallowEqual(i,t,e=Object.is){if(Object.is(i,t))return!0;if(Array.isArray(i))return Array.isArray(t)&&r(i,t,e);if(null===i||null===t||"object"!=typeof i||"object"!=typeof t)return!1;for(let r in i)if(!(r in t)||!e(i[r],t[r]))return!1;for(let r in t)if(!(r in i)||!e(i[r],t[r]))return!1;return!0}

package/dist/utils/localizable.d.ts

@@ -0,0 +1,98 @@
+import type { I18n, MessageDescriptor } from '@lingui/core';
+export type MultilingualString = {
+    $lang: Record<string, string>;
+};
+export declare const MessageDescriptorSchema: {
+    readonly type: 'object';
+    readonly properties: {
+        readonly id: {
+            readonly type: 'string';
+        };
+        readonly comment: {
+            readonly type: 'string';
+        };
+        readonly message: {
+            readonly type: 'string';
+        };
+        readonly values: {
+            readonly type: 'object';
+            readonly additionalProperties: true;
+        };
+    };
+    readonly required: ["id"];
+    readonly additionalProperties: false;
+    readonly import: [{
+        readonly module: '@lingui/core';
+        readonly member: 'MessageDescriptor';
+    }];
+    readonly tsType: 'MessageDescriptor';
+};
+export declare const EnhancedMessageDescriptorSchema: {
+    readonly type: 'object';
+    readonly properties: {
+        readonly $msg: {
+            readonly type: 'string';
+        };
+        readonly $msgId: {
+            readonly type: 'string';
+        };
+    };
+    readonly required: ["$msg"];
+    readonly additionalProperties: false;
+    readonly import: [{
+        readonly module: '@lingui/core';
+        readonly member: 'MessageDescriptor';
+    }];
+    readonly tsType: 'EnhancedMessageDescriptor';
+};
+export type Localizable = string | MessageDescriptor | MultilingualString;
+export declare const isMessageDescriptor: <T>(message: T | MessageDescriptor) => message is MessageDescriptor;
+export declare const isMultilingualString: <T>(message: T | MultilingualString) => message is MultilingualString;
+export declare function resolveLocalizable(message: MessageDescriptor | MultilingualString, i18n: I18n, textLanguages?: readonly string[]): string;
+export declare function resolveLocalizable<T>(message: T | MessageDescriptor | MultilingualString, i18n: I18n, textLanguages?: readonly string[]): string | T;
+export declare const MultilingualStringSchema: {
+    readonly import: [{
+        readonly module: '@salsita-ai/sdk/common/utils';
+        readonly member: 'MultilingualString';
+    }];
+    readonly tsType: 'MultilingualString';
+    readonly type: 'object';
+    readonly properties: {
+        readonly $lang: {
+            readonly type: 'object';
+            readonly additionalProperties: {
+                readonly type: 'string';
+            };
+        };
+    };
+    readonly required: ["$lang"];
+    readonly additionalProperties: false;
+};
+export declare const LocalizableSchema: {
+    readonly anyOf: [{
+        readonly type: 'string';
+    }, {
+        readonly $ref: '#/definitions/MessageDescriptor';
+    }, {
+        readonly $ref: '#/definitions/MultilingualString';
+    }];
+    readonly import: [{
+        readonly module: '@salsita-ai/sdk/common/utils';
+        readonly member: 'Localizable';
+    }];
+    readonly tsType: 'Localizable';
+};
+export declare const EnhancedLocalizableSchema: {
+    readonly anyOf: [{
+        readonly type: 'string';
+    }, {
+        readonly $ref: '#/definitions/EnhancedMessageDescriptor';
+    }, {
+        readonly $ref: '#/definitions/MultilingualString';
+    }];
+    readonly import: [{
+        readonly module: '@salsita-ai/sdk/common/utils';
+        readonly member: 'EnhancedLocalizable';
+    }];
+    readonly tsType: 'EnhancedLocalizable';
+};

package/dist/utils/localizable.js

@@ -0,0 +1 @@
+export const MessageDescriptorSchema={type:"object",properties:{id:{type:"string"},comment:{type:"string"},message:{type:"string"},values:{type:"object",additionalProperties:!0}},required:["id"],additionalProperties:!1,import:[{module:"@lingui/core",member:"MessageDescriptor"}],tsType:"MessageDescriptor"};export const EnhancedMessageDescriptorSchema={type:"object",properties:{$msg:{type:"string"},$msgId:{type:"string"}},required:["$msg"],additionalProperties:!1,import:[{module:"@lingui/core",member:"MessageDescriptor"}],tsType:"EnhancedMessageDescriptor"};export const isMessageDescriptor=e=>"object"==typeof e&&null!==e&&"id"in e;export const isMultilingualString=e=>"object"==typeof e&&null!==e&&"$lang"in e;export function resolveLocalizable(e,i,t){if(isMessageDescriptor(e))return i._(e);if(isMultilingualString(e)){for(let r of[i.locale,...t??[],"en"]){let i=e.$lang[r];if(void 0!==i)return i}return""}return e}export const MultilingualStringSchema={import:[{module:"@salsita-ai/sdk/common/utils",member:"MultilingualString"}],tsType:"MultilingualString",type:"object",properties:{$lang:{type:"object",additionalProperties:{type:"string"}}},required:["$lang"],additionalProperties:!1};export const LocalizableSchema={anyOf:[{type:"string"},{$ref:"#/definitions/MessageDescriptor"},{$ref:"#/definitions/MultilingualString"}],import:[{module:"@salsita-ai/sdk/common/utils",member:"Localizable"}],tsType:"Localizable"};export const EnhancedLocalizableSchema={anyOf:[{type:"string"},{$ref:"#/definitions/EnhancedMessageDescriptor"},{$ref:"#/definitions/MultilingualString"}],import:[{module:"@salsita-ai/sdk/common/utils",member:"EnhancedLocalizable"}],tsType:"EnhancedLocalizable"};

package/dist/utils/logger.d.ts

@@ -0,0 +1,12 @@
+/** Minimum severity emitted by Phoenix loggers. Debug also enables verbose messages. */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface Logger {
+    info: (message: string, context?: object, error?: Error) => void;
+    error: (message: string, context?: object, error?: Error) => void;
+    warn: (message: string, context?: object, error?: Error) => void;
+    debug: (message: string, context?: object, error?: Error) => void;
+    verbose: (message: string, context?: object, error?: Error) => void;
+    appendToGlobalContext: (context: object) => void;
+}
+/** Returns whether a message passes the configured minimum severity. */
+export declare const isLogLevelEnabled: (messageLevel: LogLevel, configuredLevel: LogLevel) => boolean;

package/dist/utils/logger.js

@@ -0,0 +1 @@
+let e={debug:0,info:1,warn:2,error:3};export const isLogLevelEnabled=(o,r)=>e[o]>=e[r];

package/dist/utils/memo-once.d.ts

@@ -0,0 +1 @@
+export declare const memoOnce: <T>(factory: () => T) => () => T;

package/dist/utils/memo-once.js

@@ -0,0 +1 @@
+let e=Symbol("empty");export const memoOnce=t=>{let m=e;return()=>(m===e&&(m=t()),m)};

package/dist/utils/object-with-key.d.ts

@@ -0,0 +1,17 @@
+export interface ObjectWithKey {
+    key: string;
+}
+export declare const ObjectWithKeySchema: {
+    readonly type: 'object';
+    readonly properties: {
+        readonly key: {
+            readonly type: 'string';
+        };
+    };
+    readonly required: ["key"];
+    readonly import: [{
+        readonly module: '@salsita-ai/sdk/common/utils';
+        readonly member: 'ObjectWithKey';
+    }];
+    readonly tsType: 'ObjectWithKey';
+};

package/dist/utils/object-with-key.js

@@ -0,0 +1 @@
+export const ObjectWithKeySchema={type:"object",properties:{key:{type:"string"}},required:["key"],import:[{module:"@salsita-ai/sdk/common/utils",member:"ObjectWithKey"}],tsType:"ObjectWithKey"};

package/dist/utils/observable-with-last-value.d.ts

@@ -0,0 +1,9 @@
+import { type Observable } from 'rxjs';
+export interface ObservableWithLastValue<T> extends Observable<T> {
+    readonly value: T;
+}
+/**
+ * Creates an observable that has a last value property, initially set to the provided value.
+ * Once the observable emits a value, the last value will be updated to the latest emitted value.
+ */
+export declare const toObservableWithLastValue: <T, I>(observable: Observable<T>, initialValue: I) => ObservableWithLastValue<T | I>;

package/dist/utils/observable-with-last-value.js

@@ -0,0 +1 @@
+import{BehaviorSubject as e,share as t}from"rxjs";export const toObservableWithLastValue=(r,o)=>{let n=new e(o),a=t({connector:()=>n,resetOnRefCountZero:!0})(r);return Object.defineProperty(a,"value",{get:()=>n.value}),a};

package/dist/utils/omit.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Omit properties with `never` type from T
+ */
+export type OmitNever<T> = Pick<T, {
+    [K in keyof T]: T[K] extends never ? never : K;
+}[keyof T]>;
+/**
+ * Omit properties with empty objects as values from T
+ */
+export type OmitEmpty<T> = Pick<T, {
+    [K in keyof T]: Record<never, never> extends T[K] ? never : K;
+}[keyof T]>;

package/dist/utils/omit.js

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

package/dist/utils/sticky-cache.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A unique token that can be used to retrieve a sticky cache from a context object.
+ * The token carries type information about the cache's key and value types.
+ */
+export interface CacheToken<K, V> {
+    _k: K & never;
+    _v: V & never;
+}
+/**
+ * Creates a new cache token to be used with `getStickyCache`.
+ */
+export declare const createCacheToken: <K, V>() => CacheToken<K, V>;
+/**
+ * A cache that is sticky to a specific context object. It is useful for caching
+ * values on arbitrary objects, without these exposing the cache to the outside world
+ * or being aware of the cache's existence at all.
+ */
+export interface StickyCache<K, V> {
+    get(key: K): V | undefined;
+    put(key: K, value: V): void;
+}
+/**
+ * Retrieves a cache defined by the given token which is sticky to the given context object.
+ * If the cache does not exist yet, an empty one is created.
+ *
+ * @param context arbitrary object to which the cache is sticky
+ * @param token a token that uniquely identifies the cache, previously created with `createCacheToken`
+ */
+export declare const getStickyCache: <K, V>(context: object, token: CacheToken<K, V>) => StickyCache<K, V>;

package/dist/utils/sticky-cache.js

@@ -0,0 +1 @@
+export const createCacheToken=()=>({});let e=new WeakMap;export const getStickyCache=(t,a)=>{let n=e.get(t);n||(n=new WeakMap,e.set(t,n));let c=n.get(a);if(!c){let e;e=new Map,c={get:t=>e.get(t),put:(t,a)=>e.set(t,a)},n.set(a,c)}return c};

package/dist/utils/try-or-default.d.ts

@@ -0,0 +1 @@
+export declare const tryOrDefault: <T>(fn: () => T, defaultValue: T) => T;

package/dist/utils/try-or-default.js

@@ -0,0 +1 @@
+export const tryOrDefault=(r,t)=>{try{return r()}catch{return t}};

package/dist/utils/union-to-intersection.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Convert a union type to an intersection type.
+ *
+ * Useful for merging arbitrary number of object types:
+ * ```ts
+ * type MergeObjects<T extends object[]> = UnionToIntersection<T[number]>
+ *
+ * const array = [{a: 1}, {b: 2}, {c: 3}] as const
+ * type Merged = MergeObjects<typeof array> // {a: 1, b: 2, c: 3}
+ * ```
+ */
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;

package/dist/utils/union-to-intersection.js

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

package/dist/utils/value-of.d.ts

@@ -0,0 +1 @@
+export type ValueOf<T> = T[keyof T];

package/dist/utils/value-of.js

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

package/dist/utils/with-optional.d.ts

@@ -0,0 +1 @@
+export type WithOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/dist/utils/with-optional.js

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

package/dist/utils/with-required.d.ts

@@ -0,0 +1,3 @@
+export type WithRequired<TYPE, KEYS extends keyof TYPE> = TYPE & {
+    [PROPERTY in KEYS]-?: TYPE[PROPERTY];
+};

package/dist/utils/with-required.js

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

package/dist/utils/zod-types.d.ts

@@ -0,0 +1,18 @@
+import { type RefinementCtx } from 'zod';
+/**
+ * Utility function to run zod validation on custom type factor, use effectType: 'input' in openapi metadata
+ * to use the input type as a type to generate the openapi schema.
+ */
+export declare function usingType<T, V>(typeFactory: (arg: V) => T): (arg: V, ctx: RefinementCtx) => T;
+/**
+ * Utility function to run zod validation on custom type factor, use effectType: 'input' in openapi metadata
+ * to use the input type as a type to generate the openapi schema.
+ * It allows the input to be undefined.
+ */
+export declare function usingOptionalType<T, V>(typeFactory: (arg: V) => T): (arg: V | undefined, ctx: RefinementCtx) => T | undefined;
+/**
+ * Utility function to run zod validation on custom type factor, use effectType: 'input' in openapi metadata
+ * to use the input type as a type to generate the openapi schema.
+ * It allows the input to be undefined.
+ */
+export declare function usingNullishType<T, V>(typeFactory: (arg: V) => T): (arg: V | undefined | null, ctx: RefinementCtx) => T | null | undefined;

package/dist/utils/zod-types.js

@@ -0,0 +1 @@
+import{z as e}from"zod";export function usingType(s){return(r,o)=>{try{return s(r)}catch(s){return s instanceof Error?o.addIssue({code:e.ZodIssueCode.custom,message:s.message}):o.addIssue({code:e.ZodIssueCode.custom,message:"An unknown error occurred."}),e.NEVER}}}export function usingOptionalType(s){return(r,o)=>{if(void 0!==r)try{return s(r)}catch(s){return s instanceof Error?o.addIssue({code:e.ZodIssueCode.custom,message:s.message}):o.addIssue({code:e.ZodIssueCode.custom,message:"An unknown error occurred."}),e.NEVER}}}export function usingNullishType(s){return(r,o)=>{if(void 0!==r){if(null===r)return null;try{return s(r)}catch(s){return s instanceof Error?o.addIssue({code:e.ZodIssueCode.custom,message:s.message}):o.addIssue({code:e.ZodIssueCode.custom,message:"An unknown error occurred."}),e.NEVER}}}}

package/package.json

@@ -1,6 +1,98 @@
 {
   "name": "@salsita-ai/common",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.49.0-develop.d4bea2382c",
+  "description": "Shared Phoenix utilities, environment loading, and lint and formatting configuration.",
+  "keywords": [
+    "salsita",
+    "3d",
+    "configurator",
+    "phoenix"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    "./utils": {
+      "import": "./dist/utils/index.js",
+      "types": "./dist/utils/index.d.ts"
+    },
+    "./eslint": {
+      "import": "./dist/eslint/index.js",
+      "types": "./dist/eslint/index.d.ts"
+    },
+    "./prettier": {
+      "import": "./dist/prettier/index.js",
+      "types": "./dist/prettier/index.d.ts"
+    },
+    "./env": {
+      "import": "./dist/env/index.js",
+      "types": "./dist/env/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "@babel/core": "7.29.7",
+    "@babel/plugin-syntax-flow": "7.23.3",
+    "@babel/plugin-transform-react-jsx": "7.23.4",
+    "@eslint/js": "9.39.4",
+    "@trivago/prettier-plugin-sort-imports": "4.3.0",
+    "@types/json-schema": "7.0.15",
+    "dotenv": "17.4.2",
+    "dotenv-expand": "10.0.0",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-import": "2.32.0",
+    "eslint-plugin-jsx-a11y": "6.10.2",
+    "eslint-plugin-lingui": "0.13.1",
+    "eslint-plugin-lodash": "8.0.0",
+    "eslint-plugin-n": "18.0.1",
+    "eslint-plugin-promise": "7.3.0",
+    "eslint-plugin-react": "7.37.5",
+    "eslint-plugin-react-hooks": "6.0.0",
+    "eslint-plugin-storybook": "10.4.1",
+    "eslint-plugin-unused-imports": "4.4.1",
+    "find-up": "7.0.0",
+    "globals": "17.6.0",
+    "lodash-es": "4.18.1",
+    "typescript-eslint": "8.60.0",
+    "zod": "3.25.76"
+  },
+  "devDependencies": {
+    "@lingui/core": "5.9.5",
+    "@swc/cli": "0.8.1",
+    "@swc/core": "1.15.40",
+    "@types/babel__core": "7",
+    "@types/eslint": "9.6.1",
+    "@types/lodash-es": "4.17.12",
+    "@types/prettier": "2.7.1",
+    "envalid": "8.1.1",
+    "eslint": "9.39.4",
+    "prettier": "3.8.3",
+    "rxjs": "7.8.2",
+    "typescript": "npm:@typescript/typescript6@6.0.2",
+    "vitest": "4.1.11",
+    "@salsita-ai/common": "0.49.0-develop.d4bea2382c"
+  },
+  "peerDependencies": {
+    "envalid": "8.1.1",
+    "eslint": "9.39.4",
+    "prettier": "3.8.3",
+    "rxjs": "7.8.2"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc --project ./tsconfig.build.json --emitDeclarationOnly --checkers 1 && swc src --out-dir dist --strip-leading-paths && rm -f dist/utils/create-selector.type-check.d.ts",
+    "clean": "rm -rf dist && rm -rf node_modules",
+    "dev": "swc src --out-dir dist --watch --strip-leading-paths",
+    "transpile": "swc src --out-dir dist --strip-leading-paths",
+    "lint:check": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "prettify:check": "prettier --check .",
+    "prettify:fix": "prettier --write .",
+    "test": "vitest run",
+    "ts:check": "tsc --project ./tsconfig.build.json --noEmit --checkers 1"
+  }
 }