@renkosky/lark-fe-skills 0.1.1 → 0.1.2

package/README.md

@@ -14,7 +14,7 @@ Lark/Feishu based Codex skills for frontend requirement planning.
 
 `@renkosky/lark-fe-skills` packages Codex skills for Lark-based frontend workflows.
 
-The first skill is `prd-fe-task`: read a Lark/Feishu requirement document, inspect configured frontend project paths, and generate a task breakdown Markdown file.
+The first packaged workflow includes `prd-fe-task` for task breakdowns and `prd-fe-schedule` for Lark Base schedule dry-runs.
 
 ## 🚀 Install
 
@@ -47,9 +47,10 @@ Use it in Codex:
 
 ## 🧰 Prerequisites
 
-Install and configure `lark-cli` first:
+Install Node.js and configure `lark-cli` first:
 
 ```bash
+npm --version
 npm install -g @larksuite/cli
 lark-cli config init
 lark-cli auth login --recommend
@@ -63,8 +64,11 @@ Official lark-cli documentation: <https://github.com/larksuite/cli/tree/main>
 lark-fe-skills list
 lark-fe-skills path
 lark-fe-skills path prd-fe-task
+lark-fe-skills path prd-fe-schedule
 lark-fe-skills install prd-fe-task
+lark-fe-skills install prd-fe-schedule
 lark-fe-skills uninstall prd-fe-task
+lark-fe-skills uninstall prd-fe-schedule
 lark-fe-skills uninstall lark-fe-task
 ```
 
@@ -73,6 +77,7 @@ lark-fe-skills uninstall lark-fe-task
 | Skill | Description |
 | --- | --- |
 | `prd-fe-task` | Turn Lark/Feishu requirement documents into concrete frontend task breakdowns. |
+| `prd-fe-schedule` | Preview Lark Base schedule records from generated frontend task Markdown. |
 
 ## 📝 Notes
 
@@ -91,11 +96,14 @@ lark-fe-skills uninstall lark-fe-task
   - [x] Inspect configured frontend project paths lightly for code-location clues.
   - [x] Generate ignored Markdown task files under the configured output directory.
 - [ ] Phase 2: Create Lark schedule tasks from generated frontend task Markdown.
-  - [ ] Accept a Lark schedule Base URL or title, then read its table schema before mapping fields.
-  - [ ] Map Markdown tasks into schedule fields such as task name, task description, task status, start time, and end time.
-  - [ ] Read custom task status options from the Base instead of inventing status tags.
-  - [ ] First version should be dry-run only and show the records that would be created without modifying Lark.
-  - [ ] A later version can add user confirmation and then create records in the schedule Base.
+  - [x] Add `prd-fe-schedule` dry-run skill.
+  - [x] Add YAML schedule profiles with comments for configurable fields, defaults, and record rules.
+  - [x] Accept a Lark schedule Base URL or title, then read its table schema before generating a profile.
+  - [x] Map Markdown tasks into schedule fields using profile rules instead of hard-coded company task types.
+  - [x] Configure and remember task classification rules with `+config-types`.
+  - [x] Read custom task status/type options from the Base instead of inventing tags.
+  - [x] Support dry-run previews from a profile without modifying Lark.
+  - [x] Add an explicit `+create` helper that requires confirmation/`--yes` before writing records.
 - [ ] Phase 3: Implement frontend tasks from generated Markdown.
   - [ ] Default to implementing one task at a time to keep human review small and manageable.
   - [ ] After each task, stop and report changed files, verification results, remaining tasks, mocks used, and unresolved questions.
@@ -120,7 +128,7 @@ lark-fe-skills uninstall lark-fe-task
 
 `@renkosky/lark-fe-skills` 用于分发基于 Lark/飞书的前端需求工作流 Codex skills。
 
