@aglyn/plugins-redirects 1.0.0-beta.221 → 1.0.0-beta.223

package/src/lib/transfer/redirects-transfer-fields.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { MatchKeySpec, TransferAliasDictionary, TransferCatalogInput, TransferField, TransferPolicyDefaults } from '@aglyn/aglyn/data-transfer';
+import { REDIRECT_KINDS } from '../model/redirects';
+/**
+ * What the redirects resource is made of, without reading anything: its key,
+ * its fields, the keys a row finds its rule by and other products' header
+ * spellings. Light on purpose — the console's boot registers the resource
+ * with these, and only an import or an export loads the module that reads
+ * and writes (`redirects-transfer.ts`).
+ */
+/** The resource key declared in `plugins.config.json` (`transferResources`). */
+export declare const REDIRECTS_TRANSFER_KEY = "redirects";
+/** The kind `/api/hosts/resources` creates a rule as, and whose declaration holds its allow-list. */
+export declare const REDIRECT_HOST_RESOURCE_KIND = "redirect";
+/** The rule's match mode, as stored. */
+export type RedirectKind = (typeof REDIRECT_KINDS)[number];
+/** Field ids, as the catalog, the plan and the export name them. */
+export declare const REDIRECT_FIELD: {
+    readonly source: "source";
+    readonly kind: "kind";
+    readonly destination: "destination";
+    readonly statusCode: "statusCode";
+    readonly priority: "priority";
+    readonly enabled: "enabled";
+    readonly approvedBy: "externalDestinationApprovedBy";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+    readonly createdBy: "createdBy";
+    readonly lastHitAt: "lastHitAt";
+    readonly hits: "hits30d";
+};
+/** The fields a file may write: the rule's own six, the create route's allow-list. */
+export declare const REDIRECT_WRITABLE_FIELDS: readonly ["source", "destination", "statusCode", "kind", "priority", "enabled"];
+/**
+ * The keys a row finds its rule by: the Aglyn ID, then the path it redirects
+ * from. The core folds the from-path only by trimming it; the lookup and the
+ * plan read it the way the redirects page stores it (lowercase, no trailing
+ * slash, no query) and within its match mode, so `/Old-Page/` finds the exact
+ * rule for `/old-page` and not the prefix rule beside it.
+ */
+export declare const REDIRECTS_MATCH_KEYS: readonly MatchKeySpec[];
+/** The field catalog: the rule, its usage, and what the platform stamps on it. */
+export declare function redirectsTransferCatalog(): TransferCatalogInput;
+/**
+ * Other products' redirect exports, by their own header spellings, so their
+ * files map without a person matching columns by hand.
+ */
+export declare const REDIRECTS_ALIAS_DICTIONARIES: readonly TransferAliasDictionary[];
+/** A Kind cell as the stored mode, or `null` when it names none. */
+export declare function canonicalRedirectKind(value: unknown): RedirectKind | null;
+/**
+ * Where an import of redirects starts: a rule already on the site takes the
+ * file's values. A redirect file is the statement of where each path goes —
+ * re-importing one with a new destination means "point it there" — so the
+ * core's fill blanks would keep every old destination and change nothing. A
+ * blank cell still leaves the rule's value alone.
+ */
+export declare const REDIRECTS_DEFAULT_POLICY: TransferPolicyDefaults;
+/**
+ * Whether a file's value and a rule's are the same as the page stores them
+ * (the review's Conflicts step and the dry run agree): a from-path by its
+ * stored form (`/Old-Page/` is `/old-page`) unless either side is a pattern,
+ * which is compared as typed; a destination by its stored form; a mode by
+ * its canonical name; a status code and a priority as numbers.
+ */
+export declare function redirectValuesEqual(field: TransferField, a: unknown, b: unknown): boolean | undefined;

package/src/lib/transfer/redirects-transfer-fields.js

