@primeui/license-manager 1.0.0-alpha.1

package/LICENSE.md

@@ -0,0 +1,62 @@
+# PrimeUI License Manager — License
+
+Copyright © 2026 PrimeTek Informatics. All rights reserved.
+
+This package (`@primeui/license-manager`) is proprietary software owned by
+PrimeTek Informatics ("PrimeTek"). It is distributed in compiled form via the
+public npm registry solely to enable license verification for PrimeUI and
+PrimeUI PRO products.
+
+## Grant
+
+PrimeTek grants you a non-exclusive, non-transferable, revocable license to
+install and use this package as a runtime dependency of your application, for
+the sole purpose of verifying license tokens issued by PrimeTek for PrimeUI and
+PrimeUI PRO products.
+
+## Restrictions
+
+You may not:
+
+1. Modify, adapt, translate, or create derivative works of this package, in
+   source or compiled form, including bundled copies in your own published
+   packages.
+2. Reverse engineer, decompile, disassemble, or otherwise attempt to derive the
+   source code of, or to circumvent, the license verification mechanism — except
+   to the limited extent applicable law expressly permits despite this
+   restriction.
+3. Forge, tamper with, replay across customers, or otherwise misuse license
+   tokens or signing keys.
+4. Sublicense, sell, rent, lease, lend, or otherwise redistribute this package
+   as a standalone product or as part of a competing license-management
+   offering.
+5. Remove or alter any copyright, trademark, or proprietary notices contained
+   in the package or its accompanying files.
+
+## Ownership
+
+This package, including all intellectual property rights in it, remains the
+exclusive property of PrimeTek. No rights are granted to you by implication,
+estoppel, or otherwise except as expressly set out in this license.
+
+## Open Source Components
+
+This package depends on third-party open source software, including
+[`@noble/ed25519`](https://github.com/paulmillr/noble-ed25519) (MIT). Those
+dependencies are governed by their own license terms, which are unaffected by
+this license.
+
+## No Warranty
+
+THIS PACKAGE 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 NONINFRINGEMENT. IN NO EVENT SHALL
+PRIMETEK BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION
+WITH THIS PACKAGE OR THE USE OR OTHER DEALINGS IN IT.
+
+## Termination
+
+This license terminates automatically if you breach any of its terms. On
+termination you must cease all use of the package and remove it from your
+systems and distributions.

package/README.md

@@ -0,0 +1,167 @@
+# @primeui/license-manager
+
+Offline license verifier for PrimeUI and PrimeUI PRO. Framework-agnostic — no Vue / React / Angular / Lit peer dependencies.
+
+License keys are configured **once** at app bootstrap into a process-global registry. Every PrimeUI library and PrimeUI PRO component then reads from the same registry — no `licenseKey` prop on individual components, no second installer to wrap.
+
+## App authors
+
+If you use a Prime UI library (PrimeVue, PrimeReact, PrimeNG, PrimeFaces), pass your PrimeUI license token through that library's existing installer as a single string — it forwards it into this registry for you. You don't import this package directly in that case.
+
+```ts
+// PrimeVue
+app.use(PrimeVue, { theme: { ... }, license: 'PrimeUI-Commercial-key...' });
+
+// PrimeReact
+<PrimeReactProvider value={{ theme: { ... }, license: 'PrimeUI-Commercial-key...' }}>
+
+// PrimeNG
+providePrimeNG({ theme: { ... }, license: 'PrimeUI-Commercial-key...' });
+```
+
+A Commercial or OEM PrimeUI license covers every PRO component via the bundle rule, so this single string is enough for most apps.
+
+If you're mixing standalone PRO buys, or using PRO components without a host Prime library, register the keys yourself before any licensed component mounts:
+
+```ts
+import { registerLicense } from '@primeui/license-manager';
+
+registerLicense({
+    primeui: 'PrimeUI-Commercial-key...',
+    texteditor: 'PrimeUI-PRO-TextEditor-key...',
+    scheduler: 'PrimeUI-PRO-Scheduler-key...'
+});
+```
+
+Standalone PRO buyers configure the specific PRO key without a `primeui` key:
+
+```ts
+registerLicense({ texteditor: 'PrimeUI-PRO-TextEditor-key...' });
+```
+
+## PrimeUI PRO component authors
+
+Inside your component, call `verifyLicense()` at mount time and surface a watermark when invalid.
+
+```ts
+import { verifyLicense } from '@primeui/license-manager';
+import { RELEASE_DATE } from './release-date';
+
+onMounted(async () => {
+    const result = await verifyLicense('texteditor', { releaseDate: RELEASE_DATE });
+    if (!result.valid) console.warn(`[PrimeUI TextEditor] ${result.message}`);
+    licenseResult.value = result;
+});
+```
+
+Verification is async (Ed25519 via WebCrypto). Do it on client mount, not during SSR render — license status is a UI concern, not a server-render concern, and threading async work into SSR is fragile.
+
+## Prime library authors (PrimeVue / PrimeReact / PrimeNG integration)
+
+Add `license?: string` to your installer's config and forward it to `registerLicense({ primeui: ... })` from the install hook. The user passes one token; you wire it into the registry.
+
+```ts
+// Sketch — inside PrimeVue's install hook
+import { registerLicense } from '@primeui/license-manager';
+
+export const PrimeVue = {
+    install(app, options) {
+        if (options?.license) registerLicense({ primeui: options.license });
+        // ... rest of PrimeVue setup
+    }
+};
+```
+
+For a host-scoped service (rather than the global registry), use `createLicenseService` directly:
+
+```ts
+import { createLicenseService } from '@primeui/license-manager';
+
+const service = createLicenseService({ primeui: options.license });
+// stash in PrimeVue's own provide/inject so consumers can read it via usePrimeVue().license
+```
+
+## Short names → product identifiers
+
+The `keys` object accepts these short names:
+
+| Short name    | Product identifier         | Covers                                       |
+| ------------- | -------------------------- | -------------------------------------------- |
+| `primeui`     | `primeui`                  | PrimeNG / PrimeVue / PrimeReact / PrimeFaces |
+| `texteditor`  | `primeui-pro:text-editor`  | PRO Text Editor                              |
+| `scheduler`   | `primeui-pro:scheduler`    | PRO Scheduler                                |
+| `charts`      | `primeui-pro:charts`       | PRO Charts                                   |
+| `diagram`     | `primeui-pro:diagram`      | PRO Diagram                                  |
+| `pdfviewer`   | `primeui-pro:pdf-viewer`   | PRO PDF Viewer                               |
+| `taskboard`   | `primeui-pro:task-board`   | PRO Task Board                               |
+| `datagrid`    | `primeui-pro:datagrid`     | PRO DataGrid                                 |
+| `ganttchart`  | `primeui-pro:gantt-chart`  | PRO Gantt                                    |
+| `filemanager` | `primeui-pro:file-manager` | PRO File Manager                             |
+
+The registry first looks up the specific short name. If that key is missing (or returns `wrong-product`), it falls back to `keys.primeui` for any PRO component request. The verifier then accepts that token if its `tier` is `'commercial'`. Community PrimeUI tokens never validate PRO requests.
+
+## License Tier + Type
+
+Each signed `primeui` token carries two claims:
+
+- `tier` — the SKU: `community` (free) or `commercial` (paid).
+- `type` — the usage model: `dev` (standard) or `oem` (redistribution).
+
+PRO tokens omit `tier` and carry `type: 'dev'` or `type: 'oem'`.
+
+| Tier         | Type  | Behavior                                                                                   |
+| ------------ | ----- | ------------------------------------------------------------------------------------------ |
+| `community`  | `dev` | Free, eligibility-gated. Annual re-confirmation. Time-bound (wall-clock grace).            |
+| `commercial` | `dev` | Paid perpetual. Library keeps working forever; only versions released after `exp` blocked. |
+| `commercial` | `oem` | Paid annual redistribution license. Time-bound (wall-clock grace).                         |
+
+Any token with `tier === 'commercial'` unlocks the PRO bundle rule. Community does not.
+
+## Result
+
+```ts
+interface VerifyResult {
+    valid: boolean; // true when status is 'active' or 'grace'
+    status: 'active' | 'grace' | 'expired' | 'invalid' | 'wrong-product' | 'tampered' | 'unconfigured' | 'missing';
+    daysUntilExpiry?: number;
+    payload?: LicensePayload;
+}
+```
+
+| status          | meaning                                                              |
+| --------------- | -------------------------------------------------------------------- |
+| `active`        | Verified, not yet expired                                            |
+| `grace`         | Expired but within the 30-day grace period — library still works     |
+| `expired`       | Past the grace period (or version released after `exp`) — red banner |
+| `wrong-product` | Signed token doesn't cover the requested product                     |
+| `tampered`      | Signature check failed                                               |
+| `invalid`       | Malformed token                                                      |
+| `missing`       | No key configured for this product (and no `primeui` fallback)       |
+| `unconfigured`  | `registerLicense` was never called                                   |
+
+`grace` is a 30-day window after expiry — library remains functional, caller should surface a warning.
+
+## SSR
+
+Module-scoped state is the correct primitive for license keys (build-time config, not request-time). Under SSR:
+
+- The host's installer re-runs per request and calls `registerLicense` again — idempotent with the same keys.
+- PRO components defer the `verifyLicense` call to client-side mount (`onMounted` / `useEffect` / `ngOnInit`), not the SSR render pass. No watermark is rendered server-side; it appears after hydration if invalid.
+
+## Low-level `verify()`
+
+If you're verifying a single token without the registry:
+
+```ts
+import { verify } from '@primeui/license-manager';
+
+const result = await verify(token, { product: 'primeui-pro:scheduler', releaseDate: '2026-04-23' });
+```
+
+## Keygen (internal, not for consumers)
+
+```
+pnpm --filter @primeui/license-manager keygen
+```
+
+Paste `PRIVATE_KEY` into the store server env, embed `PUBLIC_KEY` in `src/constants.ts`, then publish.

package/dist/index.d.mts

@@ -0,0 +1,187 @@
+/**
+ * SKU (tier) and usage model (type) on each license token. Two orthogonal
+ * fields on the store side:
+ *
+ * - `tier` answers "which SKU?": `community` (free) or `commercial` (paid).
+ *   Only present on `product: 'primeui'` tokens; absent on PRO tokens.
+ * - `type` answers "what usage?": `dev` (standard) or `oem` (redistribution).
+ */
+type LicenseTier = 'community' | 'commercial';
+type LicenseType = 'dev' | 'oem';
+type LicenseStatus = 'active' | 'grace' | 'expired' | 'invalid' | 'wrong-product' | 'tampered' | 'unconfigured' | 'missing';
+/**
+ * Short names customers use when configuring licenses. Each maps to a full
+ * product identifier via `PRODUCT_MAP`.
+ */
+type LicenseShortName = 'primeui' | 'scheduler' | 'texteditor' | 'charts' | 'diagram' | 'pdfviewer' | 'taskboard' | 'datagrid' | 'ganttchart' | 'filemanager';
+/**
+ * Config the customer passes once at app bootstrap. Each entry holds one
+ * license token. When a PRO component request is made and the specific PRO
+ * key is missing, the registry falls back to `keys.primeui` — the verifier's
+ * bundle rule then accepts that token if its `tier` is `'commercial'`.
+ */
+type LicenseKeys = Partial<Record<LicenseShortName, string>>;
+interface LicensePayload {
+    /** License key UUID from the store database. */
+    id: string;
+    /** Product identifier — 'primeui' or 'primeui-pro:<component>'. */
+    product: string;
+    /** SKU on primeui products: community or commercial. Absent on PRO tokens. */
+    tier?: LicenseTier;
+    /** Usage model: dev (standard) or oem (redistribution). */
+    type: LicenseType;
+    /** Issued-at unix seconds. */
+    iat: number;
+    /** Expiry unix seconds — matches update_ends_at. */
+    exp: number;
+}
+interface VerifyOptions {
+    /** The product this caller expects — e.g. 'primeui' or 'primeui-pro:scheduler'. */
+    product: string;
+    /** Display name used in the returned `message` — defaults to 'PrimeUI'. */
+    productLabel?: string;
+    /**
+     * Release date of the package performing the check. ISO string ('2026-04-23')
+     * or unix seconds. Tokens whose `exp` is older than this date are rejected,
+     * which is how perpetual licenses are enforced: new versions released after
+     * the updates window aren't covered.
+     */
+    releaseDate?: string | number;
+    /** Grace period in days after exp. Defaults to 30. Community / OEM only. */
+    graceDays?: number;
+    /** Override the embedded public key for dev/test builds. */
+    publicKeyOverride?: string;
+}
+interface VerifyResult {
+    /** true when status is 'active' or 'grace'. */
+    valid: boolean;
+    status: LicenseStatus;
+    /** Human-readable message suitable for display in a banner or console.warn. */
+    message: string;
+    /** Days until exp, can be negative if past exp. Only set when payload decoded. */
+    daysUntilExpiry?: number;
+    /** Decoded payload, only when signature verified. */
+    payload?: LicensePayload;
+}
+/**
+ * Optional second argument to {@link registerLicense} / `createLicenseService`.
+ * Dev/test escape hatches; production callers leave it off.
+ */
+interface LicenseConfig {
+    /** Override grace period in days (default 30). */
+    graceDays?: number;
+    /** Override the embedded public key for dev/test builds. */
+    publicKeyOverride?: string;
+}
+interface LicenseVerifyOptions {
+    /** Release date of the calling package. ISO string or unix seconds. */
+    releaseDate?: string | number;
+}
+/**
+ * The thing PRO components and Prime libraries consume. Resolved either via
+ * {@link getLicenseService} (after a host called {@link registerLicense}) or
+ * built ad-hoc with {@link createLicenseService}.
+ */
+interface LicenseService {
+    /**
+     * Verify the license for a given short product name (e.g. 'texteditor').
+     * Falls back to `keys.primeui` for PRO components when the specific PRO key
+     * is missing — the verifier's bundle rule accepts a Commercial / OEM
+     * PrimeUI token for any PRO component request. Pass the calling package's
+     * `releaseDate` so perpetual licenses are enforced against version dates,
+     * not wall-clock time.
+     */
+    verify(short: LicenseShortName, options?: LicenseVerifyOptions): Promise<VerifyResult>;
+    /** Whether any key is configured for this product (exact OR primeui bundle fallback). */
+    has(short: LicenseShortName): boolean;
+}
+
+declare function verify(token: string, options: VerifyOptions): Promise<VerifyResult>;
+
+/**
+ * Build a framework-agnostic license service from a keys object. Used by
+ * {@link registerLicense} for the process-global registry, and exported
+ * directly for hosts that want to manage their own service instance (e.g. a
+ * Prime library that scopes licenses to its own provider).
+ *
+ * `config` is optional and only used for dev/test overrides.
+ */
+declare function createLicenseService(keys: LicenseKeys, config?: LicenseConfig): LicenseService;
+
+/**
+ * Register license keys with the process-global registry. Typically called by
+ * a host Prime library's installer (PrimeVue plugin, `providePrimeNG`,
+ * `<PrimeReactProvider>`), or directly by standalone PRO consumers before any
+ * licensed component mounts.
+ *
+ * ```ts
+ * registerLicense({
+ *     primeui: 'PrimeUI-Commercial-key...',
+ *     texteditor: 'PrimeUI-PRO-TextEditor-key...'
+ * });
+ * ```
+ *
+ * Multiple calls overwrite — last call wins. Idempotent re-registration with
+ * the same keys (the common SSR / HMR case) is a no-op as far as consumers see.
+ *
+ * `config` is optional and only used for dev/test overrides.
+ */
+declare function registerLicense(keys: LicenseKeys, config?: LicenseConfig): LicenseService;
+/**
+ * Retrieve the registered license service. Returns `null` when no host has
+ * called {@link registerLicense} yet — consumers should treat that as the
+ * `unconfigured` status.
+ */
+declare function getLicenseService(): LicenseService | null;
+/**
+ * Verify a short product name against the global registry. Returns the
+ * `unconfigured` status if {@link registerLicense} has not been called.
+ *
+ * This is the entry point PRO components call at mount time:
+ *
+ * ```ts
+ * const result = await verifyLicense('scheduler', { releaseDate: __BUILD_DATE__ });
+ * if (!result.valid) showWatermark(result);
+ * ```
+ */
+declare function verifyLicense(short: LicenseShortName, options?: LicenseVerifyOptions): Promise<VerifyResult>;
+
+/**
+ * Grace period, in days, that extends past `exp`. Within this window the
+ * verifier returns status `grace` — library still works, but callers should
+ * surface a warning in the UI.
+ */
+declare const GRACE_DAYS = 30;
+/** Canonical product identifier for the PrimeUI core libraries. */
+declare const PRIMEUI_PRODUCT = "primeui";
+/** Prefix for individual PRO component product identifiers. */
+declare const PRIMEUI_PRO_PREFIX = "primeui-pro:";
+/**
+ * Maps each customer-facing short key to the canonical product identifier
+ * embedded in signed license tokens. Framework adapters look here.
+ */
+declare const PRODUCT_MAP: {
+    readonly primeui: "primeui";
+    readonly scheduler: "primeui-pro:scheduler";
+    readonly texteditor: "primeui-pro:text-editor";
+    readonly charts: "primeui-pro:charts";
+    readonly diagram: "primeui-pro:diagram";
+    readonly pdfviewer: "primeui-pro:pdf-viewer";
+    readonly taskboard: "primeui-pro:task-board";
+    readonly datagrid: "primeui-pro:datagrid";
+    readonly ganttchart: "primeui-pro:gantt-chart";
+    readonly filemanager: "primeui-pro:file-manager";
+};
+
+/**
+ * Human-readable display name for each short name. Adapters use this to feed
+ * `productLabel` into the core verifier so the returned `message` is pretty.
+ */
+declare const SHORT_NAME_LABELS: Record<LicenseShortName, string>;
+/**
+ * Produce a standard human-readable message for a license status. Consumers
+ * don't usually call this — it's applied automatically to every `VerifyResult`.
+ */
+declare function formatLicenseMessage(status: LicenseStatus, productLabel?: string): string;
+
+export { GRACE_DAYS, type LicenseConfig, type LicenseKeys, type LicensePayload, type LicenseService, type LicenseShortName, type LicenseStatus, type LicenseTier, type LicenseType, type LicenseVerifyOptions, PRIMEUI_PRODUCT, PRIMEUI_PRO_PREFIX, PRODUCT_MAP, SHORT_NAME_LABELS, type VerifyOptions, type VerifyResult, createLicenseService, formatLicenseMessage, getLicenseService, registerLicense, verify, verifyLicense };

package/dist/index.mjs

@@ -0,0 +1 @@
+import*as e from"@noble/ed25519";var r=Object.defineProperty,t=Object.getOwnPropertySymbols,i=Object.prototype.hasOwnProperty,n=Object.prototype.propertyIsEnumerable,a=(e,t,i)=>t in e?r(e,t,{enumerable:!0,configurable:!0,writable:!0,value:i}):e[t]=i,o=(e,r,t)=>new Promise((i,n)=>{var a=e=>{try{u(t.next(e))}catch(e){n(e)}},o=e=>{try{u(t.throw(e))}catch(e){n(e)}},u=e=>e.done?i(e.value):Promise.resolve(e.value).then(a,o);u((t=t.apply(e,r)).next())});function u(e){const r={};for(let e=0;e<64;e++)r["ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"[e]]=e;const t=e.replace(/=+$/,""),i=Math.floor(6*t.length/8),n=new Uint8Array(i);let a=0,o=0,u=0;for(let e=0;e<t.length;e++){const i=r[t[e]];if(void 0===i)throw new Error("Invalid base64url character");a=a<<6|i,o+=6,o>=8&&(o-=8,n[u++]=a>>o&255)}return n}var c=30,s="primeui",l="primeui-pro:",d={primeui:"primeui",scheduler:"primeui-pro:scheduler",texteditor:"primeui-pro:text-editor",charts:"primeui-pro:charts",diagram:"primeui-pro:diagram",pdfviewer:"primeui-pro:pdf-viewer",taskboard:"primeui-pro:task-board",datagrid:"primeui-pro:datagrid",ganttchart:"primeui-pro:gantt-chart",filemanager:"primeui-pro:file-manager"},p={primeui:"PrimeUI",scheduler:"Scheduler",texteditor:"TextEditor",charts:"Charts",diagram:"Diagram",pdfviewer:"PDF Viewer",taskboard:"Task Board",datagrid:"DataGrid",ganttchart:"Gantt",filemanager:"File Manager"};function f(e,r="PrimeUI"){switch(e){case"active":return`${r} license is active.`;case"grace":return`${r} license is in its grace period. Renew soon to keep using this version.`;case"expired":return`${r} license does not cover this version. Renew at primeui.store, or downgrade to a version released within your updates window.`;case"tampered":return`${r} license signature is invalid.`;case"wrong-product":return`License does not cover ${r}.`;case"missing":return`No license key configured for ${r}.`;case"invalid":return`${r} license is malformed.`;case"unconfigured":return`${r} license is not configured.`;default:return`${r} license status unknown.`}}var m=864e5;function y(e,r,o={}){return((e,r)=>{for(var o in r||(r={}))i.call(r,o)&&a(e,o,r[o]);if(t)for(var o of t(r))n.call(r,o)&&a(e,o,r[o]);return e})({valid:"active"===e||"grace"===e,status:e,message:f(e,r)},o)}function g(r,t){return o(this,null,function*(){var i,n;const a=t.productLabel;if("string"!=typeof r||!r.includes("."))return y("invalid",a);const o=r.split(".");if(2!==o.length)return y("invalid",a);const[c,d]=o;let p,f,g;try{p=function(e){const r=u(e),t=(new TextDecoder).decode(r);return JSON.parse(t)}(c)}catch(e){return y("invalid",a)}if(!p||"object"!=typeof p||"string"!=typeof p.product||"string"!=typeof p.type||"number"!=typeof p.exp||"number"!=typeof p.iat||"string"!=typeof p.id)return y("invalid",a);try{f=u(d),g=(new TextEncoder).encode(c)}catch(e){return y("invalid",a)}const v=null!=(i=t.publicKeyOverride)?i:"dae75e66b9f59bebf87d4bb29ca6494f37deccfcc2b132b98ee159ee7505373b";let h;try{h=function(e){if(e.length%2!=0)throw new Error("Invalid hex length");const r=new Uint8Array(e.length/2);for(let t=0;t<r.length;t++)r[t]=parseInt(e.substr(2*t,2),16);return r}(v)}catch(e){return y("invalid",a)}let b=!1;try{b=yield e.verifyAsync(f,g,h)}catch(e){return y("tampered",a,{payload:p})}if(!b)return y("tampered",a,{payload:p});if(!function(e,r){return e.product===r||!(!r.startsWith(l)||e.product!==s||"commercial"!==e.tier)}(p,t.product))return y("wrong-product",a,{payload:p});const w=1e3*p.exp,x=Date.now(),D=Math.floor((w-x)/m),O=function(e){if(void 0===e)return null;if("number"==typeof e)return 1e3*e;const r=Date.parse(e);return Number.isNaN(r)?null:r}(t.releaseDate);if(null!==O&&O>w)return y("expired",a,{daysUntilExpiry:D,payload:p});if(function(e){return"oem"===e.type||"community"===e.tier}(p)){if(x>w+(null!=(n=t.graceDays)?n:30)*m)return y("expired",a,{daysUntilExpiry:D,payload:p});if(x>w)return y("grace",a,{daysUntilExpiry:D,payload:p})}return y("active",a,{daysUntilExpiry:D,payload:p})})}function v(e,r){return{valid:!1,status:e,message:f(e,r)}}function h(e,r){const t=null==r?void 0:r.graceDays,i=null==r?void 0:r.publicKeyOverride;return{verify(r,n){return o(this,null,function*(){var a;const o=d[r],u=null!=(a=p[r])?a:"PrimeUI",c=null==n?void 0:n.releaseDate;if(!o)return v("invalid",u);const s=e[r],f=e.primeui;if(s){const e=yield g(s,{product:o,productLabel:u,releaseDate:c,graceDays:t,publicKeyOverride:i});if(e.valid)return e;if("wrong-product"!==e.status)return e}return f&&"primeui"!==r&&o.startsWith(l)?g(f,{product:o,productLabel:u,releaseDate:c,graceDays:t,publicKeyOverride:i}):v(s?"wrong-product":"missing",u)})},has(r){const t=d[r];return!!t&&(!!e[r]||"primeui"!==r&&t.startsWith(l)&&!!e.primeui)}}}var b=null;function w(e,r){if(!e)throw new Error("[@primeui/license-manager] registerLicense: keys argument is required.");return b=h(e,r)}function x(){return b}function D(e,r){var t;if(!b){const r=null!=(t=p[e])?t:"PrimeUI";return Promise.resolve({valid:!1,status:"unconfigured",message:f("unconfigured",r)})}return b.verify(e,r)}export{c as GRACE_DAYS,s as PRIMEUI_PRODUCT,l as PRIMEUI_PRO_PREFIX,d as PRODUCT_MAP,p as SHORT_NAME_LABELS,h as createLicenseService,f as formatLicenseMessage,x as getLicenseService,w as registerLicense,g as verify,D as verifyLicense};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@primeui/license-manager",
+  "version": "1.0.0-alpha.1",
+  "author": "PrimeTek Informatics",
+  "description": "Offline license verifier for PrimeUI and PrimeUI PRO",
+  "keywords": [
+    "license",
+    "ed25519",
+    "primeng",
+    "primereact",
+    "primevue",
+    "primeui"
+  ],
+  "license": "SEE LICENSE IN LICENSE.md",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/primefaces/primeuix.git",
+    "directory": "packages/license-manager"
+  },
+  "bugs": {
+    "url": "https://github.com/primefaces/primeuix/issues"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@noble/ed25519": "^2.3.0"
+  },
+  "scripts": {
+    "build": "cross-env NODE_ENV=production INPUT_DIR=src/ OUTPUT_DIR=dist/ pnpm run build:package",
+    "build:dev": "cross-env NODE_ENV=development INPUT_DIR=src/ OUTPUT_DIR=dist/ pnpm run build:dev:package",
+    "build:package": "pnpm run test && tsup",
+    "build:dev:package": "tsup --watch",
+    "test": "vitest run",
+    "type:check": "tsc --noEmit",
+    "dev:link": "pnpm link --global && npm link",
+    "keygen": "node scripts/generate-keys.mjs"
+  }
+}