-首个 skill 是 `prd-fe-task`：读取 Lark/飞书需求文档，轻量检查已配置的前端项目路径，并生成前端任务拆分 Markdown。
+首个工作流包含 `prd-fe-task` 和 `prd-fe-schedule`：前者生成前端任务拆分，后者基于任务 Markdown 生成 Lark Base 排期 dry-run 预览。
 
 ## 🚀 安装
 
@@ -153,9 +161,10 @@ npm exec --package=@renkosky/lark-fe-skills -- lark-fe-skills install prd-fe-tas
 
 ## 🧰 前置条件
 
-先安装并配置 `lark-cli`：
+先准备 Node.js，并安装配置 `lark-cli`：
 
 ```bash
+npm --version
 npm install -g @larksuite/cli
 lark-cli config init
 lark-cli auth login --recommend
@@ -169,8 +178,11 @@ lark-cli auth login --recommend
 lark-fe-skills list
 lark-fe-skills path
 lark-fe-skills path prd-fe-task
+lark-fe-skills path prd-fe-schedule
 lark-fe-skills install prd-fe-task
+lark-fe-skills install prd-fe-schedule
 lark-fe-skills uninstall prd-fe-task
+lark-fe-skills uninstall prd-fe-schedule
 lark-fe-skills uninstall lark-fe-task
 ```
 
@@ -179,6 +191,7 @@ lark-fe-skills uninstall lark-fe-task
 | Skill | 说明 |
 | --- | --- |
 | `prd-fe-task` | 将 Lark/飞书需求文档拆解成可开发的前端任务。 |
+| `prd-fe-schedule` | 根据前端任务 Markdown 预览 Lark Base 排期记录。 |
 
 ## 📝 说明
 
@@ -197,22 +210,25 @@ lark-fe-skills uninstall lark-fe-task
   - [x] 轻量检查已配置前端项目路径，补充代码定位线索。
   - [x] 在已配置输出目录下生成被 git 忽略的 Markdown 任务文件。
 - [ ] Phase 2：把已生成的前端任务 Markdown 转成 Lark 排期任务。
-  - [ ] 支持用户提供 Lark 排期 Base 链接或名称，并在映射字段前读取表结构。
-  - [ ] 将 Markdown 任务映射到任务名称、任务描述、任务状态、开始时间、结束时间等排期字段。
-  - [ ] 从 Base 读取自定义任务状态选项，不臆造状态 tag。
-  - [ ] 第一版只做 dry-run 预览，展示将要创建的记录，不修改 Lark。
-  - [ ] 后续版本再增加用户确认步骤，并在确认后写入排期 Base。
+  - [x] 新增 `prd-fe-schedule` dry-run skill。
+  - [x] 新增带注释的 YAML schedule profile，用于配置字段、默认值和记录生成规则。
+  - [x] 支持用户提供 Lark 排期 Base 链接或名称，并在生成 profile 前读取表结构。
+  - [x] 根据 profile 规则映射 Markdown 任务，不再写死某家公司任务类型。
+  - [x] 支持通过 `+config-types` 配置并记住任务分类规则。
+  - [x] 从 Base 读取自定义任务状态/类型选项，不臆造 tag。
+  - [x] 支持基于 profile 的 dry-run 预览，不修改 Lark。
+  - [x] 新增显式 `+create` helper，要求确认/`--yes` 后才写入记录。
 - [ ] Phase 3：根据已生成的 Markdown 实际开发前端任务。
   - [ ] 默认一次只实现一个 Task，控制代码改动粒度，方便人工 review。
   - [ ] 每完成一个 Task 就暂停，并汇报改动文件、验证结果、剩余任务、使用的 mock 和未解决问题。
   - [ ] 只有用户明确要求继续，或明确要求一次实现多个任务时，才继续处理后续 Task。
   - [ ] 如果单个 Task 本身过大，先拆成更小的实现批次再改代码。
   - [ ] 优先复用项目里已有的接口、hooks、stores、组件、权限、i18n 和 mock 模式，再考虑新增实现。