@@ -0,0 +1,398 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { normalizeRedirectDestination, normalizeRedirectSource } from "../model/redirects.js";
+/**
+ * What the redirects resource is made of, without reading anything: its key,
+ * its fields, the keys a row finds its rule by and other products' header
+ * spellings. Light on purpose — the console's boot registers the resource
+ * with these, and only an import or an export loads the module that reads
+ * and writes (`redirects-transfer.ts`).
+ */ /** The resource key declared in `plugins.config.json` (`transferResources`). */ export const REDIRECTS_TRANSFER_KEY = 'redirects';
+/** The kind `/api/hosts/resources` creates a rule as, and whose declaration holds its allow-list. */ export const REDIRECT_HOST_RESOURCE_KIND = 'redirect';
+/** Field ids, as the catalog, the plan and the export name them. */ export const REDIRECT_FIELD = {
+    source: 'source',
+    kind: 'kind',
+    destination: 'destination',
+    statusCode: 'statusCode',
+    priority: 'priority',
+    enabled: 'enabled',
+    approvedBy: 'externalDestinationApprovedBy',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt',
+    createdBy: 'createdBy',
+    lastHitAt: 'lastHitAt',
+    hits: 'hits30d'
+};
+/** The fields a file may write: the rule's own six, the create route's allow-list. */ export const REDIRECT_WRITABLE_FIELDS = [
+    REDIRECT_FIELD.source,
+    REDIRECT_FIELD.destination,
+    REDIRECT_FIELD.statusCode,
+    REDIRECT_FIELD.kind,
+    REDIRECT_FIELD.priority,
+    REDIRECT_FIELD.enabled
+];
+/**
+ * The keys a row finds its rule by: the Aglyn ID, then the path it redirects
+ * from. The core folds the from-path only by trimming it; the lookup and the
+ * plan read it the way the redirects page stores it (lowercase, no trailing
+ * slash, no query) and within its match mode, so `/Old-Page/` finds the exact
+ * rule for `/old-page` and not the prefix rule beside it.
+ */ export const REDIRECTS_MATCH_KEYS = [
+    {
+        fieldId: 'id',
+        normalizer: 'aglynId'
+    },
+    {
+        fieldId: REDIRECT_FIELD.source,
+        normalizer: 'trim'
+    }
+];
+const GROUPS = [
+    {
+        id: 'rule',
+        label: 'Rule'
+    },
+    {
+        id: 'usage',
+        label: 'Usage'
+    }
+];
+/** The field catalog: the rule, its usage, and what the platform stamps on it. */ export function redirectsTransferCatalog() {
+    return {
+        groups: GROUPS,
+        standard: [
+            {
+                id: REDIRECT_FIELD.source,
+                label: 'From path',
+                group: 'rule',
+                type: 'text',
+                required: true,
+                matchKey: true,
+                description: 'The path visitors arrive at, like /old-page; for a regex rule, the pattern.',
+                aliases: [
+                    'from',
+                    'source',
+                    'source path',
+                    'from url',
+                    'old path',
+                    'old url',
+                    'redirect from',
+                    'origin',
+                    'pattern'
+                ]
+            },
+            {
+                id: REDIRECT_FIELD.kind,
+                label: 'Kind',
+                group: 'rule',
+                type: 'text',
+                description: 'exact, prefix or regex; exact when blank.',
+                aliases: [
+                    'match',
+                    'match mode',
+                    'match type',
+                    'kind',
+                    'mode',
+                    'regex'
+                ]
+            },
+            {
+                id: REDIRECT_FIELD.destination,
+                label: 'To',
+                group: 'rule',
+                type: 'text',
+                required: true,
+                description: 'A path on this site, like /new-page, or an https:// address.',
+                aliases: [
+                    'to',
+                    'destination',
+                    'target',
+                    'to url',
+                    'new path',
+                    'new url',
+                    'redirect to',
+                    'redirect url'
+                ]
+            },
+            {
+                id: REDIRECT_FIELD.statusCode,
+                label: 'Status code',
+                group: 'rule',
+                type: 'integer',
+                description: '301, 302, 307 or 308; 302 when blank.',
+                aliases: [
+                    'status',
+                    'status code',
+                    'code',
+                    'http code',
+                    'http status',
+                    'type',
+                    'redirect type'
+                ]
+            },
+            {
+                id: REDIRECT_FIELD.priority,
+                label: 'Priority',
+                group: 'rule',
+                type: 'integer',
+                description: 'Lower fires first when several rules match; 100 when blank.',
+                aliases: [
+                    'order',
+                    'position'
+                ]
+            },
+            {
+                id: REDIRECT_FIELD.enabled,
+                label: 'Enabled',
+                group: 'rule',
+                type: 'boolean',
+                description: 'Whether the rule is on; on when blank.',
+                aliases: [
+                    'active',
+                    'on',
+                    'enabled'
+                ]
+            }
+        ],
+        derived: [
+            {
+                id: REDIRECT_FIELD.hits,
+                label: 'Hits in the last 30 days',
+                group: 'usage',
+                type: 'integer',
+                readOnly: true,
+                description: 'Sampled: one per cache window with traffic.'
+            }
+        ],
+        system: [
+            {
+                id: REDIRECT_FIELD.approvedBy,
+                label: 'Off-site destination approved by',
+                type: 'text',
+                readOnly: true,
+                description: 'Who confirmed an off-site destination. Importing one approves it in your name; it is never read from a file.'
+            },
+            {
+                id: REDIRECT_FIELD.lastHitAt,
+                label: 'Last hit',
+                group: 'usage',
+                type: 'datetime',
+                readOnly: true
+            },
+            {
+                id: REDIRECT_FIELD.createdAt,
+                label: 'Created',
+                type: 'datetime',
+                readOnly: true
+            },
+            {
+                id: REDIRECT_FIELD.updatedAt,
+                label: 'Updated',
+                type: 'datetime',
+                readOnly: true
+            },
+            {
+                id: REDIRECT_FIELD.createdBy,
+                label: 'Created by',
+                type: 'text',
+                readOnly: true
+            }
+        ]
+    };
+}
+/**
+ * Other products' redirect exports, by their own header spellings, so their
+ * files map without a person matching columns by hand.
+ */ export const REDIRECTS_ALIAS_DICTIONARIES = [
+    {
+        source: 'Shopify URL redirects',
+        aliases: {
+            [REDIRECT_FIELD.source]: [
+                'Redirect from'
+            ],
+            [REDIRECT_FIELD.destination]: [
+                'Redirect to'
+            ]
+        }
+    },
+    {
+        source: 'WordPress Redirection',
+        aliases: {
+            [REDIRECT_FIELD.source]: [
+                'source'
+            ],
+            [REDIRECT_FIELD.destination]: [
+                'target'
+            ],
+            [REDIRECT_FIELD.statusCode]: [
+                'code'
+            ],
+            [REDIRECT_FIELD.kind]: [
+                'regex'
+            ]
+        }
+    },
+    {
+        source: 'Yoast SEO redirects',
+        aliases: {
+            [REDIRECT_FIELD.source]: [
+                'Origin'
+            ],
+            [REDIRECT_FIELD.destination]: [
+                'Target'
+            ],
+            [REDIRECT_FIELD.statusCode]: [
+                'Type'
+            ],
+            [REDIRECT_FIELD.kind]: [
+                'Format'
+            ]
+        }
+    },
+    {
+        source: 'Wix URL redirects',
+        aliases: {
+            [REDIRECT_FIELD.source]: [
+                'Old URL'
+            ],
+            [REDIRECT_FIELD.destination]: [
+                'New URL'
+            ]
+        }
+    },
+    {
+        source: 'Webflow 301 redirects',
+        aliases: {
+            [REDIRECT_FIELD.source]: [
+                'Old path'
+            ],
+            [REDIRECT_FIELD.destination]: [
+                'Redirect to path'
+            ]
+        }
+    },
+    {
+        source: 'Spreadsheet',
+        aliases: {
+            [REDIRECT_FIELD.source]: [
+                'Source',
+                'From',
+                'Old'
+            ],
+            [REDIRECT_FIELD.destination]: [
+                'Destination',
+                'Target',
+                'To',
+                'New'
+            ],
+            [REDIRECT_FIELD.statusCode]: [
+                'Status',
+                'Type',
+                'HTTP status code'
+            ]
+        }
+    }
+];
+/**
+ * The spellings a file's Kind cell may take, read to the stored mode. Covers
+ * the console's own labels ("Path prefix"), the words other products use,
+ * and a yes/no "regex" column (the WordPress Redirection export's).
+ * Yoast's Format column says `plain` or `regex`.
+ */ const KIND_SPELLINGS = {
+    exact: 'exact',
+    'exact path': 'exact',
+    'exact match': 'exact',
+    plain: 'exact',
+    path: 'exact',
+    page: 'exact',
+    '0': 'exact',
+    no: 'exact',
+    false: 'exact',
+    prefix: 'prefix',
+    'path prefix': 'prefix',
+    'starts with': 'prefix',
+    folder: 'prefix',
+    directory: 'prefix',
+    regex: 'regex',
+    regexp: 'regex',
+    'regular expression': 'regex',
+    pattern: 'regex',
+    '1': 'regex',
+    yes: 'regex',
+    true: 'regex'
+};
+/** A Kind cell as the stored mode, or `null` when it names none. */ export function canonicalRedirectKind(value) {
+    var _KIND_SPELLINGS_text;
+    if (typeof value === 'boolean') return value ? 'regex' : 'exact';
+    const text = String(value != null ? value : '').trim().toLowerCase().replace(/\s+/g, ' ');
+    return (_KIND_SPELLINGS_text = KIND_SPELLINGS[text]) != null ? _KIND_SPELLINGS_text : null;
+}
+/**
+ * Where an import of redirects starts: a rule already on the site takes the
+ * file's values. A redirect file is the statement of where each path goes —
+ * re-importing one with a new destination means "point it there" — so the
+ * core's fill blanks would keep every old destination and change nothing. A
+ * blank cell still leaves the rule's value alone.
+ */ export const REDIRECTS_DEFAULT_POLICY = {
+    fieldDefault: {
+        mode: 'overwrite',
+        blank: 'leave'
+    },
+    note: 'A redirect file says where each path goes, so a rule already on the site takes the ' + 'file’s destination, status, priority and on/off. Choose Fill blanks to keep what the site has.'
+};
+const textOf = (value)=>typeof value === 'string' ? value : '';
+const isBlankCell = (value)=>value === null || value === undefined || typeof value === 'string' && !value.trim();
+/** Characters only a pattern holds; a path compared with one is compared as typed. */ const PATTERN_CHARACTERS = /[\^$*+?()[\]{}|\\]/;
+/**
+ * Whether a file's value and a rule's are the same as the page stores them
+ * (the review's Conflicts step and the dry run agree): a from-path by its
+ * stored form (`/Old-Page/` is `/old-page`) unless either side is a pattern,
+ * which is compared as typed; a destination by its stored form; a mode by
+ * its canonical name; a status code and a priority as numbers.
+ */ export function redirectValuesEqual(field, a, b) {
+    if (isBlankCell(a) || isBlankCell(b)) return undefined;
+    switch(field.id){
+        case REDIRECT_FIELD.source:
+            {
+                const left = textOf(a).trim();
+                const right = textOf(b).trim();
+                if (PATTERN_CHARACTERS.test(left) || PATTERN_CHARACTERS.test(right)) return left === right;
+                const stored = normalizeRedirectSource(left);
+                return stored !== null && stored === normalizeRedirectSource(right) ? true : left === right;
+            }
+        case REDIRECT_FIELD.destination:
+            {
+                const stored = normalizeRedirectDestination(textOf(a));
+                return stored !== null && stored === normalizeRedirectDestination(textOf(b)) ? true : textOf(a).trim() === textOf(b).trim();
+            }
+        case REDIRECT_FIELD.kind:
+            {
+                const kind = canonicalRedirectKind(a);
+                return kind !== null && kind === canonicalRedirectKind(b) ? true : undefined;
+            }
+        case REDIRECT_FIELD.statusCode:
+        case REDIRECT_FIELD.priority:
+            {
+                const left = Number(a);
+                const right = Number(b);
+                return Number.isFinite(left) && Number.isFinite(right) ? left === right : undefined;
+            }
+        default:
+            return undefined;
+    }
+}
+
+//# sourceMappingURL=redirects-transfer-fields.js.map

