open-index/open-npm huggingface dataset:
npm package: @seij/common-services
Description: Shared service and text utilities used across Seij projects.
Latest version: 0.1.2

# common-services

Shared service and text utilities used across Seij projects.

## What it provides

- `Connection`: a small fetch wrapper that builds standard JSON headers, injects
  a bearer token when available, and normalizes error handling with `Problem`
  from `@seij/common-types`.
- `defaultConnection`: a reconfigurable singleton connection for apps that want
  a shared API entry point.
- `searchFilter` and `naturalize`: helpers for user-facing search (case/diacritic
  normalization and simple filtering across fields).
npm package: @seij/common-types
Description: Shared TypeScript primitives and utility types used across Seij projects, with a focus on business data and date/time handling.
Latest version: 0.1.5

# common-types

Shared TypeScript primitives and utility types used across Seij projects, with a
focus on business data and date/time handling.

## What it provides

- `Problem` and `toProblem` helpers to normalize errors into a consistent shape, following the [RFC 7807](https://tools.ietf.org/html/rfc7807) standard.
- `throwError` for inline error throwing with correct TypeScript control-flow
  typing.
- Date and time primitives and helpers for `LocalDate`, `LocalDateTime`, month
  and year utilities, and common formatting helpers (French locale, for now).
- Money, currency, percent, and numeric formatting helpers.
- Small data primitives like `Instant`, `Int`, `Long`, and `Month`.
npm package: @seij/common-ui
Description: Business-oriented UI components for Seij applications, built on React and designed to sit on top of Fluent UI while keeping a framework-agnostic direction for our other applications..
Latest version: 0.1.11

# @seij/common-ui

Business-oriented UI components for Seij applications, built on React and
designed to sit on top of Fluent UI while keeping a framework-agnostic direction
for our other applications..

## What it provides

- Application shell and navigation building blocks.
- Form layout primitives and input controls (text, select, numbers, dates,
  months, years, money, percent).
- Data display components (tables, list view, badges, tabs, info/error boxes).
- UX helpers like loaders, inline edit, error notifier, and button bar.
- Basic i18n utilities and locale resources (FR/EN).

## Notes

- This package exposes UI primitives rather than a full design system.
npm package: @seij/common-ui-auth
Description: UI utilities and tooling to manage authentication.
Latest version: 0.1.2

# common-ui-auth

UI utilities and tooling to manage authentication.

## Usage

### Configuration

```ts
import { createAuthenticationConfig } from "@seij/common-ui-auth";

const config = createAuthenticationConfig({
  authority: "https://oidc.mydomain.lan/realms/myrealm",
  client_id: "your client id",
  redirect_uri: yourAppBaseUrl + "/authentication-callback",
});
```

### Usage with APIs

Now, you can configure your API headers so send stored API token with headers.

```ts
import { ConnectionConfig, defaultConnection } from "@seij/common-services";

const apiConfig: ConnectionConfig = {
  apiBaseUrl: "/api/myapibaseurl",
  getApiAccessToken: authenticationConfig.getCurrentAccessToken,
};
defaultConnection.reconfigure(apiConfig);
```

### Usage with React

Place a provider around the area where authentication is needed. This will
provide
hooks to know connected (or not) user, as well as methods to signIn() or
signOut()
user.

```tsx
import { AuthenticationProvider, useAuthentication } from "@seij/common-ui-auth";

export function App() {
  return (
    <AuthenticationProvider {...config}>
      <MyScreen />
    </AuthenticationProvider>
  );
}

export function MyScreen() {
  const authentication = useAuthentication();
  return (
    <div>
      <div>Is authenticated: {authentication.isAuthenticated}</div>
      <div>Is loading: {authentication.isLoading}</div>
      <div>Is error: {authentication.isError}</div>
      <div>Error: {authentication.error}</div>
      <div>User display name: {authentication.userDisplayName}</div>
      <div>
        <button onClick={() => authentication.signIn()}>Sign in</button>
        <button onClick={() => authentication.signOut()}>Sign out</button>
      </div>
    </div>
  );
}
```

We provide Views to display common displays depending on user state.

- `AuthenticationCallbackView` that you should bind to /authentication-callback
- `AuthenticationLoginView` that you should bind to /authentication-login
- `AuthenticationLogoutView` that you should bind to /authentication-logout
- `AuthenticationStatusView` that you should display when user tries to access a
  page that required authentication. Displays the current status of
  authentication process and, if user is not authenticated, a message to help
  him do so.

## Usage with @seij/common-ui's ApplicationShell

We also provide `ApplicationShellSecured`, an extension to `@seij/common-ui`'s
`ApplicationShell` that

- binds user status to the Shell (displays username, loading status, buttons to
  sign in/out)
- protects the main area if user displaying `NotAuthenticatedView` when
  necessary
- filters out navigation items (the menu items) to remove all those not
  permitted by the current user status or roles

## Paths

We provide standard paths for login, logout and callback pages:

- `AuthenticationPaths.callback`
- `AuthenticationPaths.login`
- `AuthenticationPaths.logout`

## Internationalization

Uses `common-ui` default internationalization features and plugs its translations
as a namespace.
npm package: @seij/common-ui-csv-export
Description: This library was generated with [Nx](https://nx.dev).
Latest version: 0.1.1

# common-types

This library was generated with [Nx](https://nx.dev).

## Building

Run `nx build common-types` to build the library.

## Running unit tests

Run `nx test common-types` to execute the unit tests via [Vitest](https://vitest.dev/).
npm package: @seij/common-ui-markdown
Description: Markdown rendering component for Seij UIs, with support for syntax highlighting and math.
Latest version: 0.1.2

# common-ui-markdown

Markdown rendering component for Seij UIs, with support for syntax highlighting
and math.

## Usage

```tsx
import { Markdown } from "@seij/common-ui-markdown";
import "@seij/common-ui-markdown/styles";

export function HelpPanel() {
  return <Markdown>{`# Title\n\nSome **markdown** here.`}</Markdown>;
}
```

## What it provides

- `Markdown` React component built on `react-markdown`.
- GitHub-flavored markdown and math support via `remark-gfm` and `remark-math`.
- Syntax highlighting and KaTeX rendering via `rehype-highlight` and `rehype-katex`.
- Safe HTML handling with `rehype-sanitize` (custom schema for code, links, and images).
- Optional style imports for highlight.js and KaTeX via `styles.ts`.

## Supported markdown features

- Headings, emphasis, lists, blockquotes, and tables (GFM).
- Inline code and fenced code blocks with language highlighting.
- Task lists and strikethrough (GFM).
- Links (opened in a new tab) and images (lazy-loaded).
- Inline and block math (KaTeX).
npm package: @seij/entity-storage
Description: Runtime storage layer for entity instances, designed to pair with `entity-graph`. While `entity-graph` describes _what_ exists (entities, properties, relationships), `entity-storage` defines _how_ to fetch, search, create, update, and delete the actual da
Latest version: 0.1.2

# entity-storage

Runtime storage layer for entity instances, designed to pair with
`entity-graph`. While `entity-graph` describes _what_ exists (entities,
properties, relationships), `entity-storage` defines _how_ to fetch, search,
create, update, and delete the actual data.

## What it provides

- A contribution-based registry for entity storage implementations.
- A single service (`EntityStorageService`) to route CRUD operations by entity
  name.
- DTOs for list, pagination, and single-item responses.
- Query key helpers to support cache invalidation (e.g., React Query).
- Optional mapping helpers for aggregate fetch results.

## What it is (and how it differs from usual approaches)

Most applications hardcode a repository or API client per entity, tied to a
single backend and a fixed schema. This module is different: it routes data
access by `entityName` at runtime, using contributions that can come from
multiple bounded contexts. That makes it a storage _platform_ rather than a
collection of static services.

The real power comes from its link to `entity-graph`: the graph tells the UI
what entities exist and how they relate; the storage tells the UI where to fetch
and mutate the data. Together, they turn a dynamic domain model into a working
dynamic UI without hardcoding endpoints or per-entity services.

Concrete outcomes: fewer per-entity repositories, consistent data access across
domains, and faster delivery of baseline screens (lists, detail, edit).

## Why it matters

- Separates _model discovery_ (entity-graph) from _data access_ (entity-storage).
- Lets multiple backends or storage strategies coexist behind one API.
- Enables dynamic UI to load and mutate entity data without hardcoding
  endpoints.
- Provides consistent cache keys and invalidation hooks across entities.

## How it works

- Extensions contribute a storage implementation per entity name.
- The storage exposes `fetchItem`, `search`, `createItem`, `updateItemProperty`,
  and `deleteItem`.
- The service resolves the right store by entity name and forwards calls.
- Additional invalidation keys can be contributed for cross-query consistency.
npm package: @seij/entity-validation
Description: Work in progress: validation layer that uses `entity-graph` and the type system to validate entity instances at differnt stages of their lifecycle.
Latest version: 0.1.2

# entity-validation

Work in progress: validation layer that uses `entity-graph` and the type system
to validate entity instances at differnt stages of their lifecycle.

## What it provides today

- A service that resolves an entity definition from `entity-graph`.
- Validation functions for properties marked as `create`.
- Delegation of validation to type extensions (when available).

## Status

This module is still evolving. The current surface is minimal and focused on
creation validation only. Expect API changes and missing coverage for other
validation flows.

## Relationship to entity-graph

- `entity-graph` defines the model and property metadata.
- `entity-validation` uses that metadata to run type-driven validation.
npm package: @seij/extension-tooling
Description: Small utilities used by [@seij/extension-platform](../extension-platform/Readme.md) and extension modules.
Latest version: 0.1.2

# @seij/extension-tooling

Small utilities used by [@seij/extension-platform](../extension-platform/Readme.md) and extension modules.

## What it provides

- `errorOnDuplicates`: throws when duplicate keys are detected.
- `searchOnDuplicates`: detects duplicates and reports them through a callback.