-  - [ ] 这一阶段不做真实后端联调；接口行为不可用时，优先使用已有可复用数据或项目 mock 体系。
+  - [ ] 这一阶段不做真实后端接口对接；接口行为不可用时，优先使用已有可复用数据或项目 mock 体系。
   - [ ] 如果 API 字段、权限 key、状态枚举或核心产品行为在代码里找不到，要先询问用户，不臆造。
   - [ ] 代码改动只限制在任务 Markdown 标出的受影响项目路径和模块内。
   - [ ] 每完成一个 Task 后运行最相关的静态检查，并明确说明是否存在无关历史失败。
-- [ ] Phase 4：接口联调与后端交付文档工作流。
+- [ ] Phase 4：接口对接与后端交付文档工作流。
   - [ ] 这部分在后端接口交付格式统一前保持待定。
   - [ ] 预期方向：继续使用 Lark 作为接口交付和协作载体。
   - [ ] 实施前需要先和后端约定文档格式，包括接口地址、请求方法、请求参数、响应结构、错误码、mock 示例和负责人。

package/bin/lark-fe-skills.js

@@ -8,8 +8,11 @@ import { homedir } from 'node:os'
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const packageRoot = resolve(__dirname, '..')
 const skillsRoot = join(packageRoot, 'skills')
-const packagedSkills = ['prd-fe-task']
+const packagedSkills = ['prd-fe-task', 'prd-fe-schedule']
 const uninstallableSkills = [...packagedSkills, 'lark-fe-task']
+const skillRuntimeDependencies = {
+  'prd-fe-schedule': ['yaml'],
+}
 
 function usage() {
   console.log(`lark-fe-skills
@@ -29,7 +32,9 @@ Commands:
 Examples:
   lark-fe-skills list
   lark-fe-skills path prd-fe-task
+  lark-fe-skills path prd-fe-schedule
   lark-fe-skills install prd-fe-task
+  lark-fe-skills install prd-fe-schedule
   lark-fe-skills uninstall prd-fe-task
   lark-fe-skills uninstall lark-fe-task`)
 }
@@ -76,6 +81,18 @@ function installSkill(skillName = 'prd-fe-task') {
   }
   cpSync(source, target, { recursive: true, force: true })
 
+  for (const dependencyName of skillRuntimeDependencies[skillName] || []) {
+    const dependencySource = join(packageRoot, 'node_modules', dependencyName)
+    const dependencyTarget = join(target, 'node_modules', dependencyName)
+    if (!existsSync(dependencySource)) {
+      console.error(`Runtime dependency not found: ${dependencyName}`)
+      console.error('Run npm install in the package before installing this skill.')
+      process.exit(1)
+    }
+    mkdirSync(dirname(dependencyTarget), { recursive: true })
+    cpSync(dependencySource, dependencyTarget, { recursive: true, force: true })
+  }
+
   console.log(`Installed ${skillName} to ${target}`)
 }
 

package/node_modules/yaml/LICENSE

@@ -0,0 +1,13 @@
+Copyright Eemeli Aro <eemeli@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

package/node_modules/yaml/README.md