package/src/lib/transfer/redirects-transfer-fields.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/redirects/src/lib/transfer/redirects-transfer-fields.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type {\n  MatchKeySpec,\n  TransferAliasDictionary,\n  TransferCatalogInput,\n  TransferField,\n  TransferPolicyDefaults,\n} from '@aglyn/aglyn/data-transfer'\nimport { REDIRECT_KINDS, normalizeRedirectDestination, normalizeRedirectSource } from '../model/redirects'\n\n/**\n * What the redirects resource is made of, without reading anything: its key,\n * its fields, the keys a row finds its rule by and other products' header\n * spellings. Light on purpose — the console's boot registers the resource\n * with these, and only an import or an export loads the module that reads\n * and writes (`redirects-transfer.ts`).\n */\n\n/** The resource key declared in `plugins.config.json` (`transferResources`). */\nexport const REDIRECTS_TRANSFER_KEY = 'redirects'\n\n/** The kind `/api/hosts/resources` creates a rule as, and whose declaration holds its allow-list. */\nexport const REDIRECT_HOST_RESOURCE_KIND = 'redirect'\n\n/** The rule's match mode, as stored. */\nexport type RedirectKind = (typeof REDIRECT_KINDS)[number]\n\n/** Field ids, as the catalog, the plan and the export name them. */\nexport const REDIRECT_FIELD = {\n  source: 'source',\n  kind: 'kind',\n  destination: 'destination',\n  statusCode: 'statusCode',\n  priority: 'priority',\n  enabled: 'enabled',\n  approvedBy: 'externalDestinationApprovedBy',\n  createdAt: 'createdAt',\n  updatedAt: 'updatedAt',\n  createdBy: 'createdBy',\n  lastHitAt: 'lastHitAt',\n  hits: 'hits30d',\n} as const\n\n/** The fields a file may write: the rule's own six, the create route's allow-list. */\nexport const REDIRECT_WRITABLE_FIELDS = [\n  REDIRECT_FIELD.source,\n  REDIRECT_FIELD.destination,\n  REDIRECT_FIELD.statusCode,\n  REDIRECT_FIELD.kind,\n  REDIRECT_FIELD.priority,\n  REDIRECT_FIELD.enabled,\n] as const\n\n/**\n * The keys a row finds its rule by: the Aglyn ID, then the path it redirects\n * from. The core folds the from-path only by trimming it; the lookup and the\n * plan read it the way the redirects page stores it (lowercase, no trailing\n * slash, no query) and within its match mode, so `/Old-Page/` finds the exact\n * rule for `/old-page` and not the prefix rule beside it.\n */\nexport const REDIRECTS_MATCH_KEYS: readonly MatchKeySpec[] = [\n  { fieldId: 'id', normalizer: 'aglynId' },\n  { fieldId: REDIRECT_FIELD.source, normalizer: 'trim' },\n]\n\nconst GROUPS = [\n  { id: 'rule', label: 'Rule' },\n  { id: 'usage', label: 'Usage' },\n]\n\n/** The field catalog: the rule, its usage, and what the platform stamps on it. */\nexport function redirectsTransferCatalog(): TransferCatalogInput {\n  return {\n    groups: GROUPS,\n    standard: [\n      {\n        id: REDIRECT_FIELD.source,\n        label: 'From path',\n        group: 'rule',\n        type: 'text',\n        required: true,\n        matchKey: true,\n        description:\n          'The path visitors arrive at, like /old-page; for a regex rule, the pattern.',\n        aliases: ['from', 'source', 'source path', 'from url', 'old path', 'old url', 'redirect from', 'origin', 'pattern'],\n      },\n      {\n        id: REDIRECT_FIELD.kind,\n        label: 'Kind',\n        group: 'rule',\n        type: 'text',\n        description: 'exact, prefix or regex; exact when blank.',\n        aliases: ['match', 'match mode', 'match type', 'kind', 'mode', 'regex'],\n      },\n      {\n        id: REDIRECT_FIELD.destination,\n        label: 'To',\n        group: 'rule',\n        type: 'text',\n        required: true,\n        description: 'A path on this site, like /new-page, or an https:// address.',\n        aliases: ['to', 'destination', 'target', 'to url', 'new path', 'new url', 'redirect to', 'redirect url'],\n      },\n      {\n        id: REDIRECT_FIELD.statusCode,\n        label: 'Status code',\n        group: 'rule',\n        type: 'integer',\n        description: '301, 302, 307 or 308; 302 when blank.',\n        aliases: ['status', 'status code', 'code', 'http code', 'http status', 'type', 'redirect type'],\n      },\n      {\n        id: REDIRECT_FIELD.priority,\n        label: 'Priority',\n        group: 'rule',\n        type: 'integer',\n        description: 'Lower fires first when several rules match; 100 when blank.',\n        aliases: ['order', 'position'],\n      },\n      {\n        id: REDIRECT_FIELD.enabled,\n        label: 'Enabled',\n        group: 'rule',\n        type: 'boolean',\n        description: 'Whether the rule is on; on when blank.',\n        aliases: ['active', 'on', 'enabled'],\n      },\n    ],\n    derived: [\n      {\n        id: REDIRECT_FIELD.hits,\n        label: 'Hits in the last 30 days',\n        group: 'usage',\n        type: 'integer',\n        readOnly: true,\n        description: 'Sampled: one per cache window with traffic.',\n      },\n    ],\n    system: [\n      {\n        id: REDIRECT_FIELD.approvedBy,\n        label: 'Off-site destination approved by',\n        type: 'text',\n        readOnly: true,\n        description:\n          'Who confirmed an off-site destination. Importing one approves it in your name; it is never read from a file.',\n      },\n      { id: REDIRECT_FIELD.lastHitAt, label: 'Last hit', group: 'usage', type: 'datetime', readOnly: true },\n      { id: REDIRECT_FIELD.createdAt, label: 'Created', type: 'datetime', readOnly: true },\n      { id: REDIRECT_FIELD.updatedAt, label: 'Updated', type: 'datetime', readOnly: true },\n      { id: REDIRECT_FIELD.createdBy, label: 'Created by', type: 'text', readOnly: true },\n    ],\n  }\n}\n\n/**\n * Other products' redirect exports, by their own header spellings, so their\n * files map without a person matching columns by hand.\n */\nexport const REDIRECTS_ALIAS_DICTIONARIES: readonly TransferAliasDictionary[] = [\n  {\n    source: 'Shopify URL redirects',\n    aliases: {\n      [REDIRECT_FIELD.source]: ['Redirect from'],\n      [REDIRECT_FIELD.destination]: ['Redirect to'],\n    },\n  },\n  {\n    source: 'WordPress Redirection',\n    aliases: {\n      [REDIRECT_FIELD.source]: ['source'],\n      [REDIRECT_FIELD.destination]: ['target'],\n      [REDIRECT_FIELD.statusCode]: ['code'],\n      [REDIRECT_FIELD.kind]: ['regex'],\n    },\n  },\n  {\n    source: 'Yoast SEO redirects',\n    aliases: {\n      [REDIRECT_FIELD.source]: ['Origin'],\n      [REDIRECT_FIELD.destination]: ['Target'],\n      [REDIRECT_FIELD.statusCode]: ['Type'],\n      [REDIRECT_FIELD.kind]: ['Format'],\n    },\n  },\n  {\n    source: 'Wix URL redirects',\n    aliases: {\n      [REDIRECT_FIELD.source]: ['Old URL'],\n      [REDIRECT_FIELD.destination]: ['New URL'],\n    },\n  },\n  {\n    source: 'Webflow 301 redirects',\n    aliases: {\n      [REDIRECT_FIELD.source]: ['Old path'],\n      [REDIRECT_FIELD.destination]: ['Redirect to path'],\n    },\n  },\n  {\n    source: 'Spreadsheet',\n    aliases: {\n      [REDIRECT_FIELD.source]: ['Source', 'From', 'Old'],\n      [REDIRECT_FIELD.destination]: ['Destination', 'Target', 'To', 'New'],\n      [REDIRECT_FIELD.statusCode]: ['Status', 'Type', 'HTTP status code'],\n    },\n  },\n]\n\n/**\n * The spellings a file's Kind cell may take, read to the stored mode. Covers\n * the console's own labels (\"Path prefix\"), the words other products use,\n * and a yes/no \"regex\" column (the WordPress Redirection export's).\n * Yoast's Format column says `plain` or `regex`.\n */\nconst KIND_SPELLINGS: Readonly<Record<string, RedirectKind>> = {\n  exact: 'exact',\n  'exact path': 'exact',\n  'exact match': 'exact',\n  plain: 'exact',\n  path: 'exact',\n  page: 'exact',\n  '0': 'exact',\n  no: 'exact',\n  false: 'exact',\n  prefix: 'prefix',\n  'path prefix': 'prefix',\n  'starts with': 'prefix',\n  folder: 'prefix',\n  directory: 'prefix',\n  regex: 'regex',\n  regexp: 'regex',\n  'regular expression': 'regex',\n  pattern: 'regex',\n  '1': 'regex',\n  yes: 'regex',\n  true: 'regex',\n}\n\n/** A Kind cell as the stored mode, or `null` when it names none. */\nexport function canonicalRedirectKind(value: unknown): RedirectKind | null {\n  if (typeof value === 'boolean') return value ? 'regex' : 'exact'\n  const text = String(value ?? '')\n    .trim()\n    .toLowerCase()\n    .replace(/\\s+/g, ' ')\n  return KIND_SPELLINGS[text] ?? null\n}\n\n/**\n * Where an import of redirects starts: a rule already on the site takes the\n * file's values. A redirect file is the statement of where each path goes —\n * re-importing one with a new destination means \"point it there\" — so the\n * core's fill blanks would keep every old destination and change nothing. A\n * blank cell still leaves the rule's value alone.\n */\nexport const REDIRECTS_DEFAULT_POLICY: TransferPolicyDefaults = {\n  fieldDefault: { mode: 'overwrite', blank: 'leave' },\n  note:\n    'A redirect file says where each path goes, so a rule already on the site takes the ' +\n    'file’s destination, status, priority and on/off. Choose Fill blanks to keep what the site has.',\n}\n\nconst textOf = (value: unknown): string => (typeof value === 'string' ? value : '')\nconst isBlankCell = (value: unknown): boolean =>\n  value === null || value === undefined || (typeof value === 'string' && !value.trim())\n\n/** Characters only a pattern holds; a path compared with one is compared as typed. */\nconst PATTERN_CHARACTERS = /[\\^$*+?()[\\]{}|\\\\]/\n\n/**\n * Whether a file's value and a rule's are the same as the page stores them\n * (the review's Conflicts step and the dry run agree): a from-path by its\n * stored form (`/Old-Page/` is `/old-page`) unless either side is a pattern,\n * which is compared as typed; a destination by its stored form; a mode by\n * its canonical name; a status code and a priority as numbers.\n */\nexport function redirectValuesEqual(field: TransferField, a: unknown, b: unknown): boolean | undefined {\n  if (isBlankCell(a) || isBlankCell(b)) return undefined\n  switch (field.id) {\n    case REDIRECT_FIELD.source: {\n      const left = textOf(a).trim()\n      const right = textOf(b).trim()\n      if (PATTERN_CHARACTERS.test(left) || PATTERN_CHARACTERS.test(right)) return left === right\n      const stored = normalizeRedirectSource(left)\n      return stored !== null && stored === normalizeRedirectSource(right) ? true : left === right\n    }\n    case REDIRECT_FIELD.destination: {\n      const stored = normalizeRedirectDestination(textOf(a))\n      return stored !== null && stored === normalizeRedirectDestination(textOf(b)) ? true : textOf(a).trim() === textOf(b).trim()\n    }\n    case REDIRECT_FIELD.kind: {\n      const kind = canonicalRedirectKind(a)\n      return kind !== null && kind === canonicalRedirectKind(b) ? true : undefined\n    }\n    case REDIRECT_FIELD.statusCode:\n    case REDIRECT_FIELD.priority: {\n      const left = Number(a)\n      const right = Number(b)\n      return Number.isFinite(left) && Number.isFinite(right) ? left === right : undefined\n    }\n    default:\n      return undefined\n  }\n}\n"],"names":["normalizeRedirectDestination","normalizeRedirectSource","REDIRECTS_TRANSFER_KEY","REDIRECT_HOST_RESOURCE_KIND","REDIRECT_FIELD","source","kind","destination","statusCode","priority","enabled","approvedBy","createdAt","updatedAt","createdBy","lastHitAt","hits","REDIRECT_WRITABLE_FIELDS","REDIRECTS_MATCH_KEYS","fieldId","normalizer","GROUPS","id","label","redirectsTransferCatalog","groups","standard","group","type","required","matchKey","description","aliases","derived","readOnly","system","REDIRECTS_ALIAS_DICTIONARIES","KIND_SPELLINGS","exact","plain","path","page","no","false","prefix","folder","directory","regex","regexp","pattern","yes","true","canonicalRedirectKind","value","text","String","trim","toLowerCase","replace","REDIRECTS_DEFAULT_POLICY","fieldDefault","mode","blank","note","textOf","isBlankCell","undefined","PATTERN_CHARACTERS","redirectValuesEqual","field","a","b","left","right","test","stored","Number","isFinite"],"mappings":"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"}

package/src/lib/transfer/redirects-transfer.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { checkEntitlement } from '@aglyn/aglyn/app-utils/plan-entitlements';
+import { type RowMatchOutcome } from '@aglyn/aglyn/data-transfer';
+import { type ResolvedPluginHostResource } from '@aglyn/aglyn/plugin-manager/plugin-host-resources';
+import type { PluginTransferResource } from '@aglyn/aglyn/plugin-manager/plugin-transfer-resources';
+/** The billing document a plan's entitlement and counter are read from. */
+type OrgBilling = Parameters<typeof checkEntitlement>[0];
+export interface RedirectsTransferDeps {
+    firestore: FirebaseFirestore.Firestore;
+    /** Defaults to `Date.now`. */
+    now?: () => number;
+    /** The site's owning workspace's billing document (`getOrgForHost`); `null` reads as the free plan. */
+    loadOrg(hostId: string): Promise<OrgBilling | null>;
+    /**
+     * Drops the site's cached pages at these addresses, best effort. Defaults
+     * to the platform's site cache (`dropPluginSiteCache`), the announcement
+     * the create route makes for a new rule.
+     */
+    announcePaths?(hostId: string, paths: readonly string[]): Promise<void>;
+    /** Writes the site activity line for a created rule, best effort. */
+    logCreated?(hostId: string, actorUid: string, ruleId: string, resource: ResolvedPluginHostResource): Promise<void>;
+}
+type StoredRule = Record<string, unknown>;
+/**
+ * A stored rule's fields as the redirects page reads them into its editor: a
+ * missing mode is exact, a missing priority 100, a status code outside the
+ * four is 302 (as the serve path reads it), and a rule is on unless it says
+ * `false`. The export, the dry run's "before" and undo all read this, so a
+ * file exported and imported back is unchanged.
+ */
+export declare function redirectRuleValues(id: string, data: StoredRule): Record<string, unknown>;
+/**
+ * Each row's rule, as the page tells rules apart: a row the engine found by
+ * its id keeps that rule; any other row is the rule of its mode (exact when
+ * the file gives none) at its from-path as stored — so `/blog` names the
+ * exact rule or the prefix rule beside it by the row's mode, never both.
+ * Two rows naming one rule are both matched to it here, and the plan refuses
+ * the later one, saying which row it repeats, rather than holding it back as
+ * a duplicate. `existing` holds every live rule's values by id; running this
+ * over its own outcomes changes nothing.
+ */
+export declare function redirectMatchOutcomes(rows: ReadonlyArray<Readonly<Record<string, unknown>>>, engine: readonly RowMatchOutcome[], existing: ReadonlyMap<string, Readonly<Record<string, unknown>>>, live: ReadonlyArray<{
+    id: string;
+    data: StoredRule;
+}>): RowMatchOutcome[];
+/**
+ * The id a rule an import creates is written under: the job's row, so a
+ * write retried after it landed and before the ledger recorded it finds its
+ * own rule instead of making a second one. Without a job, a fresh resource id.
+ */
+export declare function importedRedirectId(jobId: string | undefined, row: number): string;
+/**
+ * The redirects resource over `deps.firestore`: `hosts/{hostId}/redirects`,
+ * with every hook the job engine and the export route call. See the block
+ * above for what each write checks.
+ */
+export declare function createRedirectsTransferResource(deps: RedirectsTransferDeps): PluginTransferResource;
+export {};