@@ -0,0 +1,172 @@
+# YAML <a href="https://www.npmjs.com/package/yaml"><img align="right" src="https://badge.fury.io/js/yaml.svg" title="npm package" /></a>
+
+`yaml` is a definitive library for [YAML](https://yaml.org/), the human friendly data serialization standard.
+This library:
+
+- Supports both YAML 1.1 and YAML 1.2 and all common data schemas,
+- Passes all of the [yaml-test-suite](https://github.com/yaml/yaml-test-suite) tests,
+- Can accept any string as input without throwing, parsing as much YAML out of it as it can, and
+- Supports parsing, modifying, and writing YAML comments and blank lines.
+
+The library is released under the ISC open source license, and the code is [available on GitHub](https://github.com/eemeli/yaml/).
+It has no external dependencies and runs on Node.js as well as modern browsers.
+
+For the purposes of versioning, any changes that break any of the documented endpoints or APIs will be considered semver-major breaking changes.
+Undocumented library internals may change between minor versions, and previous APIs may be deprecated (but not removed).
+
+The minimum supported TypeScript version of the included typings is 3.9;
+for use in earlier versions you may need to set `skipLibCheck: true` in your config.
+This requirement may be updated between minor versions of the library.
+
+For more information, see the project's documentation site: [**eemeli.org/yaml**](https://eemeli.org/yaml/)
+
+For build instructions and contribution guidelines, see [docs/CONTRIBUTING.md](docs/CONTRIBUTING.md).
+
+To install:
+
+```sh
+npm install yaml
+# or
+deno add jsr:@eemeli/yaml
+```
+
+**Note:** These docs are for `yaml@2`. For v1, see the [v1.10.0 tag](https://github.com/eemeli/yaml/tree/v1.10.0) for the source and [eemeli.org/yaml/v1](https://eemeli.org/yaml/v1/) for the documentation.
+
+## API Overview
+
+The API provided by `yaml` has three layers, depending on how deep you need to go: [Parse & Stringify](https://eemeli.org/yaml/#parse-amp-stringify), [Documents](https://eemeli.org/yaml/#documents), and the underlying [Lexer/Parser/Composer](https://eemeli.org/yaml/#parsing-yaml).
+The first has the simplest API and "just works", the second gets you all the bells and whistles supported by the library along with a decent [AST](https://eemeli.org/yaml/#content-nodes), and the third lets you get progressively closer to YAML source, if that's your thing.
+
+A [command-line tool](https://eemeli.org/yaml/#command-line-tool) is also included.
+
+### Parse & Stringify
+
+```js
+import { parse, stringify } from 'yaml'
+```
+
+- [`parse(str, reviver?, options?): value`](https://eemeli.org/yaml/#yaml-parse)
+- [`stringify(value, replacer?, options?): string`](https://eemeli.org/yaml/#yaml-stringify)
+
+### Documents
+
+<!-- prettier-ignore -->
+```js
+import {
+  Document,
+  isDocument,
+  parseAllDocuments,
+  parseDocument
+} from 'yaml'
+```
+
+- [`Document`](https://eemeli.org/yaml/#documents)
+  - [`constructor(value, replacer?, options?)`](https://eemeli.org/yaml/#creating-documents)
+  - [`#contents`](https://eemeli.org/yaml/#content-nodes)
+  - [`#directives`](https://eemeli.org/yaml/#stream-directives)
+  - [`#errors`](https://eemeli.org/yaml/#errors)
+  - [`#warnings`](https://eemeli.org/yaml/#errors)
+- [`isDocument(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`parseAllDocuments(str, options?): Document[]`](https://eemeli.org/yaml/#parsing-documents)
+- [`parseDocument(str, options?): Document`](https://eemeli.org/yaml/#parsing-documents)
+
+### Content Nodes
+
+<!-- prettier-ignore -->
+```js
+import {
+  isAlias, isCollection, isMap, isNode,
+  isPair, isScalar, isSeq, Scalar,
+  visit, visitAsync, YAMLMap, YAMLSeq
+} from 'yaml'
+```
+
+- [`isAlias(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isCollection(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isMap(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isNode(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isPair(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isScalar(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isSeq(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`new Scalar(value)`](https://eemeli.org/yaml/#scalar-values)
+- [`new YAMLMap()`](https://eemeli.org/yaml/#collections)
+- [`new YAMLSeq()`](https://eemeli.org/yaml/#collections)
+- [`doc.createAlias(node, name?): Alias`](https://eemeli.org/yaml/#creating-nodes)
+- [`doc.createNode(value, options?): Node`](https://eemeli.org/yaml/#creating-nodes)
+- [`doc.createPair(key, value): Pair`](https://eemeli.org/yaml/#creating-nodes)
+- [`visit(node, visitor)`](https://eemeli.org/yaml/#finding-and-modifying-nodes)
+- [`visitAsync(node, visitor)`](https://eemeli.org/yaml/#finding-and-modifying-nodes)
+
+### Parsing YAML
+
+```js
+import { Composer, Lexer, Parser } from 'yaml'
+```
+
+- [`new Lexer().lex(src)`](https://eemeli.org/yaml/#lexer)
+- [`new Parser(onNewLine?).parse(src)`](https://eemeli.org/yaml/#parser)
+- [`new Composer(options?).compose(tokens)`](https://eemeli.org/yaml/#composer)
+
+## YAML.parse
+
+```yaml
+# file.yml
+YAML:
+  - A human-readable data serialization language
+  - https://en.wikipedia.org/wiki/YAML
+yaml:
+  - A complete JavaScript implementation
+  - https://www.npmjs.com/package/yaml
+```
+
+```js
+import fs from 'fs'
+import YAML from 'yaml'
+
+YAML.parse('3.14159')
+// 3.14159
+
+YAML.parse('[ true, false, maybe, null ]\n')
+// [ true, false, 'maybe', null ]
+
+const file = fs.readFileSync('./file.yml', 'utf8')
+YAML.parse(file)
+// { YAML:
+//   [ 'A human-readable data serialization language',
+//     'https://en.wikipedia.org/wiki/YAML' ],
+//   yaml:
+//   [ 'A complete JavaScript implementation',
+//     'https://www.npmjs.com/package/yaml' ] }
+```
+
+## YAML.stringify
+
+```js
+import YAML from 'yaml'
+
+YAML.stringify(3.14159)
+// '3.14159\n'
+
+YAML.stringify([true, false, 'maybe', null])
+// `- true
+// - false
+// - maybe
+// - null
+// `
+
+YAML.stringify({ number: 3, plain: 'string', block: 'two\nlines\n' })
+// `number: 3
+// plain: string
+// block: |
+//   two
+//   lines
+// `
+```
+
+---
+
+Browser testing provided by:
+
+<a href="https://www.browserstack.com/open-source">
+<img width=200 src="https://eemeli.org/yaml/images/browserstack.svg" alt="BrowserStack" />
+</a>

package/node_modules/yaml/bin.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+import { UserError, cli, help } from './dist/cli.mjs'
+
+cli(process.stdin, error => {
+  if (error instanceof UserError) {
+    if (error.code === UserError.ARGS) console.error(`${help}\n`)
+    console.error(error.message)
+    process.exitCode = error.code
+  } else if (error) throw error
+})

package/node_modules/yaml/browser/dist/compose/compose-collection.js

@@ -0,0 +1,88 @@
+import { isNode } from '../nodes/identity.js';
+import { Scalar } from '../nodes/Scalar.js';
+import { YAMLMap } from '../nodes/YAMLMap.js';
+import { YAMLSeq } from '../nodes/YAMLSeq.js';
+import { resolveBlockMap } from './resolve-block-map.js';
+import { resolveBlockSeq } from './resolve-block-seq.js';
+import { resolveFlowCollection } from './resolve-flow-collection.js';
+
+function resolveCollection(CN, ctx, token, onError, tagName, tag) {
+    const coll = token.type === 'block-map'
+        ? resolveBlockMap(CN, ctx, token, onError, tag)
+        : token.type === 'block-seq'
+            ? resolveBlockSeq(CN, ctx, token, onError, tag)
+            : resolveFlowCollection(CN, ctx, token, onError, tag);
+    const Coll = coll.constructor;
+    // If we got a tagName matching the class, or the tag name is '!',
+    // then use the tagName from the node class used to create it.
+    if (tagName === '!' || tagName === Coll.tagName) {
+        coll.tag = Coll.tagName;
+        return coll;
+    }
+    if (tagName)
+        coll.tag = tagName;
+    return coll;
+}
+function composeCollection(CN, ctx, token, props, onError) {
+    const tagToken = props.tag;
+    const tagName = !tagToken
+        ? null
+        : ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
+    if (token.type === 'block-seq') {
+        const { anchor, newlineAfterProp: nl } = props;
+        const lastProp = anchor && tagToken
+            ? anchor.offset > tagToken.offset
+                ? anchor
+                : tagToken
+            : (anchor ?? tagToken);
+        if (lastProp && (!nl || nl.offset < lastProp.offset)) {
+            const message = 'Missing newline after block sequence props';
+            onError(lastProp, 'MISSING_CHAR', message);
+        }
+    }
+    const expType = token.type === 'block-map'
+        ? 'map'
+        : token.type === 'block-seq'
+            ? 'seq'
+            : token.start.source === '{'
+                ? 'map'
+                : 'seq';
+    // shortcut: check if it's a generic YAMLMap or YAMLSeq
+    // before jumping into the custom tag logic.
+    if (!tagToken ||
+        !tagName ||
+        tagName === '!' ||
+        (tagName === YAMLMap.tagName && expType === 'map') ||
+        (tagName === YAMLSeq.tagName && expType === 'seq')) {
+        return resolveCollection(CN, ctx, token, onError, tagName);
+    }
+    let tag = ctx.schema.tags.find(t => t.tag === tagName && t.collection === expType);
+    if (!tag) {
+        const kt = ctx.schema.knownTags[tagName];
+        if (kt?.collection === expType) {
+            ctx.schema.tags.push(Object.assign({}, kt, { default: false }));
+            tag = kt;
+        }
+        else {
+            if (kt) {
+                onError(tagToken, 'BAD_COLLECTION_TYPE', `${kt.tag} used for ${expType} collection, but expects ${kt.collection ?? 'scalar'}`, true);
+            }
+            else {
+                onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
+            }
+            return resolveCollection(CN, ctx, token, onError, tagName);
+        }
+    }
+    const coll = resolveCollection(CN, ctx, token, onError, tagName, tag);
+    const res = tag.resolve?.(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options) ?? coll;
+    const node = isNode(res)
+        ? res
+        : new Scalar(res);
+    node.range = coll.range;
+    node.tag = tagName;
+    if (tag?.format)
+        node.format = tag.format;
+    return node;
+}
+
+export { composeCollection };

package/node_modules/yaml/browser/dist/compose/compose-doc.js

@@ -0,0 +1,43 @@
+import { Document } from '../doc/Document.js';
+import { composeNode, composeEmptyNode } from './compose-node.js';
+import { resolveEnd } from './resolve-end.js';
+import { resolveProps } from './resolve-props.js';
+
+function composeDoc(options, directives, { offset, start, value, end }, onError) {
+    const opts = Object.assign({ _directives: directives }, options);
+    const doc = new Document(undefined, opts);
+    const ctx = {
+        atKey: false,
+        atRoot: true,
+        directives: doc.directives,
+        options: doc.options,
+        schema: doc.schema
+    };
+    const props = resolveProps(start, {
+        indicator: 'doc-start',
+        next: value ?? end?.[0],
+        offset,
+        onError,
+        parentIndent: 0,
+        startOnNewline: true
+    });
+    if (props.found) {
+        doc.directives.docStart = true;
+        if (value &&
+            (value.type === 'block-map' || value.type === 'block-seq') &&
+            !props.hasNewline)
+            onError(props.end, 'MISSING_CHAR', 'Block collection cannot start on same line with directives-end marker');
+    }
+    // @ts-expect-error If Contents is set, let's trust the user
+    doc.contents = value
+        ? composeNode(ctx, value, props, onError)
+        : composeEmptyNode(ctx, props.end, start, null, props, onError);
+    const contentEnd = doc.contents.range[2];
+    const re = resolveEnd(end, contentEnd, false, onError);
+    if (re.comment)
+        doc.comment = re.comment;
+    doc.range = [offset, contentEnd, re.offset];
+    return doc;
+}
+
+export { composeDoc };

package/node_modules/yaml/browser/dist/compose/compose-node.js

@@ -0,0 +1,109 @@
+import { Alias } from '../nodes/Alias.js';
+import { isScalar } from '../nodes/identity.js';
+import { composeCollection } from './compose-collection.js';
+import { composeScalar } from './compose-scalar.js';
+import { resolveEnd } from './resolve-end.js';
+import { emptyScalarPosition } from './util-empty-scalar-position.js';
+
+const CN = { composeNode, composeEmptyNode };
+function composeNode(ctx, token, props, onError) {
+    const atKey = ctx.atKey;
+    const { spaceBefore, comment, anchor, tag } = props;
+    let node;
+    let isSrcToken = true;
+    switch (token.type) {
+        case 'alias':
+            node = composeAlias(ctx, token, onError);
+            if (anchor || tag)
+                onError(token, 'ALIAS_PROPS', 'An alias node must not specify any properties');
+            break;
+        case 'scalar':
+        case 'single-quoted-scalar':
+        case 'double-quoted-scalar':
+        case 'block-scalar':
+            node = composeScalar(ctx, token, tag, onError);
+            if (anchor)
+                node.anchor = anchor.source.substring(1);
+            break;
+        case 'block-map':
+        case 'block-seq':
+        case 'flow-collection':
+            try {
+                node = composeCollection(CN, ctx, token, props, onError);
+                if (anchor)
+                    node.anchor = anchor.source.substring(1);
+            }
+            catch (error) {
+                // Almost certainly here due to a stack overflow
+                const message = error instanceof Error ? error.message : String(error);
+                onError(token, 'RESOURCE_EXHAUSTION', message);
+            }
+            break;
+        default: {
+            const message = token.type === 'error'
+                ? token.message
+                : `Unsupported token (type: ${token.type})`;
+            onError(token, 'UNEXPECTED_TOKEN', message);
+            isSrcToken = false;
+        }
+    }
+    node ?? (node = composeEmptyNode(ctx, token.offset, undefined, null, props, onError));
+    if (anchor && node.anchor === '')
+        onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
+    if (atKey &&
+        ctx.options.stringKeys &&
+        (!isScalar(node) ||
+            typeof node.value !== 'string' ||
+            (node.tag && node.tag !== 'tag:yaml.org,2002:str'))) {
+        const msg = 'With stringKeys, all keys must be strings';
+        onError(tag ?? token, 'NON_STRING_KEY', msg);
+    }
+    if (spaceBefore)
+        node.spaceBefore = true;
+    if (comment) {
+        if (token.type === 'scalar' && token.source === '')
+            node.comment = comment;
+        else
+            node.commentBefore = comment;
+    }
+    // @ts-expect-error Type checking misses meaning of isSrcToken
+    if (ctx.options.keepSourceTokens && isSrcToken)
+        node.srcToken = token;
+    return node;
+}
+function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag, end }, onError) {
+    const token = {
+        type: 'scalar',
+        offset: emptyScalarPosition(offset, before, pos),
+        indent: -1,
+        source: ''
+    };
+    const node = composeScalar(ctx, token, tag, onError);
+    if (anchor) {
+        node.anchor = anchor.source.substring(1);
+        if (node.anchor === '')
+            onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
+    }
+    if (spaceBefore)
+        node.spaceBefore = true;
+    if (comment) {
+        node.comment = comment;
+        node.range[2] = end;
+    }
+    return node;
+}
+function composeAlias({ options }, { offset, source, end }, onError) {
+    const alias = new Alias(source.substring(1));
+    if (alias.source === '')
+        onError(offset, 'BAD_ALIAS', 'Alias cannot be an empty string');
+    if (alias.source.endsWith(':'))
+        onError(offset + source.length - 1, 'BAD_ALIAS', 'Alias ending in : is ambiguous', true);
+    const valueEnd = offset + source.length;
+    const re = resolveEnd(end, valueEnd, options.strict, onError);
+    alias.range = [offset, valueEnd, re.offset];
+    if (re.comment)
+        alias.comment = re.comment;
+    return alias;
+}
+
+export { composeEmptyNode, composeNode };